from direct.distributed.ClockDelta import globalClockDelta from toontown.toonbase import TTLocalizer from toontown.parties import PartyGlobals from toontown.parties.DistributedPartyActivity import DistributedPartyActivity from toontown.parties.activityFSMs import TeamActivityFSM from toontown.parties.TeamActivityGui import TeamActivityGui class DistributedPartyTeamActivity(DistributedPartyActivity): notify = directNotify.newCategory('DistributedPartyTeamActivity') def __init__(self, cr, activityId, startDelay = PartyGlobals.TeamActivityStartDelay, balanceTeams = False): DistributedPartyActivity.__init__(self, cr, activityId, PartyGlobals.ActivityTypes.GuestInitiated, wantRewardGui=True) self.notify.debug('__init__') self.toonIds = ([], []) self.isLocalToonPlaying = False self.localToonTeam = None self.advantage = 1.0 self.waitToStartTimestamp = None self._maxPlayersPerTeam = 0 self._minPlayersPerTeam = 0 self._duration = 0 self._startDelay = base.config.GetFloat('party-team-activity-start-delay', startDelay) self._willBalanceTeams = balanceTeams self._currentStatus = '' return def load(self): DistributedPartyActivity.load(self) self.teamActivityGui = TeamActivityGui(self) self.activityFSM = TeamActivityFSM(self) def unload(self): DistributedPartyActivity.unload(self) del self.activityFSM self.teamActivityGui.unload() del self.teamActivityGui if hasattr(self, 'toonIds'): del self.toonIds del self.isLocalToonPlaying del self.localToonTeam del self.advantage del self.waitToStartTimestamp def handleToonShifted(self, toonId): self.notify.error('handleToonShifted( toonId=%d ) must be overriden by child class.' % toonId) def handleToonSwitchedTeams(self, toonId): if toonId == base.localAvatar.doId and self._canSwitchTeams: if self.isState('WaitForEnough') or self.isState('WaitToStart'): self.teamActivityGui.enableExitButton() self.teamActivityGui.enableSwitchButton() def handleToonDisabled(self, toonId): self.notify.error('handleToonDisabled( toonId=%d ) must be overriden by child class.' % toonId) def setPlayersPerTeam(self, min, max): self._minPlayersPerTeam = min self._maxPlayersPerTeam = max def setDuration(self, duration): self._duration = duration def setCanSwitchTeams(self, canSwitchTeams): self._canSwitchTeams = canSwitchTeams def d_toonJoinRequest(self, team): if self.isLocalToonInActivity(): return if self.activityFSM.state in ['WaitForEnough', 'WaitToStart'] and self._localToonRequestStatus is None: base.cr.playGame.getPlace().fsm.request('activity') self.localToonJoining() self.sendUpdate('toonJoinRequest', [team]) return def d_toonExitRequest(self): toonId = base.localAvatar.doId team = self.getTeam(toonId) if team is not None: if self._localToonRequestStatus is None: self.localToonExiting() self.sendUpdate('toonExitRequest', [team]) else: self.notify.warning('Not sending exitRequest as localToon has no team.') return def joinRequestDenied(self, reason): DistributedPartyActivity.joinRequestDenied(self, reason) self.notify.debug('joinRequestDenied') if reason == PartyGlobals.DenialReasons.Full: self.showMessage(TTLocalizer.PartyTeamActivityTeamFull) elif reason == PartyGlobals.DenialReasons.Default: self.showMessage(TTLocalizer.PartyTeamActivityJoinDenied % self.getTitle()) def exitRequestDenied(self, reason): DistributedPartyActivity.exitRequestDenied(self, reason) if reason == PartyGlobals.DenialReasons.Default: self.showMessage(TTLocalizer.PartyTeamActivityExitDenied % self.getTitle()) if self.isLocalToonPlaying and (self.isState('WaitToStart') or self.isState('WaitForEnough')): self.teamActivityGui.enableExitButton() if self._canSwitchTeams: self.teamActivityGui.enableSwitchButton() def d_toonSwitchTeamRequest(self): if not self._canSwitchTeams: return self.sendUpdate('toonSwitchTeamRequest') def switchTeamRequestDenied(self, reason): self.notify.debug('switchTeamRequestDenied') if reason == PartyGlobals.DenialReasons.Full: self.showMessage(TTLocalizer.PartyTeamActivityTeamFull, endState='activity') elif reason == PartyGlobals.DenialReasons.Default: self.showMessage(TTLocalizer.PartyTeamActivitySwitchDenied, endState='activity') if self.isLocalToonPlaying and (self.isState('WaitToStart') or self.isState('WaitForEnough')) and self._canSwitchTeams: self.teamActivityGui.enableSwitchButton() def setToonsPlaying(self, leftTeamToonIds, rightTeamToonIds): newToonIds = [leftTeamToonIds, rightTeamToonIds] exitedToons, joinedToons, shifters, switchers = self.getToonsPlayingChanges(self.toonIds, newToonIds) if base.localAvatar.doId in exitedToons: self.localToonExiting() self._processExitedToons(exitedToons) self.setToonIds([leftTeamToonIds, rightTeamToonIds]) self._processJoinedToons(joinedToons) for toonId in shifters: self.handleToonShifted(toonId) if self._canSwitchTeams: for toonId in switchers: self.handleToonSwitchedTeams(toonId) if self.isState('WaitForEnough'): self._updateWaitForEnoughStatus() def _updateWaitForEnoughStatus(self): amount = self.getNumToonsNeededToStart() if self._willBalanceTeams: text = TTLocalizer.PartyTeamActivityForMoreWithBalance else: text = TTLocalizer.PartyTeamActivityForMore if amount > 1: plural = TTLocalizer.PartyTeamActivityForMorePlural else: plural = '' self.setStatus(text % (amount, plural)) def setState(self, newState, timestamp, data): DistributedPartyActivity.setState(self, newState, timestamp) if newState == 'WaitToStart': self.activityFSM.request(newState, timestamp) elif newState == 'Conclusion': self.activityFSM.request(newState, data) else: self.activityFSM.request(newState) def d_toonReady(self): self.sendUpdate('toonReady') def setAdvantage(self, advantage): self.advantage = advantage def handleToonJoined(self, toonId): if toonId == base.localAvatar.doId: self.isLocalToonPlaying = True self.localToonTeam = self.getTeam(base.localAvatar.doId) self.teamActivityGui.load() self.teamActivityGui.enableExitButton() if self._canSwitchTeams: self.teamActivityGui.enableSwitchButton() if self.activityFSM.state == 'WaitToStart': self.showWaitToStartCountdown() else: self.showStatus() def handleToonExited(self, toonId): if toonId == base.localAvatar.doId: self.hideStatus() self.teamActivityGui.disableExitButton() if self._canSwitchTeams: self.teamActivityGui.disableSwitchButton() if self.activityFSM.state == 'WaitToStart': self.hideWaitToStartCountdown() self.teamActivityGui.unload() self.isLocalToonPlaying = False self.localToonTeam = None return def handleRulesDone(self): self.notify.debug('handleRulesDone') self.d_toonReady() self.activityFSM.request('WaitForServer') def handleGameTimerExpired(self): pass def getToonsPlayingChanges(self, oldToonIds, newToonIds): oldLeftTeam = oldToonIds[0] oldRightTeam = oldToonIds[1] newLeftTeam = newToonIds[0] newRightTeam = newToonIds[1] oldToons = set(oldLeftTeam + oldRightTeam) newToons = set(newLeftTeam + newRightTeam) exitedToons = oldToons.difference(newToons) joinedToons = newToons.difference(oldToons) shifters = [] if self._canSwitchTeams: switchers = list(set(oldLeftTeam) & set(newRightTeam)) + list(set(oldRightTeam) & set(newLeftTeam)) else: switchers = [] for i in xrange(len(PartyGlobals.TeamActivityTeams)): persistentToons = set(oldToonIds[i]) & set(newToonIds[i]) for toonId in persistentToons: if oldToonIds[i].index(toonId) != newToonIds[i].index(toonId): shifters.append(toonId) return (list(exitedToons), list(joinedToons), shifters, switchers) def getMaxPlayersPerTeam(self): return self._maxPlayersPerTeam def getMinPlayersPerTeam(self): return self._minPlayersPerTeam def getNumToonsNeededToStart(self): if self._willBalanceTeams: return abs(self._minPlayersPerTeam * 2 - self.getNumToonsPlaying()) else: return self._minPlayersPerTeam def getToonIdsAsList(self): return self.toonIds[0] + self.toonIds[1] def getNumToonsPlaying(self): return len(self.toonIds[0]) + len(self.toonIds[1]) def getNumToonsInTeam(self, team): return len(self.toonIds[team]) def getTeam(self, toonId): for i in xrange(len(PartyGlobals.TeamActivityTeams)): if self.toonIds[i].count(toonId) > 0: return i else: return None return None def getIndex(self, toonId, team): if self.toonIds[team].count(toonId) > 0: return self.toonIds[team].index(toonId) else: return None return None def _joinLeftTeam(self, collEntry): if self.isLocalToonInActivity(): return self.d_toonJoinRequest(PartyGlobals.TeamActivityTeams.LeftTeam) def _joinRightTeam(self, collEntry): if self.isLocalToonInActivity(): return self.d_toonJoinRequest(PartyGlobals.TeamActivityTeams.RightTeam) def showWaitToStartCountdown(self): if self.waitToStartTimestamp is None: self.notify.warning('showWaitToStartCountdown was called when self.waitToStartTimestamp was None') return self.teamActivityGui.showWaitToStartCountdown(self._startDelay, self.waitToStartTimestamp, almostDoneCallback=self._onCountdownAlmostDone) self.showStatus() self.teamActivityGui.enableExitButton() return def _onCountdownAlmostDone(self): if self._canSwitchTeams: self.teamActivityGui.disableSwitchButton() def hideWaitToStartCountdown(self): self.teamActivityGui.hideWaitToStartCountdown() self.teamActivityGui.disableExitButton() self.hideStatus() def setStatus(self, text): self._currentStatus = text if self.isLocalToonPlaying: self.showStatus() def showStatus(self): if self.teamActivityGui is not None: self.teamActivityGui.showStatus(self._currentStatus) return def hideStatus(self): if self.teamActivityGui is not None: self.teamActivityGui.hideStatus() return def toonsCanSwitchTeams(self): return self._canSwitchTeams def isState(self, state): return hasattr(self, 'activityFSM') and self.activityFSM.getCurrentOrNextState() == state def startWaitForEnough(self): self.notify.debug('startWaitForEnough') self.advantage = 1.0 self._updateWaitForEnoughStatus() if self.isLocalToonPlaying: self.teamActivityGui.enableExitButton() if self._canSwitchTeams: self.teamActivityGui.enableSwitchButton() def finishWaitForEnough(self): self.notify.debug('finishWaitForEnough') def startWaitToStart(self, waitStartTimestamp): self.notify.debug('startWaitToStart') self.waitToStartTimestamp = globalClockDelta.networkToLocalTime(waitStartTimestamp) self._updateWaitForEnoughStatus() self.setStatus(TTLocalizer.PartyTeamActivityWaitingToStart) if self.isLocalToonPlaying: self.showWaitToStartCountdown() def finishWaitToStart(self): self.notify.debug('finishWaitToStart') if self.isLocalToonPlaying: self.hideWaitToStartCountdown() if self._canSwitchTeams: self.teamActivityGui.disableSwitchButton() self.waitToStartTimestamp = None return def startRules(self): self.notify.debug('startRules') if self.isLocalToonPlaying: DistributedPartyActivity.startRules(self) def finishRules(self): self.notify.debug('finishRules') if self.isLocalToonPlaying: DistributedPartyActivity.finishRules(self) if self.activityFSM.getCurrentOrNextState() == 'WaitForEnough': DistributedPartyActivity.finishRules(self) def startWaitForServer(self): self.notify.debug('startWaitForServer') self.setStatus(TTLocalizer.PartyTeamActivityWaitingForOtherPlayers) def finishWaitForServer(self): self.notify.debug('finishWaitForServer') if self.isLocalToonPlaying: self.hideStatus() def startActive(self): self.notify.debug('startActive') if self.isLocalToonPlaying: self.hideStatus() self.teamActivityGui.showTimer(self._duration) def finishActive(self): self.notify.debug('finishActive') if self.isLocalToonPlaying: self.teamActivityGui.hideTimer() self.hideStatus() def startConclusion(self, data): self.notify.debug('startConclusion') self.setStatus('') if self.isLocalToonPlaying: self.localToonExiting() def finishConclusion(self): self.notify.debug('finishConclusion') if self.isLocalToonPlaying: self.hideStatus()