def setGameStart(self, timestamp):
        if not self.hasLocalToon: return
        self.notify.debug("setGameStart")
        # base class will cause gameFSM to enter initial state
        DistributedMinigame.setGameStart(self, timestamp)
        # all players have finished reading the rules, and are ready to start playing.

        ##        self.twoDDrive = TwoDDrive(self, self.TOON_SPEED, maxFrameMove=self.MAX_FRAME_MOVE)

        self.twoDWalk = TwoDWalk(self.twoDDrive,
                                 broadcast=not self.isSinglePlayer())

        # Initialize the scoreboard
        self.scores = [0] * self.numPlayers
        spacing = .4
        for i in xrange(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = \
                       MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId,
                                                                         avName)
            scorePanel.setScale(.9)
            scorePanel.setPos(.75 - spacing * ((self.numPlayers - 1) - i), 0.0,
                              .85)
            # make the panels slightly transparent
            scorePanel.makeTransparent(.75)
            self.scorePanels.append(scorePanel)

        # Transition to the appropriate state
        self.gameFSM.request("play", [timestamp])
Exemple #2
0
    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameStart')
        DistributedMinigame.setGameStart(self, timestamp)
        self.twoDWalk = TwoDWalk(self.twoDDrive, broadcast=not self.isSinglePlayer())
        self.scores = [0] * self.numPlayers
        spacing = 0.4
        for i in xrange(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
            scorePanel.setScale(0.9)
            scorePanel.setPos(-0.583 - spacing * (self.numPlayers - 1 - i), 0.0, -0.15)
            scorePanel.reparentTo(base.a2dTopRight)
            scorePanel.makeTransparent(0.75)
            self.scorePanels.append(scorePanel)

        self.gameFSM.request('play', [timestamp])
    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameStart')
        DistributedMinigame.setGameStart(self, timestamp)
        self.twoDWalk = TwoDWalk(self.twoDDrive, broadcast=not self.isSinglePlayer())
        self.scores = [0] * self.numPlayers
        spacing = 0.4
        for i in xrange(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
            scorePanel.setScale(0.9)
            scorePanel.setPos(0.75 - spacing * (self.numPlayers - 1 - i), 0.0, 0.85)
            scorePanel.makeTransparent(0.75)
            self.scorePanels.append(scorePanel)

        self.gameFSM.request('play', [timestamp])
class DistributedTwoDGame(DistributedMinigame):
    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedTwoDGame')
    UpdateLocalToonTask = 'ToonBlitzUpdateLocalToonTask'
    EndGameTaskName = 'endTwoDGame'

    def __init__(self, cr):
        DistributedMinigame.__init__(self, cr)
        self.gameFSM = ClassicFSM.ClassicFSM('DistributedTwoDGame', [
            State.State('off', self.enterOff, self.exitOff, ['play']),
            State.State('play', self.enterPlay, self.exitPlay,
                        ['cleanup', 'pause', 'showScores']),
            State.State('pause', self.enterPause, self.exitPause,
                        ['cleanup', 'play', 'showScores']),
            State.State('showScores', self.enterShowScores,
                        self.exitShowScores, ['cleanup']),
            State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
        ], 'off', 'cleanup')
        self.addChildGameFSM(self.gameFSM)
        self.reportedDone = False
        self.showCollSpheres = False

    def getTitle(self):
        return TTLocalizer.TwoDGameTitle

    def getInstructions(self):
        return TTLocalizer.TwoDGameInstructions

    def getMaxDuration(self):
        return 200

    def __defineConstants(self):
        self.TOON_SPEED = 12.0
        self.MAX_FRAME_MOVE = 1
        self.isHeadInFloor = False
        self.timeToRunToElevator = 1.5

    def setSectionsSelected(self, sectionsSelected):
        self.sectionsSelected = sectionsSelected

    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        self.__defineConstants()
        self.assetMgr = ToonBlitzAssetMgr.ToonBlitzAssetMgr(self)
        self.cameraMgr = TwoDCamera.TwoDCamera(camera)
        self.sectionMgr = TwoDSectionMgr.TwoDSectionMgr(
            self, self.sectionsSelected)
        self.gameStartX = -40.0
        endSection = self.sectionMgr.sections[-1]
        self.gameEndX = endSection.spawnPointMgr.gameEndX
        self.gameLength = self.gameEndX - self.gameStartX
        self.toonSDs = {}
        avId = self.localAvId
        toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
        self.toonSDs[avId] = toonSD
        self.toonSDs[avId].createHeadFrame(0)

    def unload(self):
        self.notify.debug('unload')
        DistributedMinigame.unload(self)
        taskMgr.remove(self.UpdateLocalToonTask)
        for avId in self.toonSDs.keys():
            toonSD = self.toonSDs[avId]
            toonSD.destroy()

        del self.toonSDs
        self.cameraMgr.destroy()
        del self.cameraMgr
        self.sectionMgr.destroy()
        del self.sectionMgr
        for panel in self.scorePanels:
            panel.cleanup()

        del self.scorePanels
        self.assetMgr.destroy()
        del self.assetMgr
        self.removeChildGameFSM(self.gameFSM)
        del self.gameFSM

    def onstage(self):
        self.notify.debug('onstage')
        DistributedMinigame.onstage(self)
        self.scorePanels = []
        self.assetMgr.onstage()
        lt = base.localAvatar
        lt.reparentTo(render)
        lt.hideName()
        self.__placeToon(self.localAvId)
        lt.setAnimState('Happy', 1.0)
        lt.setSpeed(0, 0)
        base.localAvatar.collisionsOn()
        base.localAvatar.setTransparency(1)
        self.setupHeadCollision()
        self.cameraMgr.onstage()
        toonSD = self.toonSDs[self.localAvId]
        toonSD.enter()
        toonSD.fsm.request('normal')
        self.twoDDrive = TwoDDrive(self,
                                   self.TOON_SPEED,
                                   maxFrameMove=self.MAX_FRAME_MOVE)

    def offstage(self):
        self.notify.debug('offstage')
        self.assetMgr.offstage()
        for avId in self.toonSDs.keys():
            self.toonSDs[avId].exit()

        base.localAvatar.setTransparency(0)
        self.ignore('enterheadCollSphere-into-floor1')
        base.localAvatar.controlManager.currentControls.cTrav.removeCollider(
            self.headCollNP)
        self.headCollNP.removeNode()
        del self.headCollNP
        base.localAvatar.laffMeter.start()
        DistributedMinigame.offstage(self)

    def setGameReady(self):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameReady')
        if DistributedMinigame.setGameReady(self):
            return
        drawNum = 0
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                drawNum += 1
                toon.reparentTo(render)
                toon.setAnimState('Happy', 1.0)
                toon.hideName()
                toon.startSmooth()
                toon.startLookAround()
                distCNP = toon.find('**/distAvatarCollNode*')
                distCNP.node().setIntoCollideMask(BitMask32.allOff())
                toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
                self.toonSDs[avId] = toonSD
                toonSD.enter()
                toonSD.fsm.request('normal')
                self.toonSDs[avId].createHeadFrame(drawNum)

    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameStart')
        DistributedMinigame.setGameStart(self, timestamp)
        self.twoDWalk = TwoDWalk(self.twoDDrive,
                                 broadcast=not self.isSinglePlayer())
        self.scores = [0] * self.numPlayers
        spacing = 0.4
        for i in range(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(
                avId, avName)
            scorePanel.setScale(0.9)
            scorePanel.setPos(0.75 - spacing * (self.numPlayers - 1 - i), 0.0,
                              0.85)
            scorePanel.makeTransparent(0.75)
            self.scorePanels.append(scorePanel)

        self.gameFSM.request('play', [timestamp])

    def enterOff(self):
        self.notify.debug('enterOff')

    def exitOff(self):
        pass

    def enterPlay(self, timestamp):
        self.notify.debug('enterPlay')
        elapsedTime = globalClockDelta.localElapsedTime(timestamp)
        self.sectionMgr.enterPlay(elapsedTime)
        handlers = [None, None, None, None, self.shootKeyHandler]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)
        self.twoDWalk.start()
        self.accept('jumpStart', self.startJump)
        self.accept('enemyHit', self.localToonHitByEnemy)
        self.accept('twoDTreasureGrabbed', self.__treasureGrabbed)
        self.accept('enemyShot', self.__enemyShot)
        taskMgr.remove(self.UpdateLocalToonTask)
        taskMgr.add(self.__updateLocalToonTask,
                    self.UpdateLocalToonTask,
                    priority=1)
        base.localAvatar.laffMeter.stop()
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.setTime(ToonBlitzGlobals.GameDuration[self.getSafezoneId()])
        self.timer.countdown(
            ToonBlitzGlobals.GameDuration[self.getSafezoneId()],
            self.timerExpired)
        return

    def exitPlay(self):
        handlers = [None, None, None, None, None]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)
        if self.toonSDs[
                self.localAvId].fsm.getCurrentState().getName() != 'victory':
            base.localAvatar.b_setAnimState('Happy', 1.0)
        self.ignore('jumpStart')
        self.ignore('enemyHit')
        self.ignore('twoDTreasureGrabbed')
        return

    def enterPause(self):
        self.notify.debug('enterPause')

    def exitPause(self):
        pass

    def enterShowScores(self):
        self.notify.debug('enterShowScores')
        lerpTrack = Parallel()
        lerpDur = 0.5
        tY = 0.6
        bY = -.6
        lX = -.7
        cX = 0
        rX = 0.7
        scorePanelLocs = (((cX, bY), ), ((lX, bY), (rX, bY)),
                          ((cX, bY), (lX, bY), (rX, bY)), ((lX, tY), (rX, tY),
                                                           (lX, bY), (rX, bY)))
        scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
        for i in range(self.numPlayers):
            panel = self.scorePanels[i]
            pos = scorePanelLocs[i]
            lerpTrack.append(
                Parallel(
                    LerpPosInterval(panel,
                                    lerpDur,
                                    Point3(pos[0], 0, pos[1]),
                                    blendType='easeInOut'),
                    LerpScaleInterval(panel,
                                      lerpDur,
                                      Vec3(panel.getScale()) * 1.5,
                                      blendType='easeInOut')))

        self.showScoreTrack = Parallel(
            lerpTrack, self.getElevatorCloseTrack(),
            Sequence(Wait(ToonBlitzGlobals.ShowScoresDuration),
                     Func(self.gameOver)))
        self.showScoreTrack.start()

    def exitShowScores(self):
        self.showScoreTrack.pause()
        del self.showScoreTrack

    def enterCleanup(self):
        self.notify.debug('enterCleanup')
        self.timer.stop()
        self.timer.destroy()
        del self.timer
        taskMgr.remove(self.EndGameTaskName)
        self.twoDWalk.stop()
        self.twoDWalk.destroy()
        del self.twoDWalk
        self.twoDDrive = None
        del self.twoDDrive
        return

    def exitCleanup(self):
        pass

    def acceptInputs(self):
        if hasattr(self, 'twoDDrive'):
            handlers = [None, None, None, None, self.shootKeyHandler]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            self.twoDDrive.start()
        return

    def ignoreInputs(self):
        if hasattr(self, 'twoDDrive'):
            handlers = [None, None, None, None, None]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            self.twoDDrive.lastAction = None
            self.twoDDrive.stop()
        return

    def __updateLocalToonTask(self, task):
        dt = globalClock.getDt()
        self.cameraMgr.update()
        if self.gameFSM.getCurrentState().getName() == 'play':
            if not self.toonSDs[self.localAvId].fsm.getCurrentState().getName(
            ) == 'victory':
                if not base.localAvatar.getY() == 0:
                    base.localAvatar.setY(0)
        if base.localAvatar.getZ() < -2.0:
            self.localToonFellDown()
        for avId in self.toonSDs.keys():
            self.toonSDs[avId].update()

        return task.cont

    def handleDisabledAvatar(self, avId):
        self.notify.debug('handleDisabledAvatar')
        self.notify.debug('avatar ' + str(avId) + ' disabled')
        self.toonSDs[avId].exit(unexpectedExit=True)
        del self.toonSDs[avId]
        DistributedMinigame.handleDisabledAvatar(self, avId)

    def setupHeadCollision(self):
        collSphere = CollisionSphere(0, 0, 0, 1)
        collSphere.setTangible(1)
        collNode = CollisionNode('headCollSphere')
        collNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        collNode.setIntoCollideMask(BitMask32.allOff())
        collNode.addSolid(collSphere)
        head = base.localAvatar.getPart('head', '1000')
        self.headCollNP = head.attachNewNode(collNode)
        self.headCollNP.setPos(0, 0, 0.0)
        animal = base.localAvatar.style.getAnimal()
        if animal == 'dog' or animal == 'bear' or animal == 'horse':
            torso = base.localAvatar.style.torso
            legs = base.localAvatar.style.legs
            if (torso == 'ls' or torso == 'ld') and legs == 'l':
                self.headCollNP.setZ(-1.3)
            else:
                self.headCollNP.setZ(-0.7)
        elif animal == 'mouse' or animal == 'duck':
            self.headCollNP.setZ(0.5)
        elif animal == 'cat':
            self.headCollNP.setZ(-0.3)
        elif animal == 'rabbit':
            self.headCollNP.setZ(-0.5)
        elif animal == 'monkey':
            self.headCollNP.setZ(0.3)
        elif animal == 'pig':
            self.headCollNP.setZ(-0.7)
        self.headCollNP.hide()
        if self.showCollSpheres:
            self.headCollNP.show()
        headCollisionEvent = CollisionHandlerEvent()
        headCollisionEvent.addInPattern('enter%fn-into-%in')
        headCollisionEvent.addOutPattern('%fn-exit-%in')
        cTrav = base.localAvatar.controlManager.currentControls.cTrav
        cTrav.addCollider(self.headCollNP, headCollisionEvent)
        self.accept('enterheadCollSphere-into-floor1',
                    self.__handleHeadCollisionIntoFloor)
        self.accept('headCollSphere-exit-floor1',
                    self.__handleHeadCollisionExitFloor)

    def __handleHeadCollisionIntoFloor(self, cevent):
        self.isHeadInFloor = True
        if base.localAvatar.controlManager.currentControls.lifter.getVelocity(
        ) > 0:
            base.localAvatar.controlManager.currentControls.lifter.setVelocity(
                0.0)
            self.assetMgr.playHeadCollideSound()

    def __handleHeadCollisionExitFloor(self, cevent):
        self.isHeadInFloor = False

    def __placeToon(self, avId):
        toon = self.getAvatar(avId)
        i = self.avIdList.index(avId)
        pos = Point3(ToonBlitzGlobals.ToonStartingPosition[0] + i,
                     ToonBlitzGlobals.ToonStartingPosition[1],
                     ToonBlitzGlobals.ToonStartingPosition[2])
        toon.setPos(pos)
        toon.setHpr(-90, 0, 0)

    def startJump(self):
        self.assetMgr.playJumpSound()

    def checkValidity(self, avId):
        if not self.hasLocalToon:
            return False
        if self.gameFSM.getCurrentState(
        ) == None or self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring msg: av %s performing some action.' %
                                avId)
            return False
        toon = self.getAvatar(avId)
        if toon == None:
            return False
        return True

    def shootKeyHandler(self):
        self.toonSDs[self.localAvId].shootGun()
        timestamp = globalClockDelta.localToNetworkTime(
            globalClock.getFrameTime())
        self.sendUpdate('showShootGun', [self.localAvId, timestamp])

    def showShootGun(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s is shooting water gun' % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].shootGun()

    def localToonFellDown(self):
        if self.toonSDs[
                self.localAvId].fsm.getCurrentState().getName() != 'fallDown':
            self.toonSDs[self.localAvId].fsm.request('fallDown')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            self.updateScore(
                self.localAvId,
                ToonBlitzGlobals.ScoreLossPerFallDown[self.getSafezoneId()])
            self.sendUpdate('toonFellDown', [self.localAvId, timestamp])

    def toonFellDown(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s fell down.' % avId)
            if avId != self.localAvId:
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerFallDown[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallDown')

    def localToonHitByEnemy(self):
        currToonState = self.toonSDs[
            self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('fallBack')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            self.updateScore(
                self.localAvId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[
                    self.getSafezoneId()])
            self.sendUpdate('toonHitByEnemy', [self.localAvId, timestamp])

    def toonHitByEnemy(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s hit by a suit' % avId)
            if avId != self.localAvId:
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallBack')

    def localToonSquished(self):
        currToonState = self.toonSDs[
            self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('squish')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            self.updateScore(
                self.localAvId, ToonBlitzGlobals.ScoreLossPerStomperSquish[
                    self.getSafezoneId()])
            self.sendUpdate('toonSquished', [self.localAvId, timestamp])

    def toonSquished(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s is squished.' % avId)
            if avId != self.localAvId:
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerStomperSquish[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('squish')

    def localToonVictory(self):
        if not ToonBlitzGlobals.EndlessGame:
            self.ignoreInputs()
        if not self.toonSDs[
                self.localAvId].fsm.getCurrentState().getName() == 'victory':
            self.toonSDs[self.localAvId].fsm.request('victory')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            self.sendUpdate('toonVictory', [self.localAvId, timestamp])

    def toonVictory(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s achieves victory' % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].fsm.request('victory')

    def addVictoryScore(self, avId, score):
        if not self.hasLocalToon:
            return
        self.updateScore(avId, score)
        if avId == self.localAvId:
            self.assetMgr.threeSparkles.play()

    def __treasureGrabbed(self, sectionIndex, treasureIndex):
        self.notify.debug('treasure %s-%s grabbed' %
                          (sectionIndex, treasureIndex))
        section = self.sectionMgr.sections[sectionIndex]
        section.treasureMgr.treasures[treasureIndex].hideTreasure()
        self.assetMgr.treasureGrabSound.play()
        self.sendUpdate('claimTreasure', [sectionIndex, treasureIndex])

    def setTreasureGrabbed(self, avId, sectionIndex, treasureIndex):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() == 'play':
            self.notify.debug('treasure %s-%s grabbed by %s' %
                              (sectionIndex, treasureIndex, avId))
            numSections = len(self.sectionMgr.sections)
            if sectionIndex < numSections:
                section = self.sectionMgr.sections[sectionIndex]
                numTreasures = len(section.treasureMgr.treasures)
                if treasureIndex < numTreasures:
                    treasure = section.treasureMgr.treasures[treasureIndex]
                    if avId != self.localAvId:
                        treasure.hideTreasure()
                    self.updateScore(
                        avId,
                        ToonBlitzGlobals.ScoreGainPerTreasure * treasure.value)
                else:
                    self.notify.error(
                        'WHOA!! treasureIndex %s is out of range; numTreasures = %s'
                        % (treasureIndex, numTreasures))
                    base.localAvatar.sendLogMessage(
                        'treasureIndex %s is out of range; numTreasures = %s' %
                        (treasureIndex, numTreasures))
            else:
                self.notify.error(
                    'WHOA!! sectionIndex %s is out of range; numSections = %s'
                    % (sectionIndex, numSections))
                base.localAvatar.sendLogMessage(
                    'sectionIndex %s is out of range; numSections = %s' %
                    (sectionIndex, numSections))

    def __enemyShot(self, sectionIndex, enemyIndex):
        self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[
            enemyIndex].doShotTrack()
        self.sendUpdate('claimEnemyShot', [sectionIndex, enemyIndex])

    def setEnemyShot(self, avId, sectionIndex, enemyIndex, enemyHealth):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() == 'play':
            self.notify.debug('enemy %s is shot by %s. Health left %s' %
                              (enemyIndex, avId, enemyHealth))
            if enemyHealth > 0:
                if not avId == self.localAvId:
                    self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[
                        enemyIndex].doShotTrack()
            else:
                enemy = self.sectionMgr.sections[
                    sectionIndex].enemyMgr.enemies[enemyIndex]
                treasureSpawnPoint = Point3(
                    enemy.suit.getX(), enemy.suit.getY(),
                    enemy.suit.getZ() + enemy.suit.height / 2.0)
                self.spawnTreasure(sectionIndex, enemyIndex,
                                   treasureSpawnPoint)
                enemy.doDeathTrack()

    def updateScore(self, avId, deltaScore):
        i = self.avIdList.index(avId)
        self.scores[i] += deltaScore
        self.scorePanels[i].setScore(self.scores[i])
        self.toonSDs[avId].showScoreText(deltaScore)

    def spawnTreasure(self, sectionIndex, enemyIndex, pos):
        if self.gameFSM.getCurrentState().getName() == 'play':
            section = self.sectionMgr.sections[sectionIndex]
            treasure = section.treasureMgr.enemyTreasures[enemyIndex]
            treasure.setTreasurePos(pos)
            treasure.popupEnemyTreasure()

    def timerExpired(self):
        self.notify.debug('timer expired')
        if not self.reportedDone:
            if not ToonBlitzGlobals.EndlessGame:
                self.ignoreInputs()
            self.reportedDone = True
            self.sendUpdate('reportDone')

    def setEveryoneDone(self):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring setEveryoneDone msg')
            return
        self.notify.debug('setEveryoneDone')

        def endGame(task, self=self):
            if not ToonBlitzGlobals.EndlessGame:
                self.gameFSM.request('showScores')
            return Task.done

        self.timer.hide()
        taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)

    def getElevatorCloseTrack(self):
        leftDoor = self.sectionMgr.exitElevator.find('**/doorL')
        rightDoor = self.sectionMgr.exitElevator.find('**/doorR')
        leftDoorClose = LerpPosInterval(leftDoor, 2, Point3(3.02, 0, 0))
        rightDoorClose = LerpPosInterval(rightDoor, 2, Point3(-3.02, 0, 0))
        return Sequence(Wait(self.timeToRunToElevator),
                        Parallel(leftDoorClose, rightDoorClose))

    def debugStartPause(self):
        self.sectionMgr.enterPause()

    def debugEndPause(self):
        self.sectionMgr.exitPause()
class DistributedTwoDGame(DistributedMinigame):
    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedTwoDGame')
    UpdateLocalToonTask = 'ToonBlitzUpdateLocalToonTask'
    EndGameTaskName = 'endTwoDGame'

    def __init__(self, cr):
        DistributedMinigame.__init__(self, cr)
        self.gameFSM = ClassicFSM.ClassicFSM('DistributedTwoDGame', [State.State('off', self.enterOff, self.exitOff, ['play']),
         State.State('play', self.enterPlay, self.exitPlay, ['cleanup', 'pause', 'showScores']),
         State.State('pause', self.enterPause, self.exitPause, ['cleanup', 'play', 'showScores']),
         State.State('showScores', self.enterShowScores, self.exitShowScores, ['cleanup']),
         State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
        self.addChildGameFSM(self.gameFSM)
        self.reportedDone = False
        self.showCollSpheres = False

    def getTitle(self):
        return TTLocalizer.TwoDGameTitle

    def getInstructions(self):
        return TTLocalizer.TwoDGameInstructions

    def getMaxDuration(self):
        return 200

    def __defineConstants(self):
        self.TOON_SPEED = 12.0
        self.MAX_FRAME_MOVE = 1
        self.isHeadInFloor = False
        self.timeToRunToElevator = 1.5

    def setSectionsSelected(self, sectionsSelected):
        self.sectionsSelected = sectionsSelected

    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        self.__defineConstants()
        self.assetMgr = ToonBlitzAssetMgr.ToonBlitzAssetMgr(self)
        self.cameraMgr = TwoDCamera.TwoDCamera(camera)
        self.sectionMgr = TwoDSectionMgr.TwoDSectionMgr(self, self.sectionsSelected)
        self.gameStartX = -40.0
        endSection = self.sectionMgr.sections[-1]
        self.gameEndX = endSection.spawnPointMgr.gameEndX
        self.gameLength = self.gameEndX - self.gameStartX
        self.toonSDs = {}
        avId = self.localAvId
        toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
        self.toonSDs[avId] = toonSD
        self.toonSDs[avId].createHeadFrame(0)

    def unload(self):
        self.notify.debug('unload')
        DistributedMinigame.unload(self)
        taskMgr.remove(self.UpdateLocalToonTask)
        for avId in self.toonSDs.keys():
            toonSD = self.toonSDs[avId]
            toonSD.destroy()

        del self.toonSDs
        self.cameraMgr.destroy()
        del self.cameraMgr
        self.sectionMgr.destroy()
        del self.sectionMgr
        for panel in self.scorePanels:
            panel.cleanup()

        del self.scorePanels
        self.assetMgr.destroy()
        del self.assetMgr
        self.removeChildGameFSM(self.gameFSM)
        del self.gameFSM

    def onstage(self):
        self.notify.debug('onstage')
        DistributedMinigame.onstage(self)
        self.scorePanels = []
        self.assetMgr.onstage()
        lt = base.localAvatar
        lt.reparentTo(render)
        lt.hideName()
        self.__placeToon(self.localAvId)
        lt.setAnimState('Happy', 1.0)
        lt.setSpeed(0, 0)
        base.localAvatar.collisionsOn()
        base.localAvatar.setTransparency(1)
        self.setupHeadCollision()
        self.cameraMgr.onstage()
        toonSD = self.toonSDs[self.localAvId]
        toonSD.enter()
        toonSD.fsm.request('normal')
        self.twoDDrive = TwoDDrive(self, self.TOON_SPEED, maxFrameMove=self.MAX_FRAME_MOVE)

    def offstage(self):
        self.notify.debug('offstage')
        self.assetMgr.offstage()
        for avId in self.toonSDs.keys():
            self.toonSDs[avId].exit()

        base.localAvatar.setTransparency(0)
        self.ignore('enterheadCollSphere-into-floor1')
        base.localAvatar.controlManager.currentControls.cTrav.removeCollider(self.headCollNP)
        self.headCollNP.removeNode()
        del self.headCollNP
        base.localAvatar.laffMeter.start()
        DistributedMinigame.offstage(self)

    def setGameReady(self):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameReady')
        if DistributedMinigame.setGameReady(self):
            return
        drawNum = 0
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                drawNum += 1
                toon.reparentTo(render)
                toon.setAnimState('Happy', 1.0)
                toon.hideName()
                toon.startSmooth()
                toon.startLookAround()
                distCNP = toon.find('**/distAvatarCollNode*')
                distCNP.node().setIntoCollideMask(BitMask32.allOff())
                toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
                self.toonSDs[avId] = toonSD
                toonSD.enter()
                toonSD.fsm.request('normal')
                self.toonSDs[avId].createHeadFrame(drawNum)

    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameStart')
        DistributedMinigame.setGameStart(self, timestamp)
        self.twoDWalk = TwoDWalk(self.twoDDrive, broadcast=not self.isSinglePlayer())
        self.scores = [0] * self.numPlayers
        spacing = 0.4
        for i in xrange(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
            scorePanel.setScale(0.9)
            scorePanel.setPos(-0.583 - spacing * (self.numPlayers - 1 - i), 0.0, -0.15)
            scorePanel.reparentTo(base.a2dTopRight)
            scorePanel.makeTransparent(0.75)
            self.scorePanels.append(scorePanel)

        self.gameFSM.request('play', [timestamp])

    def enterOff(self):
        self.notify.debug('enterOff')

    def exitOff(self):
        pass

    def enterPlay(self, timestamp):
        self.notify.debug('enterPlay')
        elapsedTime = globalClockDelta.localElapsedTime(timestamp)
        self.sectionMgr.enterPlay(elapsedTime)
        handlers = [None,
         None,
         None,
         None,
         self.shootKeyHandler]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)
        self.twoDWalk.start()
        self.accept('jumpStart', self.startJump)
        self.accept('enemyHit', self.localToonHitByEnemy)
        self.accept('twoDTreasureGrabbed', self.__treasureGrabbed)
        self.accept('enemyShot', self.__enemyShot)
        taskMgr.remove(self.UpdateLocalToonTask)
        taskMgr.add(self.__updateLocalToonTask, self.UpdateLocalToonTask, priority=1)
        base.localAvatar.laffMeter.stop()
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.setTime(ToonBlitzGlobals.GameDuration[self.getSafezoneId()])
        self.timer.countdown(ToonBlitzGlobals.GameDuration[self.getSafezoneId()], self.timerExpired)
        return

    def exitPlay(self):
        handlers = [None,
         None,
         None,
         None,
         None]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)
        if self.toonSDs[self.localAvId].fsm.getCurrentState().getName() != 'victory':
            base.localAvatar.b_setAnimState('Happy', 1.0)
        self.ignore('jumpStart')
        self.ignore('enemyHit')
        self.ignore('twoDTreasureGrabbed')
        return

    def enterPause(self):
        self.notify.debug('enterPause')

    def exitPause(self):
        pass

    def enterShowScores(self):
        self.notify.debug('enterShowScores')
        lerpTrack = Parallel()
        lerpDur = 0.5
        tY = 0.6
        bY = -.6
        lX = -.7
        cX = 0
        rX = 0.7
        scorePanelLocs = (((cX, bY),),
         ((lX, bY), (rX, bY)),
         ((cX, bY), (lX, bY), (rX, bY)),
         ((lX, tY),
          (rX, tY),
          (lX, bY),
          (rX, bY)))
        scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
        for i in xrange(self.numPlayers):
            panel = self.scorePanels[i]
            pos = scorePanelLocs[i]
            panel.wrtReparentTo(aspect2d)
            lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 1.5, blendType='easeInOut')))

        self.showScoreTrack = Parallel(lerpTrack, self.getElevatorCloseTrack(), Sequence(Wait(ToonBlitzGlobals.ShowScoresDuration), Func(self.gameOver)))
        self.showScoreTrack.start()

        #For the Alpha Blueprint ARG
        if base.config.GetBool('want-blueprint4-ARG', False):
            MinigameGlobals.generateDebugARGPhrase()

    def exitShowScores(self):
        self.showScoreTrack.pause()
        del self.showScoreTrack

    def enterCleanup(self):
        self.notify.debug('enterCleanup')
        self.timer.stop()
        self.timer.destroy()
        del self.timer
        taskMgr.remove(self.EndGameTaskName)
        self.twoDWalk.stop()
        self.twoDWalk.destroy()
        del self.twoDWalk
        self.twoDDrive = None
        del self.twoDDrive
        return

    def exitCleanup(self):
        pass

    def acceptInputs(self):
        if hasattr(self, 'twoDDrive'):
            handlers = [None,
             None,
             None,
             None,
             self.shootKeyHandler]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            self.twoDDrive.start()
        return

    def ignoreInputs(self):
        if hasattr(self, 'twoDDrive'):
            handlers = [None,
             None,
             None,
             None,
             None]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            self.twoDDrive.lastAction = None
            self.twoDDrive.stop()
        return

    def __updateLocalToonTask(self, task):
        dt = globalClock.getDt()
        self.cameraMgr.update()
        if self.gameFSM.getCurrentState().getName() == 'play':
            if not self.toonSDs[self.localAvId].fsm.getCurrentState().getName() == 'victory':
                if not base.localAvatar.getY() == 0:
                    base.localAvatar.setY(0)
        if base.localAvatar.getZ() < -2.0:
            self.localToonFellDown()
        for avId in self.toonSDs.keys():
            self.toonSDs[avId].update()

        return task.cont

    def handleDisabledAvatar(self, avId):
        self.notify.debug('handleDisabledAvatar')
        self.notify.debug('avatar ' + str(avId) + ' disabled')
        self.toonSDs[avId].exit(unexpectedExit=True)
        del self.toonSDs[avId]
        DistributedMinigame.handleDisabledAvatar(self, avId)

    def setupHeadCollision(self):
        collSphere = CollisionSphere(0, 0, 0, 1)
        collSphere.setTangible(1)
        collNode = CollisionNode('headCollSphere')
        collNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        collNode.setIntoCollideMask(BitMask32.allOff())
        collNode.addSolid(collSphere)
        head = base.localAvatar.getPart('head', '1000')
        self.headCollNP = head.attachNewNode(collNode)
        self.headCollNP.setPos(0, 0, 0.0)
        animal = base.localAvatar.style.getAnimal()
        if animal == 'dog' or animal == 'bear' or animal == 'horse':
            torso = base.localAvatar.style.torso
            legs = base.localAvatar.style.legs
            if (torso == 'ls' or torso == 'ld') and legs == 'l':
                self.headCollNP.setZ(-1.3)
            else:
                self.headCollNP.setZ(-0.7)
        elif animal == 'mouse' or animal == 'duck':
            self.headCollNP.setZ(0.5)
        elif animal == 'cat':
            self.headCollNP.setZ(-0.3)
        elif animal == 'rabbit':
            self.headCollNP.setZ(-0.5)
        elif animal == 'monkey':
            self.headCollNP.setZ(0.3)
        elif animal == 'pig':
            self.headCollNP.setZ(-0.7)
        self.headCollNP.hide()
        if self.showCollSpheres:
            self.headCollNP.show()
        headCollisionEvent = CollisionHandlerEvent()
        headCollisionEvent.addInPattern('enter%fn-into-%in')
        headCollisionEvent.addOutPattern('%fn-exit-%in')
        cTrav = base.localAvatar.controlManager.currentControls.cTrav
        cTrav.addCollider(self.headCollNP, headCollisionEvent)
        self.accept('enterheadCollSphere-into-floor1', self.__handleHeadCollisionIntoFloor)
        self.accept('headCollSphere-exit-floor1', self.__handleHeadCollisionExitFloor)

    def __handleHeadCollisionIntoFloor(self, cevent):
        self.isHeadInFloor = True
        if base.localAvatar.controlManager.currentControls.lifter.getVelocity() > 0:
            base.localAvatar.controlManager.currentControls.lifter.setVelocity(0.0)
            self.assetMgr.playHeadCollideSound()

    def __handleHeadCollisionExitFloor(self, cevent):
        self.isHeadInFloor = False

    def __placeToon(self, avId):
        toon = self.getAvatar(avId)
        i = self.avIdList.index(avId)
        pos = Point3(ToonBlitzGlobals.ToonStartingPosition[0] + i, ToonBlitzGlobals.ToonStartingPosition[1], ToonBlitzGlobals.ToonStartingPosition[2])
        toon.setPos(pos)
        toon.setHpr(-90, 0, 0)

    def startJump(self):
        self.assetMgr.playJumpSound()

    def checkValidity(self, avId):
        if not self.hasLocalToon:
            return False
        if self.gameFSM.getCurrentState() == None or self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring msg: av %s performing some action.' % avId)
            return False
        toon = self.getAvatar(avId)
        if toon == None:
            return False
        return True

    def shootKeyHandler(self):
        self.toonSDs[self.localAvId].shootGun()
        timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
        self.sendUpdate('showShootGun', [self.localAvId, timestamp])

    def showShootGun(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s is shooting water gun' % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].shootGun()

    def localToonFellDown(self):
        if self.toonSDs[self.localAvId].fsm.getCurrentState().getName() != 'fallDown':
            self.toonSDs[self.localAvId].fsm.request('fallDown')
            timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
            self.updateScore(self.localAvId, ToonBlitzGlobals.ScoreLossPerFallDown[self.getSafezoneId()])
            self.sendUpdate('toonFellDown', [self.localAvId, timestamp])

    def toonFellDown(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s fell down.' % avId)
            if avId != self.localAvId:
                self.updateScore(avId, ToonBlitzGlobals.ScoreLossPerFallDown[self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallDown')

    def localToonHitByEnemy(self):
        currToonState = self.toonSDs[self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('fallBack')
            timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
            self.updateScore(self.localAvId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[self.getSafezoneId()])
            self.sendUpdate('toonHitByEnemy', [self.localAvId, timestamp])

    def toonHitByEnemy(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s hit by a suit' % avId)
            if avId != self.localAvId:
                self.updateScore(avId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallBack')

    def localToonSquished(self):
        currToonState = self.toonSDs[self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('squish')
            timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
            self.updateScore(self.localAvId, ToonBlitzGlobals.ScoreLossPerStomperSquish[self.getSafezoneId()])
            self.sendUpdate('toonSquished', [self.localAvId, timestamp])

    def toonSquished(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s is squished.' % avId)
            if avId != self.localAvId:
                self.updateScore(avId, ToonBlitzGlobals.ScoreLossPerStomperSquish[self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('squish')

    def localToonVictory(self):
        if not ToonBlitzGlobals.EndlessGame:
            self.ignoreInputs()
        if not self.toonSDs[self.localAvId].fsm.getCurrentState().getName() == 'victory':
            self.toonSDs[self.localAvId].fsm.request('victory')
            timestamp = globalClockDelta.localToNetworkTime(globalClock.getFrameTime())
            self.sendUpdate('toonVictory', [self.localAvId, timestamp])

    def toonVictory(self, avId, timestamp):
        if self.checkValidity(avId):
            self.notify.debug('avatar %s achieves victory' % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].fsm.request('victory')

    def addVictoryScore(self, avId, score):
        if not self.hasLocalToon:
            return
        self.updateScore(avId, score)
        if avId == self.localAvId:
            self.assetMgr.threeSparkles.play()

    def __treasureGrabbed(self, sectionIndex, treasureIndex):
        self.notify.debug('treasure %s-%s grabbed' % (sectionIndex, treasureIndex))
        section = self.sectionMgr.sections[sectionIndex]
        section.treasureMgr.treasures[treasureIndex].hideTreasure()
        self.assetMgr.treasureGrabSound.play()
        self.sendUpdate('claimTreasure', [sectionIndex, treasureIndex])

    def setTreasureGrabbed(self, avId, sectionIndex, treasureIndex):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() == 'play':
            self.notify.debug('treasure %s-%s grabbed by %s' % (sectionIndex, treasureIndex, avId))
            numSections = len(self.sectionMgr.sections)
            if sectionIndex < numSections:
                section = self.sectionMgr.sections[sectionIndex]
                numTreasures = len(section.treasureMgr.treasures)
                if treasureIndex < numTreasures:
                    treasure = section.treasureMgr.treasures[treasureIndex]
                    if avId != self.localAvId:
                        treasure.hideTreasure()
                    self.updateScore(avId, ToonBlitzGlobals.ScoreGainPerTreasure * treasure.value)
                else:
                    self.notify.error('WHOA!! treasureIndex %s is out of range; numTreasures = %s' % (treasureIndex, numTreasures))
                    base.localAvatar.sendLogMessage('treasureIndex %s is out of range; numTreasures = %s' % (treasureIndex, numTreasures))
            else:
                self.notify.error('WHOA!! sectionIndex %s is out of range; numSections = %s' % (sectionIndex, numSections))
                base.localAvatar.sendLogMessage('sectionIndex %s is out of range; numSections = %s' % (sectionIndex, numSections))

    def __enemyShot(self, sectionIndex, enemyIndex):
        self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[enemyIndex].doShotTrack()
        self.sendUpdate('claimEnemyShot', [sectionIndex, enemyIndex])

    def setEnemyShot(self, avId, sectionIndex, enemyIndex, enemyHealth):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() == 'play':
            self.notify.debug('enemy %s is shot by %s. Health left %s' % (enemyIndex, avId, enemyHealth))
            if enemyHealth > 0:
                if not avId == self.localAvId:
                    self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[enemyIndex].doShotTrack()
            else:
                enemy = self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[enemyIndex]
                treasureSpawnPoint = Point3(enemy.suit.getX(), enemy.suit.getY(), enemy.suit.getZ() + enemy.suit.height / 2.0)
                self.spawnTreasure(sectionIndex, enemyIndex, treasureSpawnPoint)
                enemy.doDeathTrack()

    def updateScore(self, avId, deltaScore):
        i = self.avIdList.index(avId)
        self.scores[i] += deltaScore
        self.scorePanels[i].setScore(self.scores[i])
        self.toonSDs[avId].showScoreText(deltaScore)

    def spawnTreasure(self, sectionIndex, enemyIndex, pos):
        if self.gameFSM.getCurrentState().getName() == 'play':
            section = self.sectionMgr.sections[sectionIndex]
            treasure = section.treasureMgr.enemyTreasures[enemyIndex]
            treasure.setTreasurePos(pos)
            treasure.popupEnemyTreasure()

    def timerExpired(self):
        self.notify.debug('timer expired')
        if not self.reportedDone:
            if not ToonBlitzGlobals.EndlessGame:
                self.ignoreInputs()
            self.reportedDone = True
            self.sendUpdate('reportDone')

    def setEveryoneDone(self):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring setEveryoneDone msg')
            return
        self.notify.debug('setEveryoneDone')

        def endGame(task, self = self):
            if not ToonBlitzGlobals.EndlessGame:
                self.gameFSM.request('showScores')
            return Task.done

        self.timer.hide()
        taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)

    def getElevatorCloseTrack(self):
        leftDoor = self.sectionMgr.exitElevator.find('**/doorL')
        rightDoor = self.sectionMgr.exitElevator.find('**/doorR')
        leftDoorClose = LerpPosInterval(leftDoor, 2, Point3(3.02, 0, 0))
        rightDoorClose = LerpPosInterval(rightDoor, 2, Point3(-3.02, 0, 0))
        return Sequence(Wait(self.timeToRunToElevator), Parallel(leftDoorClose, rightDoorClose))

    def debugStartPause(self):
        self.sectionMgr.enterPause()

    def debugEndPause(self):
        self.sectionMgr.exitPause()
class DistributedTwoDGame(DistributedMinigame):
    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedTwoDGame')
    # define constants that you won't want to tweak here

    UpdateLocalToonTask = "ToonBlitzUpdateLocalToonTask"  # name of the update task called each frame
    EndGameTaskName = 'endTwoDGame'

    def __init__(self, cr):
        DistributedMinigame.__init__(self, cr)
        self.gameFSM = ClassicFSM.ClassicFSM(
            'DistributedTwoDGame',
            [
                State.State('off', self.enterOff, self.exitOff, ['play']),
                State.State('play', self.enterPlay, self.exitPlay,
                            ['cleanup', 'pause', 'showScores']),
                State.State('pause', self.enterPause, self.exitPause,
                            ['cleanup', 'play', 'showScores']),
                State.State('showScores', self.enterShowScores,
                            self.exitShowScores, ['cleanup']),
                State.State('cleanup', self.enterCleanup, self.exitCleanup,
                            []),
            ],
            # Initial State
            'off',
            # Final State
            'cleanup',
        )

        # it's important for the final state to do cleanup;
        # on disconnect, the ClassicFSM will be forced into the
        # final state. All states (except 'off') should
        # be prepared to transition to 'cleanup' at any time.

        # Add our game ClassicFSM to the framework ClassicFSM
        self.addChildGameFSM(self.gameFSM)

        if __debug__:
            base.mg = self
            self.accept('p', self.debugStartPause)
            self.accept('o', self.debugEndPause)
##            self.accept('y', self.localToonVictory)

        self.reportedDone = False
        self.showCollSpheres = False

    def getTitle(self):
        return TTLocalizer.TwoDGameTitle

    def getInstructions(self):
        return TTLocalizer.TwoDGameInstructions

    def getMaxDuration(self):
        # how many seconds can this minigame possibly last (within reason)?
        # this is for debugging only
        return 200

    def __defineConstants(self):
        '''Define all the game contants here.'''
        self.TOON_SPEED = 12.0
        self.MAX_FRAME_MOVE = 1
        self.isHeadInFloor = False
        self.timeToRunToElevator = 1.5

    def setSectionsSelected(self, sectionsSelected):
        """ Set the sectionsSelected as dictated by the AI."""
        self.sectionsSelected = sectionsSelected

    def load(self):
        self.notify.debug("load")
        DistributedMinigame.load(self)
        self.__defineConstants()
        # Load resources and create objects here
        # Create Asset Manager and load assets
        self.assetMgr = ToonBlitzAssetMgr.ToonBlitzAssetMgr(self)
        # Create camera
        self.cameraMgr = TwoDCamera.TwoDCamera(camera)
        # Create a Section Manager
        self.sectionMgr = TwoDSectionMgr.TwoDSectionMgr(
            self, self.sectionsSelected)
        # Get the start and end X values of the game. Required for the progress line.
        self.gameStartX = -40.
        endSection = self.sectionMgr.sections[-1]
        # This is just to confirm that the last section is actually the endSection
        assert endSection.sectionTypeNum == 'end'
        self.gameEndX = endSection.spawnPointMgr.gameEndX
        self.gameLength = self.gameEndX - self.gameStartX

        # make a dictionary of TwoDGameToonSDs; they will track
        # toons' states and animate them appropriately
        self.toonSDs = {}
        # add the local toon now, add remote toons as they join
        avId = self.localAvId
        toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
        self.toonSDs[avId] = toonSD
        # The toon with the higher drawNum is rendered closer to the camera.
        # Local toon is rendered with a drawNum of 0. In the progress line the
        # other toons appear in front of the localToon.
        self.toonSDs[avId].createHeadFrame(0)

    def unload(self):
        self.notify.debug("unload")
        DistributedMinigame.unload(self)
        taskMgr.remove(self.UpdateLocalToonTask)

        # unload resources and delete objects from load() here
        for avId in self.toonSDs.keys():
            toonSD = self.toonSDs[avId]
            toonSD.destroy()
        del self.toonSDs

        self.cameraMgr.destroy()
        del self.cameraMgr

        self.sectionMgr.destroy()
        del self.sectionMgr

        for panel in self.scorePanels:
            panel.cleanup()
        del self.scorePanels

        self.assetMgr.destroy()
        del self.assetMgr

        # remove our game ClassicFSM from the framework ClassicFSM
        self.removeChildGameFSM(self.gameFSM)
        del self.gameFSM

    def onstage(self):
        self.notify.debug("onstage")
        DistributedMinigame.onstage(self)

        self.scorePanels = []

        # start up the minigame; parent things to render, start playing music...
        self.assetMgr.onstage()

        # Displaying the local avatar
        lt = base.localAvatar
        lt.reparentTo(render)
        ##        lt.setBin('fixed', 10)
        lt.hideName()
        self.__placeToon(self.localAvId)
        lt.setAnimState('Happy', 1.0)
        lt.setSpeed(0, 0)
        base.localAvatar.collisionsOn()
        base.localAvatar.setTransparency(1)
        # Create Head Collision for the local avatar
        self.setupHeadCollision()

        self.cameraMgr.onstage()

        toonSD = self.toonSDs[self.localAvId]
        toonSD.enter()
        toonSD.fsm.request('normal')

        self.twoDDrive = TwoDDrive(self,
                                   self.TOON_SPEED,
                                   maxFrameMove=self.MAX_FRAME_MOVE)
        # at this point we cannot yet show the remote players' toons

    def offstage(self):
        self.notify.debug("offstage")
        # stop the minigame; parent things to hidden, stop the music...
        self.assetMgr.offstage()

        for avId in self.toonSDs.keys():
            self.toonSDs[avId].exit()

        base.localAvatar.setTransparency(0)

        self.ignore('enterheadCollSphere-into-floor1')
        base.localAvatar.controlManager.currentControls.cTrav.removeCollider(
            self.headCollNP)
        self.headCollNP.removeNode()
        del self.headCollNP

        # Show the laff meter
        base.localAvatar.laffMeter.start()

        #@TODO: setIntoBitMask of distAvatarCollNode of all the toons to 0x1
        #@TODO: setBin to default for all toons

        # the base class parents the toons to hidden, so consider
        # calling it last
        DistributedMinigame.offstage(self)

    def setGameReady(self):
        if not self.hasLocalToon: return
        self.notify.debug("setGameReady")
        if DistributedMinigame.setGameReady(self):
            return
        # all of the remote toons have joined the game; it's safe to show them now.

        drawNum = 0
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                drawNum += 1
                toon.reparentTo(render)
                ##                toon.setBin('fixed', drawNum)
                toon.setAnimState('Happy', 1.0)
                toon.hideName()
                # Start a smoothing task
                toon.startSmooth()
                toon.startLookAround()
                # Switching off the Bitmask for distAvatarCollNode
                # so that the toons don't collide against each other
                distCNP = toon.find('**/distAvatarCollNode*')
                distCNP.node().setIntoCollideMask(BitMask32.allOff())

                # create the toonSD for this toon
                toonSD = TwoDGameToonSD.TwoDGameToonSD(avId, self)
                self.toonSDs[avId] = toonSD
                toonSD.enter()
                toonSD.fsm.request('normal')
                # The toon with the higher drawNum is rendered closer to the camera
                self.toonSDs[avId].createHeadFrame(drawNum)

    def setGameStart(self, timestamp):
        if not self.hasLocalToon: return
        self.notify.debug("setGameStart")
        # base class will cause gameFSM to enter initial state
        DistributedMinigame.setGameStart(self, timestamp)
        # all players have finished reading the rules, and are ready to start playing.

        ##        self.twoDDrive = TwoDDrive(self, self.TOON_SPEED, maxFrameMove=self.MAX_FRAME_MOVE)

        self.twoDWalk = TwoDWalk(self.twoDDrive,
                                 broadcast=not self.isSinglePlayer())

        # Initialize the scoreboard
        self.scores = [0] * self.numPlayers
        spacing = .4
        for i in xrange(self.numPlayers):
            avId = self.avIdList[i]
            avName = self.getAvatarName(avId)
            scorePanel = \
                       MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId,
                                                                         avName)
            scorePanel.setScale(.9)
            scorePanel.setPos(.75 - spacing * ((self.numPlayers - 1) - i), 0.0,
                              .85)
            # make the panels slightly transparent
            scorePanel.makeTransparent(.75)
            self.scorePanels.append(scorePanel)

        # Transition to the appropriate state
        self.gameFSM.request("play", [timestamp])

    # these are enter and exit functions for the game's
    # fsm (finite state machine)

    def enterOff(self):
        self.notify.debug("enterOff")

    def exitOff(self):
        pass

    def enterPlay(self, timestamp):
        self.notify.debug("enterPlay")

        # Calculated to make sure all Lerps will start at the same time
        elapsedTime = globalClockDelta.localElapsedTime(timestamp)

        self.sectionMgr.enterPlay(elapsedTime)
        # Enable shootKeyHandler() to handle Ctrl
        handlers = [None, None, None, None, self.shootKeyHandler]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)
        # Start twoDWalk so that left-right walking works
        self.twoDWalk.start()

        # Listen to 'jumpStart' to play jump sound
        self.accept('jumpStart', self.startJump)
        # Listen for enemy collision
        self.accept('enemyHit', self.localToonHitByEnemy)
        # Listen for treasure collision
        self.accept('twoDTreasureGrabbed', self.__treasureGrabbed)
        # Listen for for enemy shot
        self.accept('enemyShot', self.__enemyShot)

        # This is the local toon task (game loop for the local toon)
        taskMgr.remove(self.UpdateLocalToonTask)
        # Making the priority of this task 1 because this controls the camera.
        # We want the camera pos to be calculated after the toon pos has been
        # calculated, which happens in TwoDDrive.__update().
        taskMgr.add(self.__updateLocalToonTask,
                    self.UpdateLocalToonTask,
                    priority=1)

        # Hide the laff meter
        base.localAvatar.laffMeter.stop()

        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.setTime(ToonBlitzGlobals.GameDuration[self.getSafezoneId()])
        self.timer.countdown(
            ToonBlitzGlobals.GameDuration[self.getSafezoneId()],
            self.timerExpired)

    def exitPlay(self):
        # Remove all handles so that we don't track Ctrl
        handlers = [None, None, None, None, None]
        self.twoDDrive.arrowKeys.setPressHandlers(handlers)

        # Loop idle animation so that the toon is standing while showing showing the score.
        # Do this only if player is not in victory state.
        if (self.toonSDs[self.localAvId].fsm.getCurrentState().getName() !=
                'victory'):
            base.localAvatar.b_setAnimState('Happy', 1.0)

        # Stop listening to 'jumpStart' because we don't need to play jump sound
        self.ignore('jumpStart')
        self.ignore('enemyHit')
        self.ignore('twoDTreasureGrabbed')

    def enterPause(self):
        self.notify.debug('enterPause')

    def exitPause(self):
        pass

    def enterShowScores(self):
        self.notify.debug("enterShowScores")

        # lerp up the goal bar, score panels
        lerpTrack = Parallel()
        lerpDur = .5

        # score panels
        # top/bottom Y
        tY = .6
        bY = -.6
        # left/center/right X
        lX = -.7
        cX = 0
        rX = .7
        scorePanelLocs = (
            ((cX, bY), ),
            ((lX, bY), (rX, bY)),
            ((cX, bY), (lX, bY), (rX, bY)),
            ((lX, tY), (rX, tY), (lX, bY), (rX, bY)),
        )
        scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
        for i in xrange(self.numPlayers):
            panel = self.scorePanels[i]
            pos = scorePanelLocs[i]
            lerpTrack.append(
                Parallel(
                    LerpPosInterval(panel,
                                    lerpDur,
                                    Point3(pos[0], 0, pos[1]),
                                    blendType='easeInOut'),
                    LerpScaleInterval(panel,
                                      lerpDur,
                                      Vec3(panel.getScale()) * 1.5,
                                      blendType='easeInOut'),
                ))

        self.showScoreTrack = Parallel(
            lerpTrack,
            self.getElevatorCloseTrack(),
            Sequence(
                Wait(ToonBlitzGlobals.ShowScoresDuration),
                Func(self.gameOver),
            ),
        )

        self.showScoreTrack.start()

    def exitShowScores(self):
        # calling finish() here would cause problems if we're
        # exiting abnormally, because of the gameOver() call
        self.showScoreTrack.pause()
        del self.showScoreTrack

    def enterCleanup(self):
        self.notify.debug("enterCleanup")

        self.timer.stop()
        self.timer.destroy()
        del self.timer

        taskMgr.remove(self.EndGameTaskName)
        # Stop twoDWalk to stop left-right movement
        self.twoDWalk.stop()
        self.twoDWalk.destroy()
        del self.twoDWalk
        self.twoDDrive = None
        del self.twoDDrive

    def exitCleanup(self):
        pass

    def acceptInputs(self):
        # Enable shootKeyHandler() to handle Ctrl
        if hasattr(self, 'twoDDrive'):
            handlers = [None, None, None, None, self.shootKeyHandler]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            # Start twoDDrive so that left-right walking works
            self.twoDDrive.start()

    def ignoreInputs(self):
        # Remove all handles so that we don't track Ctrl
        if hasattr(self, 'twoDDrive'):
            handlers = [None, None, None, None, None]
            self.twoDDrive.arrowKeys.setPressHandlers(handlers)
            # Stop twoDDrive to stop left-right movement
            self.twoDDrive.lastAction = None
            self.twoDDrive.stop()

    def __updateLocalToonTask(self, task):
        dt = globalClock.getDt()
        self.cameraMgr.update()

        # ALWAYS keep the toon at y=0
        if self.gameFSM.getCurrentState().getName() == 'play':
            # Only exception is when the local toon has reached the victory state.
            if not self.toonSDs[self.localAvId].fsm.getCurrentState().getName(
            ) == 'victory':
                if not (base.localAvatar.getY() == 0):
                    base.localAvatar.setY(0)

        # Handle if toon falls into a pit
        if (base.localAvatar.getZ() < -2.):
            self.localToonFellDown()

        for avId in self.toonSDs.keys():
            self.toonSDs[avId].update()

        return task.cont

    def handleDisabledAvatar(self, avId):
        """This will be called if an avatar exits unexpectedly"""
        self.notify.debug("handleDisabledAvatar")
        self.notify.debug("avatar " + str(avId) + " disabled")
        # clean up any references to the disabled avatar before he disappears
        self.toonSDs[avId].exit(unexpectedExit=True)
        del self.toonSDs[avId]
        # then call the base class
        DistributedMinigame.handleDisabledAvatar(self, avId)

    def setupHeadCollision(self):
        collSphere = CollisionSphere(0, 0, 0, 1)
        collSphere.setTangible(1)
        collNode = CollisionNode('headCollSphere')
        collNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        collNode.setIntoCollideMask(BitMask32.allOff())
        collNode.addSolid(collSphere)
        head = base.localAvatar.getPart('head', '1000')
        self.headCollNP = head.attachNewNode(collNode)
        self.headCollNP.setPos(0, 0, 0.0)
        # I'm positioning the headCollNP at different Z values because the different animal
        # species have different heights. The headCollNP prevents the toon from going through
        # a floor. For tall toons, I bring the headCollNP lower so that the toon can complete
        # a jump onto a 2nd platform without banging it's head on the 3rd platform.
        animal = base.localAvatar.style.getAnimal()
        if (animal == 'dog') or (animal == 'bear') or (animal == 'horse'):
            torso = base.localAvatar.style.torso
            legs = base.localAvatar.style.legs
            if ((torso == 'ls') or (torso == 'ld')) and (legs == 'l'):
                self.headCollNP.setZ(-1.3)
            else:
                self.headCollNP.setZ(-0.7)
        elif (animal == 'mouse') or (animal == 'duck'):
            self.headCollNP.setZ(0.5)
        elif (animal == 'cat'):
            self.headCollNP.setZ(-0.3)
        elif (animal == 'rabbit'):
            self.headCollNP.setZ(-0.5)
        elif (animal == 'monkey'):
            self.headCollNP.setZ(0.3)
        elif (animal == 'pig'):
            self.headCollNP.setZ(-0.7)

        self.headCollNP.hide()
        if self.showCollSpheres:
            self.headCollNP.show()

        # Setting up the collision event handler
        headCollisionEvent = CollisionHandlerEvent()
        headCollisionEvent.addInPattern("enter%fn-into-%in")
        headCollisionEvent.addOutPattern("%fn-exit-%in")
        # Adding this as a collider to the main local avatar's traverser
        cTrav = base.localAvatar.controlManager.currentControls.cTrav
        cTrav.addCollider(self.headCollNP, headCollisionEvent)
        self.accept('enterheadCollSphere-into-floor1',
                    self.__handleHeadCollisionIntoFloor)
        self.accept('headCollSphere-exit-floor1',
                    self.__handleHeadCollisionExitFloor)

    def __handleHeadCollisionIntoFloor(self, cevent):
        # Toon's head is hitting a floor.
        # Making the up velocity 0 when you hit a floor. Only while going up.
        self.isHeadInFloor = True
        if (base.localAvatar.controlManager.currentControls.lifter.getVelocity(
        ) > 0):
            base.localAvatar.controlManager.currentControls.lifter.setVelocity(
                0.)
            # Play collision sound
            self.assetMgr.playHeadCollideSound()

    def __handleHeadCollisionExitFloor(self, cevent):
        # Toon's head is exiting the floor.
        # Check this flag before jumping in TwoDDrive.
        self.isHeadInFloor = False

    def __placeToon(self, avId):
        """Places a toon in its starting position."""
        toon = self.getAvatar(avId)
        i = self.avIdList.index(avId)
        pos = Point3(ToonBlitzGlobals.ToonStartingPosition[0] + i,
                     ToonBlitzGlobals.ToonStartingPosition[1],
                     ToonBlitzGlobals.ToonStartingPosition[2])
        toon.setPos(pos)
        toon.setHpr(-90, 0, 0)

    def startJump(self):
        """
        This function does not control the start of the jump.
        GravityWalker controls jump and sends a msg "jumpStart".
        This function is only called because we are listening to the "jumpStart" msg.
        """
        ##        self.notify.debug('startJump')
        # Play start jump sound here
        self.assetMgr.playJumpSound()

    def checkValidity(self, avId):
        if not self.hasLocalToon: return False

        if self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring msg: av %s performing some action.' %
                                avId)
            return False

        # try to see if the avId is valid, return if not
        toon = self.getAvatar(avId)
        if toon == None:
            return False

        return True

    def shootKeyHandler(self):
        """Handle pressing the Ctrl key."""
        self.toonSDs[self.localAvId].shootGun()
        timestamp = globalClockDelta.localToNetworkTime(
            globalClock.getFrameTime())
        self.sendUpdate('showShootGun', [self.localAvId, timestamp])

    def showShootGun(self, avId, timestamp):
        """ called when remote toon shoots gun """
        if self.checkValidity(avId):
            self.notify.debug("avatar %s is shooting water gun" % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].shootGun()

    def localToonFellDown(self):
        """ Called when the local toon falls through a hole."""
        if (self.toonSDs[self.localAvId].fsm.getCurrentState().getName() !=
                'fallDown'):
            self.toonSDs[self.localAvId].fsm.request('fallDown')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            # Update local toon's score
            self.updateScore(
                self.localAvId,
                ToonBlitzGlobals.ScoreLossPerFallDown[self.getSafezoneId()])
            self.sendUpdate('toonFellDown', [self.localAvId, timestamp])

    def toonFellDown(self, avId, timestamp):
        """ Called when a remote toon falls through a hole."""
        if self.checkValidity(avId):
            self.notify.debug("avatar %s fell down." % avId)
            if avId != self.localAvId:
                # Update remote toon's score
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerFallDown[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallDown')

    def localToonHitByEnemy(self):
        """ Called when a suit collides with localToon."""
        # If not already in fallBack or squished state
        currToonState = self.toonSDs[
            self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('fallBack')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            # Update local toon's score
            self.updateScore(
                self.localAvId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[
                    self.getSafezoneId()])
            self.sendUpdate('toonHitByEnemy', [self.localAvId, timestamp])

    def toonHitByEnemy(self, avId, timestamp):
        """ Called when a remote toon is hit by suit."""
        if self.checkValidity(avId):
            self.notify.debug("avatar %s hit by a suit" % avId)
            if avId != self.localAvId:
                # Update remote toon's score
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerEnemyCollision[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('fallBack')

    def localToonSquished(self):
        """ Called when the local toon gets squished by a stomper."""
        # If not already in fallBack or squished state
        currToonState = self.toonSDs[
            self.localAvId].fsm.getCurrentState().getName()
        if not (currToonState == 'fallBack' or currToonState == 'squish'):
            self.toonSDs[self.localAvId].fsm.request('squish')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            # Update local toon's score
            self.updateScore(
                self.localAvId, ToonBlitzGlobals.ScoreLossPerStomperSquish[
                    self.getSafezoneId()])
            # Tell others that the local toon got squished
            self.sendUpdate('toonSquished', [self.localAvId, timestamp])

    def toonSquished(self, avId, timestamp):
        """ Called whan a remote toon is squished by a stomper."""
        if self.checkValidity(avId):
            self.notify.debug("avatar %s is squished." % avId)
            if (avId != self.localAvId):
                # Update remote toon's score
                self.updateScore(
                    avId, ToonBlitzGlobals.ScoreLossPerStomperSquish[
                        self.getSafezoneId()])
                self.toonSDs[avId].fsm.request('squish')

    def localToonVictory(self):
        """ Called when localToon reaches the end of tunnel. """
        if not ToonBlitzGlobals.EndlessGame:
            self.ignoreInputs()
        if not (self.toonSDs[self.localAvId].fsm.getCurrentState().getName()
                == 'victory'):
            self.toonSDs[self.localAvId].fsm.request('victory')
            timestamp = globalClockDelta.localToNetworkTime(
                globalClock.getFrameTime())
            self.sendUpdate('toonVictory', [self.localAvId, timestamp])

    def toonVictory(self, avId, timestamp):
        """ Called when a remote toon reaches the end of tunnel. """
        if self.checkValidity(avId):
            self.notify.debug("avatar %s achieves victory" % avId)
            if avId != self.localAvId:
                self.toonSDs[avId].fsm.request('victory')

    def addVictoryScore(self, avId, score):
        """ Called by the AI to set the victory score on the toon who has completed the game."""
        if not self.hasLocalToon: return
        # Update the toon's score
        self.updateScore(avId, score)
        # Play sound for the local player
        if (avId == self.localAvId):
            self.assetMgr.threeSparkles.play()

    def __treasureGrabbed(self, sectionIndex, treasureIndex):
        """ Handle the local toon grabbing this treasure.
        Another toon may actually get the credit, proceed as if we got it
        """
        self.notify.debug('treasure %s-%s grabbed' %
                          (sectionIndex, treasureIndex))
        # make the treasure react
        section = self.sectionMgr.sections[sectionIndex]
        section.treasureMgr.treasures[treasureIndex].hideTreasure()
        # play a sound
        self.assetMgr.treasureGrabSound.play()
        # tell the AI we're claiming this treasure
        self.sendUpdate("claimTreasure", [sectionIndex, treasureIndex])

    def setTreasureGrabbed(self, avId, sectionIndex, treasureIndex):
        """Update a treasure being grabbed by a toon."""
        if not self.hasLocalToon: return
        # Grab treasure only if we're still playing
        if (self.gameFSM.getCurrentState().getName() == 'play'):
            self.notify.debug("treasure %s-%s grabbed by %s" %
                              (sectionIndex, treasureIndex, avId))
            numSections = len(self.sectionMgr.sections)
            # numSections includes the end section also.
            ##            assert (sectionIndex < numSections)
            if (sectionIndex < numSections):
                section = self.sectionMgr.sections[sectionIndex]

                numTreasures = len(section.treasureMgr.treasures)
                ##                assert (treasureIndex < numTreasures)
                if (treasureIndex < numTreasures):
                    treasure = section.treasureMgr.treasures[treasureIndex]
                    if avId != self.localAvId:
                        # destroy the treasure
                        treasure.hideTreasure()

                    # Update the toon's score
                    self.updateScore(
                        avId,
                        ToonBlitzGlobals.ScoreGainPerTreasure * treasure.value)
                else:
                    self.notify.error(
                        'WHOA!! treasureIndex %s is out of range; numTreasures = %s'
                        % (treasureIndex, numTreasures))
                    base.localAvatar.sendLogMessage(
                        'treasureIndex %s is out of range; numTreasures = %s' %
                        (treasureIndex, numTreasures))
            else:
                self.notify.error(
                    'WHOA!! sectionIndex %s is out of range; numSections = %s'
                    % (sectionIndex, numSections))
                base.localAvatar.sendLogMessage(
                    'sectionIndex %s is out of range; numSections = %s' %
                    (sectionIndex, numSections))

    def __enemyShot(self, sectionIndex, enemyIndex):
        """
        Handle the local toon shooting the enemy of enemyIndex.
        Send a message to the AI.
        """
        ##        self.notify.debug('enemy %s-%s shot' %(sectionIndex, enemyIndex))
        # Play cog hit effect for the local client
        self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[
            enemyIndex].doShotTrack()
        # play a sound

        # tall the AI we're claiming the shot
        self.sendUpdate('claimEnemyShot', [sectionIndex, enemyIndex])

    def setEnemyShot(self, avId, sectionIndex, enemyIndex, enemyHealth):
        """
        This method is called by the AI to all the clients.
        enemyIndex has been shot by avId.
        Update effects on the enemyIndex
        If avId is local toon update score.
        """
        if not self.hasLocalToon: return

        # Enemy is hit only if we're still playing
        if (self.gameFSM.getCurrentState().getName() == 'play'):
            self.notify.debug('enemy %s is shot by %s. Health left %s' %
                              (enemyIndex, avId, enemyHealth))
            if (enemyHealth > 0):
                # Enemy is still alive.
                # Don't play the shotTrack for the local client, because we already played it.
                if not (avId == self.localAvId):
                    self.sectionMgr.sections[sectionIndex].enemyMgr.enemies[
                        enemyIndex].doShotTrack()
            else:
                enemy = self.sectionMgr.sections[
                    sectionIndex].enemyMgr.enemies[enemyIndex]
                # Show the spawned treasure
                treasureSpawnPoint = Point3(
                    enemy.suit.getX(), enemy.suit.getY(),
                    enemy.suit.getZ() + enemy.suit.height / 2.)
                self.spawnTreasure(sectionIndex, enemyIndex,
                                   treasureSpawnPoint)
                # Enemy just died. Play Death animation.
                enemy.doDeathTrack()

    def updateScore(self, avId, deltaScore):
        i = self.avIdList.index(avId)
        self.scores[i] += deltaScore
        self.scorePanels[i].setScore(self.scores[i])
        self.toonSDs[avId].showScoreText(deltaScore)

    def spawnTreasure(self, sectionIndex, enemyIndex, pos):
        # Spawn a treasure if we're still playing
        if (self.gameFSM.getCurrentState().getName() == 'play'):
            # Place the correct treasure in the right position and show it
            section = self.sectionMgr.sections[sectionIndex]
            treasure = section.treasureMgr.enemyTreasures[enemyIndex]
            treasure.setTreasurePos(pos)
            treasure.popupEnemyTreasure()

    def timerExpired(self):
        self.notify.debug('timer expired')
        if not self.reportedDone:
            if not ToonBlitzGlobals.EndlessGame:
                self.ignoreInputs()
            self.reportedDone = True
            self.sendUpdate('reportDone')

    def setEveryoneDone(self):
        if not self.hasLocalToon: return
        if self.gameFSM.getCurrentState().getName() != 'play':
            self.notify.warning('ignoring setEveryoneDone msg')
            return

        self.notify.debug('setEveryoneDone')

        def endGame(task, self=self):
            if not ToonBlitzGlobals.EndlessGame:
                self.gameFSM.request('showScores')
            return Task.done

        # hide the timer
        self.timer.hide()

        taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)

    def getElevatorCloseTrack(self):
        leftDoor = self.sectionMgr.exitElevator.find('**/doorL')
        rightDoor = self.sectionMgr.exitElevator.find('**/doorR')
        leftDoorClose = LerpPosInterval(leftDoor, 2, Point3(3.02, 0, 0))
        rightDoorClose = LerpPosInterval(rightDoor, 2, Point3(-3.02, 0, 0))
        return Sequence(Wait(self.timeToRunToElevator),
                        Parallel(leftDoorClose, rightDoorClose))

    def debugStartPause(self):
        """ This function is called when the minigame is paused in the debug mode."""
        self.sectionMgr.enterPause()

    def debugEndPause(self):
        """ This function is called when the minigame is unpaused in the debug mode."""
        self.sectionMgr.exitPause()