mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-11-01 01:07:54 +00:00
378 lines
14 KiB
Python
378 lines
14 KiB
Python
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()
|