class ReplayPlayer(Hub): ''' Emulates a normal server by outputting the same messages that a server once did. ''' def __init__(self, filename, *args, **kwargs): super(ReplayPlayer, self).__init__(*args, **kwargs) self.tickPeriod = TICK_PERIOD self.finished = False self.loop = WeakLoopingCall(self, 'tick') self.agentIds = [] self.nextAgentId = 0 self.settings, self.msgIterator = readReplay(open(filename, 'rb')) def popSettings(self): result, self.settings = self.settings, None return result def start(self): self.loop.start(self.tickPeriod) def stop(self): if self.loop.running: self.loop.stop() def tick(self): while True: try: msg = next(self.msgIterator) except StopIteration: self.finished = True if self.node: while self.agentIds: agentId = self.agentIds.pop(0) # Give 2 seconds before ending the replay reactor.callLater(2, self.node.agentDisconnected, agentId) self.loop.stop() break self.node.gotServerCommand(msg) if isinstance(msg, TickMsg): break def connectNewAgent(self, authTag=0): agentId = self.nextAgentId self.nextAgentId += 1 self.agentIds.append(agentId) return agentId def disconnectAgent(self, agentId): self.agentIds.remove(agentId) def sendRequestToGame(self, agentId, msg): pass
class StartGameWhenReadyTrigger(Trigger): def __init__(self, level): super(StartGameWhenReadyTrigger, self).__init__(level) self.loop = WeakLoopingCall(self, 'check') def doActivate(self): if not self.loop.running: self.loop.start(3, False) def doDeactivate(self): if self.loop.running: self.loop.stop() def check(self): try: self.world.voteArbiter.startNewGameIfReady() except Exception: log.exception('Error trying to start new game')
class AchievementManager(object): SAVE_PERIOD = 20 achievementDefs = availableAchievements def __init__(self, game): self.game = game self.world = world = game.world self.lastSave = timeNow() # All players recorded this game, indexed by user id. self.allPlayers = {} defs = self.achievementDefs self.oncePerGameAchievements = [c(world) for c in defs.oncePerGame] self.oncePerTeamPerGameAchievements = [ c(world, team) for c in defs.oncePerTeamPerGame for team in world.teams ] self.loop = WeakLoopingCall(self, 'save') self.started = False self.stopped = False def save(self, force=False): for playerAchievements in list(self.allPlayers.values()): playerAchievements.saveProgress(force=force) def start(self): assert not self.started self.started = True for player in self.world.players: self.playerAdded(player) self.world.onPlayerAdded.addListener(self.playerAdded) self.loop.start(self.SAVE_PERIOD) for a in self.oncePerGameAchievements: a.onUnlocked.addListener(self.achievementUnlocked) a.start() for a in self.oncePerTeamPerGameAchievements: a.start() a.onUnlocked.addListener(self.achievementUnlocked) def stop(self): assert not self.stopped self.stopped = True self.loop.stop() self.world.onPlayerAdded.removeListener(self.playerAdded) self.save(force=True) for a in self.oncePerGameAchievements: a.stop() a.onUnlocked.removeListener(self.achievementUnlocked) for a in self.oncePerTeamPerGameAchievements: a.stop() a.onUnlocked.removeListener(self.achievementUnlocked) for p in list(self.allPlayers.values()): p.stop() @defer.inlineCallbacks def playerAdded(self, player): if self.world.isServer and not player.joinComplete: # We want to identify by user rather than nickname if the user # is authenticated. yield player.onJoinComplete.wait() name = player.identifyingName if name not in self.allPlayers: a = PlayerAchievements(self, player) self.allPlayers[name] = a a.start() else: self.allPlayers[name].rejoined(player) def triggerAchievement(self, player, achievementId): ''' Called from stats manager to trigger a stats-related achievement. Never raises an exception. ''' try: a = self.allPlayers[ player.identifyingName].achievements[achievementId] a.achievementTriggered() except Exception: log.exception('Error triggering achievement') def achievementUnlocked(self, achievement, player): if player.user is not None: player.user.achievementUnlocked(achievement.idstring) self.game.sendServerCommand( AchievementUnlockedMsg(player.id, achievement.idstring))
class AddBotsForLobbyTrigger(Trigger): ''' Adds a number of bots so even a single player can mess around in the lobby until others arrive. Keeps the total number of bots at least up to a particular minimum, adding and removing bots as necessary. ''' def __init__(self, level, playerCount=6): from trosnoth.bots.base import listAIs super(AddBotsForLobbyTrigger, self).__init__(level) self.playerCount = playerCount self.loop = WeakLoopingCall(self, 'recheck') self.agents = [] self.newAgents = set() self.aiNames = listAIs(playableOnly=True) def doActivate(self): if not self.loop.running: self.loop.start(3, False) def doDeactivate(self): if self.loop.running: self.loop.stop() self._stopAllAgents() @defer.inlineCallbacks def recheck(self): self._graduateNewAgents() yield self._adjustAgentsToTarget() def _graduateNewAgents(self): for agent in list(self.newAgents): if agent.player is not None: self.agents.append(agent) self.newAgents.remove(agent) def _stopAllAgents(self): if len(self.agents) != 0: log.info('AIInjector: Stopping all agents') for agent in self.agents: agent.stop() self.world.game.detachAgent(agent) self.agents = [] @defer.inlineCallbacks def _adjustAgentsToTarget(self): worldPlayers = len(self.world.game.world.players) newAgents = len(self.newAgents) if self.playerCount > worldPlayers + newAgents: yield self._addAgents(self.playerCount - worldPlayers - newAgents) else: self._removeAgents(worldPlayers + newAgents - self.playerCount) @defer.inlineCallbacks def _addAgents(self, count): log.info('AIInjector: Adding %d agents', count) for i in range(count): agent = yield self.world.game.addBot(random.choice(self.aiNames)) self.newAgents.add(agent) def _removeAgents(self, count): if count != 0: log.info('AIInjector: Removing %d agents', count) for i in range(count): if len(self.agents) == 0: break agent = self.agents.pop(0) agent.stop() self.world.game.detachAgent(agent)
class AchievementBox(framework.CompoundElement): achievementDefs = availableAchievements def __init__(self, app, player, achievementId): super(AchievementBox, self).__init__(app) self.app = app self.player = player self.achievements = [achievementId] self.width = 453 self.height = 75 self._setColours() self.area = Area( FullScreenAttachedPoint(ScaledSize(0, -100), 'midbottom'), ScaledSize(self.width, self.height), 'midbottom') self.smlBox = Area( FullScreenAttachedPoint(ScaledSize(-self.width / 2 + 6, -104), 'midbottom'), ScaledSize(66, 66), 'bottomleft') self.titleText = TextElement( self.app, "ACHIEVEMENT UNLOCKED!", self.fonts.achievementTitleFont, Location( FullScreenAttachedPoint( ScaledSize(73 / 2, -100 - self.height + 10), 'midbottom'), 'midtop'), self.borderColour) self.nameText = TextElement( self.app, self.achievementDefs.getAchievementDetails(achievementId)[0], self.fonts.achievementNameFont, Location( FullScreenAttachedPoint(ScaledSize(73 / 2, -100 - 13), 'midbottom'), 'midbottom'), self.colours.black) self.elements = [self.titleText, self.nameText] self._updateImage() self.cycler = WeakLoopingCall(self, 'cycleAchievements') self.cycler.start(5.0, now=False) def addAchievement(self, achievementId): self.achievements.append(achievementId) self.titleText.setText("%d ACHIEVEMENTS UNLOCKED!" % len(self.achievements)) def _updateImage(self): try: filepath = self.app.theme.getPath('achievements', '%s.png' % self.achievements[0]) except IOError: filepath = self.app.theme.getPath('achievements', 'default.png') image = pygame.image.load(filepath).convert() image = pygame.transform.smoothscale( image, ScaledSize(64, 64).getSize(self.app)) if type(self.elements[-1]) == PictureElement: self.elements.pop() self.image = PictureElement( self.app, image, Location( FullScreenAttachedPoint(ScaledSize(-self.width / 2 + 7, -105), 'midbottom'), 'bottomleft')) self.elements.append(self.image) def cycleAchievements(self): del self.achievements[0] if len(self.achievements) == 0: self.cycler.stop() return elif len(self.achievements) == 1: self.titleText.setText("ACHIEVEMENT UNLOCKED!") else: self.titleText.setText("%d ACHIEVEMENTS UNLOCKED!" % len(self.achievements)) self.nameText.setText( self.achievementDefs.getAchievementDetails( self.achievements[0])[0]) self._updateImage() def _setColours(self): self.colours = self.app.theme.colours self.fonts = self.app.screenManager.fonts if self.player.teamId == 'A': self.borderColour = self.colours.achvBlueBorder self.bgColour = self.colours.achvBlueBackground else: self.borderColour = self.colours.achvRedBorder self.bgColour = self.colours.achvRedBackground def _getRect(self, area): return area.getRect(self.app) def draw(self, surface): mainRect = self._getRect(self.area) boxRect = self._getRect(self.smlBox) surface.fill(self.bgColour, mainRect) pygame.draw.rect(surface, self.borderColour, mainRect, 2) surface.fill(self.colours.white, boxRect) pygame.draw.rect(surface, self.borderColour, boxRect, 1) super(AchievementBox, self).draw(surface)
class GameInterface(framework.CompoundElement, ConcreteAgent): '''Interface for when we are connected to a game.''' achievementDefs = availableAchievements def __init__(self, app, game, onDisconnectRequest=None, onConnectionLost=None, replay=False, authTag=0): super(GameInterface, self).__init__(app, game=game) self.localState.onShoxwave.addListener(self.localShoxwaveFired) self.localState.onGameInfoChanged.addListener(self.gameInfoChanged) self.world.onOpenChatReceived.addListener(self.openChat) self.world.onTeamChatReceived.addListener(self.teamChat) self.world.onReset.addListener(self.worldReset) self.world.onGrenadeExplosion.addListener(self.grenadeExploded) self.world.onTrosballExplosion.addListener(self.trosballExploded) self.world.onBomberExplosion.addListener(self.trosballExploded) self.world.uiOptions.onChange.addListener(self.uiOptionsChanged) self.timingsLoop = WeakLoopingCall(self, '_sendPing') self.timingsLoop.start(1, now=False) self.subscribedPlayers = set() self.onDisconnectRequest = Event() if onDisconnectRequest is not None: self.onDisconnectRequest.addListener(onDisconnectRequest) self.onConnectionLost = Event() if onConnectionLost is not None: self.onConnectionLost.addListener(onConnectionLost) self.game = game self.joinDialogReason = None self.keyMapping = keyboard.KeyboardMapping(keymap.default_game_keys) self.runningPlayerInterface = None self.updateKeyMapping() self.gameViewer = viewManager.GameViewer(self.app, self, game, replay) if replay: self.joinController = None else: self.joinController = JoinGameController(self.app, self, self.game) self.detailsInterface = DetailsInterface(self.app, self) self.winnerMsg = WinnerMsg(app) self.timingInfo = TimingInfo( app, self, Location(Canvas(307, 768), 'midbottom'), app.screenManager.fonts.timingsFont, ) self.gameInfoDisplay = GameInfoDisplay( app, self, Region(topleft=Screen(0.01, 0.05), size=Canvas(330, 200))) self.hotkeys = hotkey.Hotkeys(self.app, self.keyMapping, self.detailsInterface.doAction) self.terminal = None self.joinInProgress = False self.vcInterface = None if replay: self.vcInterface = ViewControlInterface(self.app, self) self.ready = False defer.maybeDeferred(game.addAgent, self, authTag=authTag).addCallback(self.addedAgent) self.setElements() def _sendPing(self): for i in range(3): data = bytes([random.randrange(256)]) if data not in self.localState.pings: self.sendRequest(PingMsg(data)) return def gameInfoChanged(self): self.gameInfoDisplay.refreshInfo() def addedAgent(self, result): self.ready = True if self.joinController: self.joinDialogReason = 'automatic' self.joinController.start() def spectatorWantsToJoin(self): if self.runningPlayerInterface or not self.joinController: return self.joinDialogReason = 'from menu' self.joinController.maybeShowJoinDialog(autoJoin=True) def sendRequest(self, msg): if not self.ready: # Not yet completely connected to game return super(GameInterface, self).sendRequest(msg) def worldReset(self, *args, **kwarsg): self.winnerMsg.hide() if self.ready and self.joinController: self.joinController.gotWorldReset() self.gameViewer.reset() def updateKeyMapping(self): # Set up the keyboard mapping. try: # Try to load keyboard mappings from the user's personal settings. with open(getPath(user, 'keymap'), 'r') as f: config = f.read() self.keyMapping.load(config) if self.runningPlayerInterface: self.runningPlayerInterface.keyMappingUpdated() except IOError: pass @ConnectionLostMsg.handler def connectionLost(self, msg): self.cleanUp() if self.joinController: self.joinController.hide() self.onConnectionLost.execute() def joined(self, player): '''Called when joining of game is successful.''' pygame.key.set_repeat() self.gameViewer.worldgui.overridePlayer(self.localState.player) self.runningPlayerInterface = pi = PlayerInterface(self.app, self) self.detailsInterface.setPlayer(pi.player) self.setElements() self.joinController.hide() self.gameViewer.leaderboard.update() def spectate(self): ''' Called by join controller if user selects to only spectate. ''' self.vcInterface = ViewControlInterface(self.app, self) self.setElements() self.joinController.hide() def joinDialogCancelled(self): if self.joinDialogReason == 'automatic': self.disconnect() else: self.spectate() def stop(self): super(GameInterface, self).stop() self.localState.onShoxwave.removeListener(self.localShoxwaveFired) self.localState.onGameInfoChanged.removeListener(self.gameInfoChanged) self.world.onOpenChatReceived.removeListener(self.openChat) self.world.onTeamChatReceived.removeListener(self.teamChat) self.world.onReset.removeListener(self.worldReset) self.world.onGrenadeExplosion.removeListener(self.grenadeExploded) self.world.onTrosballExplosion.removeListener(self.trosballExploded) self.world.onBomberExplosion.removeListener(self.trosballExploded) self.world.uiOptions.onChange.removeListener(self.uiOptionsChanged) self.timingsLoop.stop() self.gameViewer.stop() if self.runningPlayerInterface is not None: self.runningPlayerInterface.stop() def setElements(self): spectate = replay = False if self.runningPlayerInterface: self.elements = [ self.gameViewer, self.runningPlayerInterface, self.gameInfoDisplay, self.hotkeys, self.detailsInterface, self.winnerMsg, self.timingInfo ] else: self.elements = [ self.gameViewer, self.gameInfoDisplay, self.hotkeys, self.detailsInterface, self.winnerMsg, self.timingInfo ] if self.vcInterface is not None: self.elements.insert(2, self.vcInterface) if self.joinController: spectate = True else: replay = True self.detailsInterface.menuManager.setMode(spectate=spectate, replay=replay) def toggleTerminal(self): if self.terminal is None: locs = {'app': self.app} if hasattr(self.app, 'getConsoleLocals'): locs.update(self.app.getConsoleLocals()) self.terminal = console.TrosnothInteractiveConsole( self.app, self.app.screenManager.fonts.consoleFont, Region(size=Screen(1, 0.4), bottomright=Screen(1, 1)), locals=locs) self.terminal.interact().addCallback(self._terminalQuit) from trosnoth.utils.utils import timeNow if self.terminal in self.elements: if timeNow() > self._termWaitTime: self.elements.remove(self.terminal) else: self._termWaitTime = timeNow() + 0.1 self.elements.append(self.terminal) self.setFocus(self.terminal) def _terminalQuit(self, result): if self.terminal in self.elements: self.elements.remove(self.terminal) self.terminal = None def disconnect(self): self.cleanUp() self.onDisconnectRequest.execute() def joinGame(self, nick, head, team, timeout=10): if self.joinInProgress: return if team is None: teamId = NEUTRAL_TEAM_ID else: teamId = team.id self.joinInProgress = True self.sendJoinRequest(teamId, nick, head) WeakCallLater(timeout, self, '_joinTimedOut') def setPlayer(self, player): if not player: self.gameViewer.worldgui.removeOverride() self.lostPlayer() super(GameInterface, self).setPlayer(player) if player: if __debug__ and globaldebug.enabled: globaldebug.localPlayerId = player.id self.joinInProgress = False self.joined(player) @CannotJoinMsg.handler def joinFailed(self, msg): self.joinInProgress = False self.joinController.joinFailed(msg.reasonId) def _joinTimedOut(self): if self.player or not self.joinInProgress: return self.joinInProgress = False self.joinController.joinFailed('timeout') def cleanUp(self): if self.gameViewer.timerBar is not None: self.gameViewer.timerBar = None pygame.key.set_repeat(300, 30) def uiOptionsChanged(self): if self.world.uiOptions.showGameOver: winner = self.world.uiOptions.winningTeam if winner: self.winnerMsg.show( '{} win'.format(winner), self.app.theme.colours.chatColour(winner), ) else: self.winnerMsg.show('Game drawn', (128, 128, 128)) else: self.winnerMsg.hide() @PlayerCoinsSpentMsg.handler def discard(self, msg): pass @AwardPlayerCoinMsg.handler def playerAwardedCoin(self, msg): if not self.localState.player: return if msg.sound and msg.playerId == self.localState.player.id: self.playSound('gotCoin') @PlayerHasElephantMsg.handler def gotElephant(self, msg, _lastElephantPlayer=[None]): player = self.world.getPlayer(msg.playerId) if player and player != _lastElephantPlayer[0]: message = '%s now has %s!' % (player.nick, player.world.uiOptions.elephantName) self.detailsInterface.newMessage(message) _lastElephantPlayer[0] = player @PlayerHasTrosballMsg.handler def gotTrosball(self, msg, _lastTrosballPlayer=[None]): player = self.world.playerWithId.get(msg.playerId) if player != _lastTrosballPlayer[0]: _lastTrosballPlayer[0] = player if player is None: message = 'The ball has been dropped!' else: message = '%s has the ball!' % (player.nick, ) self.detailsInterface.newMessage(message) @AddPlayerMsg.handler def addPlayer(self, msg): player = self.world.getPlayer(msg.playerId) if player and player not in self.subscribedPlayers: self.subscribedPlayers.add(player) team = player.team if player.team else self.world.rogueTeamName message = '%s has joined %s' % (player.nick, team) self.detailsInterface.newMessage(message) player.onDied.addListener(partial(self.playerDied, player)) @SetPlayerTeamMsg.handler def changeTeam(self, msg): self.defaultHandler(msg) # Make sure the local player changes team player = self.world.getPlayer(msg.playerId) if player: message = '%s has joined %s' % (player.nick, self.world.getTeamName(msg.teamId)) self.detailsInterface.newMessage(message) @RemovePlayerMsg.handler def handle_RemovePlayerMsg(self, msg): player = self.world.getPlayer(msg.playerId) if player: message = '%s has left the game' % (player.nick, ) self.detailsInterface.newMessage(message) self.subscribedPlayers.discard(player) def lostPlayer(self): self.runningPlayerInterface.stop() self.runningPlayerInterface = None self.setElements() @CannotBuyUpgradeMsg.handler def notEnoughCoins(self, msg): if msg.reasonId == NOT_ENOUGH_COINS_REASON: text = 'Your team does not have enough coins.' elif msg.reasonId == CANNOT_REACTIVATE_REASON: text = 'You already have that item.' elif msg.reasonId == PLAYER_DEAD_REASON: text = 'You cannot buy an upgrade while dead.' elif msg.reasonId == GAME_NOT_STARTED_REASON: text = 'Upgrades can' 't be bought at this time.' elif msg.reasonId == TOO_CLOSE_TO_EDGE_REASON: text = 'You are too close to the zone edge.' elif msg.reasonId == TOO_CLOSE_TO_ORB_REASON: text = 'You are too close to the orb.' elif msg.reasonId == NOT_IN_DARK_ZONE_REASON: text = 'You are not in a dark friendly zone.' elif msg.reasonId == INVALID_UPGRADE_REASON: text = 'Upgrade not recognised by server.' elif msg.reasonId == DISABLED_UPGRADE_REASON: text = 'That upgrade is currently disabled.' else: text = 'You cannot buy that item at this time.' self.detailsInterface.newMessage(text) self.defaultHandler(msg) @PlayerHasUpgradeMsg.handler def gotUpgrade(self, msg): player = self.world.getPlayer(msg.playerId) if player: self.detailsInterface.upgradeUsed(player, msg.upgradeType) upgradeClass = self.world.getUpgradeType(msg.upgradeType) existing = player.items.get(upgradeClass) if not existing: if (self.detailsInterface.player is None or self.detailsInterface.player.isFriendsWith(player)): self.playSound('buyUpgrade') self.defaultHandler(msg) @ChatFromServerMsg.handler def gotChatFromServer(self, msg): self.detailsInterface.newMessage(msg.text.decode('utf-8'), error=msg.error) @TaggingZoneMsg.handler def zoneTagged(self, msg): try: zone = self.world.zoneWithId[msg.zoneId] zoneLabel = zone.defn.label except KeyError: zoneLabel = '<?>' if msg.playerId != NO_PLAYER: try: player = self.world.playerWithId[msg.playerId] except KeyError: nick = '<?>' else: nick = player.nick message = '%s tagged zone %s' % (nick, zoneLabel) self.detailsInterface.newMessage(message) def playerDied(self, target, killer, deathType): if deathType == OFF_MAP_DEATH_HIT: messages = [ 'fell into the void', 'looked into the abyss', 'dug too greedily and too deep' ] message = '%s %s' % (target.nick, random.choice(messages)) elif deathType == TROSBALL_DEATH_HIT: message = '%s was killed by the Trosball' % (target.nick, ) elif deathType == BOMBER_DEATH_HIT: message = '%s head asplode' % (target.nick, ) thisPlayer = self.detailsInterface.player if thisPlayer and target.id == thisPlayer.id: self.detailsInterface.doAction(ACTION_CLEAR_UPGRADE) else: if killer is None: message = '%s was killed' % (target.nick, ) self.detailsInterface.newMessage(message) else: message = '%s killed %s' % (killer.nick, target.nick) self.detailsInterface.newMessage(message) @RespawnMsg.handler def playerRespawn(self, msg): player = self.world.getPlayer(msg.playerId) if player: message = '%s is back in the game' % (player.nick, ) self.detailsInterface.newMessage(message) @CannotRespawnMsg.handler def respawnFailed(self, msg): if msg.reasonId == GAME_NOT_STARTED_REASON: message = 'The game has not started yet.' elif msg.reasonId == ALREADY_ALIVE_REASON: message = 'You are already alive.' elif msg.reasonId == BE_PATIENT_REASON: message = 'You cannot respawn yet.' elif msg.reasonId == ENEMY_ZONE_REASON: message = 'Cannot respawn outside friendly zone.' elif msg.reasonId == FROZEN_ZONE_REASON: message = 'That zone has been frozen!' else: message = 'You cannot respawn here.' self.detailsInterface.newMessage( message, self.app.theme.colours.errorMessageColour) def sendPrivateChat(self, player, targetId, text): self.sendRequest(ChatMsg(PRIVATE_CHAT, targetId, text=text.encode())) def sendTeamChat(self, player, text): self.sendRequest(ChatMsg(TEAM_CHAT, player.teamId, text=text.encode())) def sendPublicChat(self, player, text): self.sendRequest(ChatMsg(OPEN_CHAT, text=text.encode())) def openChat(self, text, sender): text = ': ' + text self.detailsInterface.newChat(text, sender) def teamChat(self, team, text, sender): player = self.detailsInterface.player if player and player.isFriendsWithTeam(team): text = ' (team): ' + text self.detailsInterface.newChat(text, sender) @AchievementUnlockedMsg.handler def achievementUnlocked(self, msg): player = self.world.getPlayer(msg.playerId) if not player: return achievementName = self.achievementDefs.getAchievementDetails( msg.achievementId)[0] self.detailsInterface.newMessage( '%s has unlocked "%s"!' % (player.nick, achievementName), self.app.theme.colours.achievementMessageColour) focusPlayer = self.detailsInterface.player if (focusPlayer is not None and focusPlayer.id == msg.playerId): self.detailsInterface.localAchievement(msg.achievementId) @ShotFiredMsg.handler def shotFired(self, msg): self.defaultHandler(msg) try: shot = self.world.getShot(msg.shotId) except KeyError: return pos = shot.pos dist = self.distance(pos) self.playSound('shoot', self.getSoundVolume(dist)) def grenadeExploded(self, pos, radius): self.gameViewer.worldgui.addExplosion(pos) dist = self.distance(pos) self.playSound('explodeGrenade', self.getSoundVolume(dist)) def trosballExploded(self, player): self.gameViewer.worldgui.addTrosballExplosion(player.pos) dist = self.distance(player.pos) self.playSound('explodeGrenade', self.getSoundVolume(dist)) @FireShoxwaveMsg.handler def shoxwaveExplosion(self, msg): localPlayer = self.localState.player if localPlayer and msg.playerId == localPlayer.id: return self.gameViewer.worldgui.addShoxwaveExplosion((msg.xpos, msg.ypos)) def localShoxwaveFired(self): localPlayer = self.localState.player self.gameViewer.worldgui.addShoxwaveExplosion(localPlayer.pos) @UpgradeChangedMsg.handler def upgradeChanged(self, msg): self.detailsInterface.upgradeDisplay.refresh() def distance(self, pos): return distance(self.gameViewer.viewManager.getTargetPoint(), pos) def getSoundVolume(self, distance): 'The volume for something that far away from the player' # Up to 500px away is within the "full sound zone" - full sound distFromScreen = max(0, distance - 500) # 1000px away from "full sound zone" is 0 volume: return 1 - min(1, (distFromScreen / 1000.)) def playSound(self, action, volume=1): self.app.soundPlayer.play(action, volume) @PlaySoundMsg.handler def playSoundFromServerCommand(self, msg): self.app.soundPlayer.playFromServerCommand( msg.filename.decode('utf-8')) @TickMsg.handler def handle_TickMsg(self, msg): super(GameInterface, self).handle_TickMsg(msg) self.timingInfo.ticksSeen += 1
class AIAgent(ConcreteAgent): ''' Base class for an AI agent. ''' def __init__(self, game, aiClass, fromLevel, nick=None, *args, **kwargs): super(AIAgent, self).__init__(game=game, *args, **kwargs) self.aiClass = aiClass self.fromLevel = fromLevel self._initialisationNick = nick self.ai = None self.team = None self.requestedNick = None self._onBotSet = Event([]) self._loop = WeakLoopingCall(self, '_tick') def __str__(self): if self.ai: bot = self.ai else: bot = 'None (was {})'.format(self.aiClass.__name__) return '{}<{}>'.format(self.__class__.__name__, bot) def start(self, team=None): self.team = team self._loop.start(2) def stop(self): super(AIAgent, self).stop() self._loop.stop() if self.ai: self.ai.disable() self.ai = None def detached(self): super().detached() self.stop() def _tick(self): if self.ai is not None: return if self.fromLevel and self._initialisationNick: nick = self._initialisationNick else: nick = self.aiClass.nick if self.team is None: teamId = NEUTRAL_TEAM_ID else: teamId = self.team.id self._joinGame(nick, teamId) def _joinGame(self, nick, teamId): self.requestedNick = nick self.sendJoinRequest(teamId, nick, bot=True, fromLevel=self.fromLevel) @CannotJoinMsg.handler def _joinFailed(self, msg): r = msg.reasonId nick = self.requestedNick if r == GAME_FULL_REASON: message = 'full' elif r == UNAUTHORISED_REASON: message = 'not authenticated' elif r == NICK_USED_REASON: message = 'nick in use' elif r == USER_IN_GAME_REASON: message = 'user already in game' # Should never happen elif r == ALREADY_JOINED_REASON: message = 'tried to join twice' # Should never happen else: message = repr(r) log.error('Join failed for AI %r (%s)', nick, message) self.stop() def setPlayer(self, player): if player is None and self.ai: self.ai.disable() self.ai = None super(AIAgent, self).setPlayer(player) if player: self.requestedNick = None self.ai = self.aiClass(self.world, self.localState.player, self) self._onBotSet() @defer.inlineCallbacks def getBot(self): ''' @return: a Deferred which fires with this agent's Bot object, as soon as it has one. ''' if self.ai is not None: defer.returnValue(self.ai) yield self._onBotSet.wait() defer.returnValue(self.ai) @TickMsg.handler def handle_TickMsg(self, msg): super(AIAgent, self).handle_TickMsg(msg) if self.ai: self.ai.consumeMsg(msg) @ResyncPlayerMsg.handler def handle_ResyncPlayerMsg(self, msg): super(AIAgent, self).handle_ResyncPlayerMsg(msg) if self.ai: self.ai.playerResynced() @WorldResetMsg.handler def handle_WorldResetMsg(self, msg): super().handle_WorldResetMsg(msg) if self.ai: self.ai.worldReset() def defaultHandler(self, msg): super(AIAgent, self).defaultHandler(msg) if self.ai: self.ai.consumeMsg(msg)
class LocalGame(Game): def __init__(self, layoutDatabase, halfMapWidth=None, mapHeight=None, blockRatio=0.5, duration=0, maxPerTeam=100, maxTotal=500, serverInterface=None, onceOnly=False, saveReplay=False, gamePrefix=None, replayPath=None, level=None, gameType=None, lobbySettings=None, *args, **kwargs): self._serverCommandStack = [] self._waitingForEmptyCommandQueue = [] self.maxPerTeam = maxPerTeam self.maxTotalPlayers = min(2 * maxPerTeam, maxTotal) self.serverInterface = serverInterface self.lobbySettings = lobbySettings self.agents = set() self.agentInfos = {} self.layoutDatabase = layoutDatabase if level is None: level = StandardRandomLevel(halfMapWidth, mapHeight, blockRatio=blockRatio, duration=duration) world = ServerUniverse(self, layoutDatabase, onceOnly=onceOnly, level=level, gameType=gameType) self.idManager = world.idManager self.gameRecorder = GameRecorder(self, world, saveReplay=saveReplay, gamePrefix=gamePrefix, replayPath=replayPath) super(LocalGame, self).__init__(world, *args, **kwargs) world.onServerTickComplete.addListener(self.worldTickDone) self.gameRecorder.start() self.updateDelayLoop = WeakLoopingCall(self, 'updateDelays') self.updateDelayLoop.start(10, False) self.achievementManager = AchievementManager(self) self.achievementManager.start() if VERIFY_PLAYER_CONSISTENCY: self.playerConsistencyVerifier = PlayerConsistencyVerifier(self) def updateDelays(self): for info in self.agentInfos.values(): info.updateDelays() def addAgent(self, agent, user=None, authTag=0): agent.user = user info = AgentInfo(self, agent) self.agentInfos[agent] = info self.agents.add(agent) def detachAgent(self, agent): if agent not in self.agents: return self.agents.remove(agent) if agent.player: self.kickPlayer(agent.player.id) self.agentInfos[agent].takePlayer() del self.agentInfos[agent] agent.detached() def kickPlayer(self, playerId): ''' Removes the player with the specified ID from the game. ''' self.sendServerCommand(RemovePlayerMsg(playerId)) def agentRequest(self, agent, msg): ''' Some messages need to be delayed until the correct time comes. ''' msg.tracePoint(self, 'agentRequest') if agent not in self.agents: # Probably just because it's a delayed call log.debug('LocalGame got message %s from unconnected agent', msg) return info = self.agentInfos[agent] info.requestFromAgent(msg) def dispatchDelayedRequest(self, agent, msg): ''' Called by an AgentInfo when the correct time comes for a request to be dispatched. ''' msg.tracePoint(self, 'dispatchDelayedRequest') msg.serverApply(self, agent) def setPlayerLimits(self, maxPerTeam, maxTotal=40): ''' Changes the player limits in the current game. Note that this does not affect players who are already in the game. @param maxPerTeam: Maximum number of players per team at once @param maxTotal: Maximum number of players in the game at once ''' self.maxPerTeam = maxPerTeam self.maxTotalPlayers = min(2 * maxPerTeam, maxTotal) def stop(self): super(LocalGame, self).stop() self.gameRecorder.stop() self.achievementManager.stop() self.updateDelayLoop.stop() self.idManager.stop() def worldTickDone(self): ''' Called when the universe has ticked. ''' self.checkCollisionsWithCollectables() for info in self.agentInfos.values(): info.tick() def checkCollisionsWithCollectables(self): ''' When a player runs into a collectable unit (e.g. a coin or the trosball), we pay attention not to where we think the collectable units are, but where the player's client thinks they are. To do this, we need to project the collectable units back in time based on the player's current delay. ''' greatestDelay = 0 for info in self.agentInfos.values(): if not info.player or info.player.dead: continue greatestDelay = max(greatestDelay, info.currentDelay) for unit in self.world.getCollectableUnits(): if unit.checkCollision(info.player, info.currentDelay): unit.collidedWithPlayer(info.player) for unit in self.world.getCollectableUnits(): unit.clearOldHistory(greatestDelay) def joinSuccessful(self, agent, playerId): super(LocalGame, self).joinSuccessful(agent, playerId) if agent in self.agentInfos: self.agentInfos[agent].givePlayer(self.world.getPlayer(playerId)) def playerRemoved(self, player, playerId): super(LocalGame, self).playerRemoved(player, playerId) info = self.agentInfos.get(player.agent) if info: info.takePlayer() def sendServerCommand(self, msg): ''' Sends a command to the universe and all attached agents. Typically called by message classes in serverApply(). ''' self._serverCommandStack.append(msg) if len(self._serverCommandStack) > 1: # Sometimes one of the calls below (e.g. self.world.consumeMsg()) # triggers another sendServerCommand() call, so to make sure # that all the messages arrive at the clients in the same order # as the server, we queue them and release them as soon as the # first message is completely sent. msg.tracePoint(self, '(sendServerCommand: deferred)') return while self._serverCommandStack: cmd = self._serverCommandStack[0] cmd.tracePoint(self, 'sendServerCommand') if VERIFY_PLAYER_CONSISTENCY: self.playerConsistencyVerifier.preMessage(cmd) self.world.consumeMsg(cmd) self.gameRecorder.consumeMsg(cmd) if VERIFY_PLAYER_CONSISTENCY: self.playerConsistencyVerifier.postMessage(cmd) self.onServerCommand(cmd) cmd.tracePoint(self, 'done sendServerCommand') self._serverCommandStack.pop(0) # Release things that are waiting for the command stack to empty while not self._serverCommandStack and self._waitingForEmptyCommandQueue: d = self._waitingForEmptyCommandQueue.pop(0) try: d.callback(None) except Exception: log.exception('Error in queued callback') def waitForEmptyCommandQueue(self): ''' :return: a Deferred which will callback when the queue of server commands to send is empty. This is useful to be sure that the world is in a consistent state (all messages have been processed). ''' if not self._serverCommandStack: return defer.succeed(None) d = defer.Deferred() self._waitingForEmptyCommandQueue.append(d) return d def sendResync(self, playerId, reason='Your computer was out of sync with the server!'): ''' Resyncs the position of the player with the given id. Typically called by message classes in serverApply(). ''' player = self.world.getPlayer(playerId) player.sendResync(reason)
class ReplayPlayer(Hub): ''' Emulates a normal server by outputting the same messages that a server once did. ''' def __init__(self, filename, *args, **kwargs): super(ReplayPlayer, self).__init__(*args, **kwargs) self.tickPeriod = TICK_PERIOD self.file = open(filename, 'rb') self.finished = False self.loop = WeakLoopingCall(self, 'tick') self.agentIds = [] self.nextAgentId = 0 try: length = struct.unpack('!I', self.file.read(4))[0] except struct.error: raise ReplayFileError('invalid replay format') data = self.file.read(length) self.settings = unrepr(data) def popSettings(self): result, self.settings = self.settings, None return result def start(self): self.loop.start(self.tickPeriod) def stop(self): if self.loop.running: self.loop.stop() def tick(self): while True: data = self.file.read(4) if not data: self.finished = True if self.node: while self.agentIds: agentId = self.agentIds.pop(0) # Give 2 seconds before ending the replay reactor.callLater( 2, self.node.agentDisconnected, agentId) self.loop.stop() break length = struct.unpack('!I', data)[0] data = self.file.read(length) try: msg = clientMsgs.buildMessage(data) except MessageTypeError: log.warning('WARNING: UNKNOWN MESSAGE: %r' % (data,)) continue self.node.gotServerCommand(msg) if isinstance(msg, TickMsg): break def connectNewAgent(self): agentId = self.nextAgentId self.nextAgentId += 1 self.agentIds.append(agentId) return agentId def disconnectAgent(self, agentId): self.agentIds.remove(agentId) def sendRequestToGame(self, agentId, msg): pass