238 lines
8 KiB
Python
238 lines
8 KiB
Python
from direct.distributed.ClockDelta import globalClockDelta
|
|
from toontown.toonbase import TTLocalizer
|
|
from DistCogdoGame import DistCogdoGame
|
|
from toontown.cogdominium.DistCogdoMazeGameBase import DistCogdoMazeGameBase
|
|
from CogdoMazeGame import CogdoMazeGame
|
|
from CogdoMaze import CogdoMazeFactory
|
|
import CogdoMazeGameGlobals
|
|
import CogdoMazeGameGlobals as Globals
|
|
|
|
class DistCogdoMazeGame(DistCogdoGame, DistCogdoMazeGameBase):
|
|
notify = directNotify.newCategory('DistCogdoMazeGame')
|
|
|
|
def __init__(self, cr):
|
|
DistCogdoGame.__init__(self, cr)
|
|
self.game = CogdoMazeGame(self)
|
|
self._numSuits = (0, 0, 0)
|
|
|
|
def delete(self):
|
|
del self.randomNumGen
|
|
del self.game
|
|
DistCogdoGame.delete(self)
|
|
|
|
def getTitle(self):
|
|
return TTLocalizer.CogdoMazeGameTitle
|
|
|
|
def getInstructions(self):
|
|
return TTLocalizer.CogdoMazeGameInstructions
|
|
|
|
def generate(self):
|
|
self.randomNumGen = self.createRandomNumGen()
|
|
DistCogdoGame.generate(self)
|
|
|
|
def placeEntranceElev(self, elev):
|
|
DistCogdoGame.placeEntranceElev(self, elev)
|
|
self.game.placeEntranceElevator(elev)
|
|
|
|
def _gameInProgress(self):
|
|
return self.fsm.getCurrentState().getName() == 'Game'
|
|
|
|
def enterLoaded(self):
|
|
DistCogdoGame.enterLoaded(self)
|
|
mazeFactory = self.createMazeFactory(self.createRandomNumGen())
|
|
bossCode = None
|
|
if self._numSuits[0] > 0:
|
|
bossCode = ''
|
|
for u in xrange(self._numSuits[0]):
|
|
bossCode += '%X' % self.randomNumGen.randint(0, 15)
|
|
|
|
self.game.load(mazeFactory, self._numSuits, bossCode)
|
|
return
|
|
|
|
def exitLoaded(self):
|
|
self.game.unload()
|
|
self.ignoreAll()
|
|
DistCogdoGame.exitLoaded(self)
|
|
|
|
def enterVisible(self):
|
|
DistCogdoGame.enterVisible(self)
|
|
self.game.initPlayers()
|
|
self.game.onstage()
|
|
|
|
def exitVisible(self):
|
|
DistCogdoGame.exitVisible(self)
|
|
|
|
def enterIntro(self):
|
|
DistCogdoGame.enterIntro(self, Globals.IntroDurationSeconds)
|
|
self.game.startIntro()
|
|
|
|
def exitIntro(self):
|
|
DistCogdoGame.exitIntro(self)
|
|
self.game.endIntro()
|
|
self.stashEntranceElevator()
|
|
|
|
def enterGame(self):
|
|
DistCogdoGame.enterGame(self)
|
|
self.game.start()
|
|
|
|
def exitGame(self):
|
|
DistCogdoGame.exitGame(self)
|
|
self.game.exit()
|
|
|
|
def enterFinish(self):
|
|
DistCogdoGame.enterFinish(self)
|
|
self.game.startFinish()
|
|
|
|
def exitFinish(self):
|
|
DistCogdoGame.exitFinish(self)
|
|
self.game.endFinish()
|
|
self.game.offstage()
|
|
|
|
def setNumSuits(self, numSuits):
|
|
self._numSuits = numSuits
|
|
|
|
def d_sendRequestAction(self, action, data):
|
|
self.sendUpdate('requestAction', [action, data])
|
|
|
|
def toonUsedGag(self, toonId, x, y, h, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
if toonId == localAvatar.doId:
|
|
return
|
|
elapsedTime = globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.toonUsedGag(toonId, x, y, h, elapsedTime)
|
|
|
|
def d_requestUseGag(self, x, y, h):
|
|
networkTime = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
|
|
self.sendUpdate('requestUseGag', [x,
|
|
y,
|
|
h,
|
|
networkTime])
|
|
|
|
def b_toonUsedGag(self, x, y, h):
|
|
self.d_requestUseGag(x, y, h)
|
|
self.game.toonUsedGag(base.localAvatar.doId, x, y, h)
|
|
|
|
def suitHitByGag(self, toonId, suitType, suitNum):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
if toonId == localAvatar.doId:
|
|
return
|
|
self.game.suitHitByGag(toonId, suitType, suitNum)
|
|
|
|
def d_requestSuitHitByGag(self, suitType, suitNum):
|
|
self.sendUpdate('requestSuitHitByGag', [suitType, suitNum])
|
|
|
|
def b_suitHitByGag(self, suitType, suitNum):
|
|
self.d_requestSuitHitByGag(suitType, suitNum)
|
|
self.game.suitHitByGag(base.localAvatar.doId, suitType, suitNum)
|
|
|
|
def toonHitByGag(self, toonId, hitToon, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
if toonId == localAvatar.doId:
|
|
return
|
|
elapsedTime = globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.toonHitByGag(toonId, hitToon, elapsedTime)
|
|
|
|
def d_broadcastSendToonHitByGag(self, toonId):
|
|
pass
|
|
|
|
def b_toonHitByGag(self, toonId):
|
|
self.d_broadcastSendToonHitByGag(toonId)
|
|
self.game.toonHitByGag(base.localAvatar.doId, toonId)
|
|
|
|
def toonHitBySuit(self, toonId, suitType, suitNum, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
if toonId == localAvatar.doId:
|
|
return
|
|
elapsedTime = globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.toonHitBySuit(toonId, suitType, suitNum, elapsedTime)
|
|
|
|
def d_requestHitBySuit(self, suitType, suitNum):
|
|
networkTime = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
|
|
self.sendUpdate('requestHitBySuit', [suitType, suitNum, networkTime])
|
|
|
|
def b_toonHitBySuit(self, suitType, suitNum):
|
|
self.d_requestHitBySuit(suitType, suitNum)
|
|
self.game.toonHitBySuit(base.localAvatar.doId, suitType, suitNum)
|
|
|
|
def toonHitByDrop(self, toonId):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
if toonId == localAvatar.doId:
|
|
return
|
|
self.game.toonHitByDrop(toonId)
|
|
|
|
def d_requestHitByDrop(self):
|
|
self.sendUpdate('requestHitByDrop', [])
|
|
|
|
def b_toonHitByDrop(self):
|
|
self.d_requestHitByDrop()
|
|
self.game.toonHitByDrop(base.localAvatar.doId)
|
|
|
|
def d_sendRequestPickUp(self, pickupNum):
|
|
self.sendUpdate('requestPickUp', [pickupNum])
|
|
|
|
def pickUp(self, toonId, pickupNum, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
elapsedTime = globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.pickUp(toonId, pickupNum, elapsedTime)
|
|
|
|
def d_sendRequestGag(self, waterCoolerIndex):
|
|
self.game.localPlayer.orthoWalk.sendCurrentPosition()
|
|
self.sendUpdate('requestGag', [waterCoolerIndex])
|
|
|
|
def hasGag(self, toonId, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if not self.getToon(base.localAvatar.doId):
|
|
return
|
|
elapsedTime = globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.hasGag(toonId, elapsedTime)
|
|
|
|
def doAction(self, action, data, networkTime):
|
|
if not self._gameInProgress():
|
|
return
|
|
if action == Globals.GameActions.RevealDoor:
|
|
self.game.toonRevealsDoor(data)
|
|
elif action == Globals.GameActions.EnterDoor:
|
|
self.game.toonEntersDoor(data)
|
|
elif action == Globals.GameActions.OpenDoor:
|
|
timeLeft = Globals.SecondsUntilGameEnds - globalClockDelta.localElapsedTime(networkTime)
|
|
self.game.openDoor(timeLeft)
|
|
elif action == Globals.GameActions.Countdown:
|
|
countdownTimeLeft = Globals.SecondsUntilTimeout
|
|
self.game.countdown(countdownTimeLeft)
|
|
elif action == Globals.GameActions.TimeAlert:
|
|
self.game.timeAlert()
|
|
|
|
def setToonSad(self, toonId):
|
|
DistCogdoGame.setToonSad(self, toonId)
|
|
self.game.handleToonWentSad(toonId)
|
|
|
|
def setToonDisconnect(self, toonId):
|
|
DistCogdoGame.setToonDisconnect(self, toonId)
|
|
self.game.handleToonDisconnected(toonId)
|
|
|
|
from otp.ai.MagicWordGlobal import *
|
|
@magicWord(category=CATEGORY_PROGRAMMER)
|
|
def revealMap():
|
|
if hasattr(base.cr, 'cogdoGame'):
|
|
game = base.cr.cogdoGame
|
|
game.game.guiMgr.mazeMapGui.showExit()
|
|
game.game.guiMgr.mazeMapGui.revealAll()
|