예제 #1
0
    def reset_game(self, player=None, territory=None):
        """reset the score of the game

        player is the player which should be awarded the necessary captures to
        end the game
        """
        self.team_1.initialize()
        self.team_2.initialize()
        if self.game_mode == CTF_MODE:
            if player is None:
                player = list(self.players.values())[0]
            intel_capture = loaders.IntelCapture()
            intel_capture.player_id = player.player_id
            intel_capture.winning = True
            self.send_contained(intel_capture, save=True)
        elif self.game_mode == TC_MODE:
            if territory is None:
                territory = self.entities[0]
            territory_capture = loaders.TerritoryCapture()
            territory_capture.object_index = territory.id
            territory_capture.winning = True
            territory_capture.state = territory.team.id
            self.send_contained(territory_capture)
            self.reset_tc()
        for entity in self.entities:
            entity.update()
        for player in self.players.values():
            if player.team is not None:
                player.spawn()
예제 #2
0
 def score(self):
     if self.protocol.game_mode != CTF_MODE:
         return
     if self.player_id in self.protocol.players:
         self.acquire_player_id()
     if self.player_id is None and not self.acquire_player_id():
         return
     winning = (self.protocol.max_score not in (0, None)
                and self.team.score + 1 >= self.protocol.max_score)
     self.team.score += 1
     intel_capture = loaders.IntelCapture()
     intel_capture.player_id = self.player_id
     intel_capture.winning = winning
     self.protocol.broadcast_contained(intel_capture, save=True)
     if winning:
         self.team.initialize()
         self.team.other.initialize()
         for entity in self.protocol.entities:
             entity.update()
         for player in list(self.protocol.players.values()):
             player.hp = None
             if player.team is not None:
                 player.spawn()
         self.protocol.on_game_end()
     else:
         flag = self.team.other.set_flag()
         flag.update()
예제 #3
0
    def __init__(self, protocol):
        self.protocol = protocol
        self.green_flag = protocol.green_team.flag
        self.blue_flag = protocol.blue_team.flag

        self.state_loader = loaders.CTFState()
        self.drop_intel_loader = loaders.IntelDrop()
        self.drop_pickup_loader = loaders.IntelPickup()
        self.drop_capture_loader = loaders.IntelCapture()
예제 #4
0
    def __init__(self, protocol):
        self.protocol = protocol
        self.team_1 = protocol.team_1
        self.team_2 = protocol.team_2

        self.state_loader = loaders.CTFState()
        self.intel_drop_loader = loaders.IntelDrop()
        self.intel_pickup_loader = loaders.IntelPickup()
        self.intel_capture_loader = loaders.IntelCapture()

        # player carrying team_1's intel, not the team_1 member carrying the
        # intel
        # This should probably be reversed as it's pretty confusing
        self.team_1_carrier = None
        self.team_2_carrier = None
예제 #5
0
from pyspades.constants import *
from pyspades.packet import call_packet_handler, register_packet_handler
from pyspades import contained as loaders
from pyspades.collision import vector_collision, collision_3d
from pyspades import world
from pyspades.common import Vertex3, get_color, make_color
from pyspades.weapon import WEAPONS
from pyspades.mapgenerator import ProgressiveMapGenerator

set_tool = loaders.SetTool()
block_action = loaders.BlockAction()
position_data = loaders.PositionData()
restock = loaders.Restock()
create_player = loaders.CreatePlayer()
intel_pickup = loaders.IntelPickup()
intel_capture = loaders.IntelCapture()
intel_drop = loaders.IntelDrop()
player_left = loaders.PlayerLeft()
set_hp = loaders.SetHP()
existing_player = loaders.ExistingPlayer()
kill_action = loaders.KillAction()
chat_message = loaders.ChatMessage()
map_data = loaders.MapChunk()
map_start = loaders.MapStart()
state_data = loaders.StateData()
ctf_data = loaders.CTFState()
tc_data = loaders.TCState()
change_weapon = loaders.ChangeWeapon()
weapon_reload = loaders.WeaponReload()
handshake_init = loaders.HandShakeInit()
version_request = loaders.VersionRequest()