Poodletooth-iLand/toontown/minigame/DistributedDivingGame.py

from direct.showbase.ShowBaseGlobal import *
from toontown.toonbase.ToonBaseGlobal import *
from direct.interval.IntervalGlobal import *
from toontown.toonbase import ToontownTimer
from DistributedMinigame import *
from direct.distributed.ClockDelta import *
from direct.fsm import ClassicFSM
from direct.fsm import State
from direct.task import Task
from direct.actor import Actor
from toontown.toon import LaffMeter
from direct.distributed import DistributedSmoothNode
import ArrowKeys
import Ring
import RingTrack
import DivingGameGlobals
import RingGroup
import RingTrackGroups
import random
import DivingGameToonSD
import DivingFishSpawn
import DivingTreasure
import math
import TreasureScorePanel
from otp.distributed.TelemetryLimiter import TelemetryLimiter, TLGatherAllAvs
from toontown.toonbase import ToontownGlobals
from toontown.toonbase import TTLocalizer

class DivingGameRotationLimiter(TelemetryLimiter):

    def __init__(self, h, p):
        self._h = h
        self._p = p

    def __call__(self, obj):
        obj.setHpr(self._h, self._p, obj.getR())


class DistributedDivingGame(DistributedMinigame):
    COLLISION_WATCH_TASK = 'DivingGameCollisionWatchTask'
    TREASURE_BOUNDS_TASK = 'DivingGameTreasureBoundsTask'
    CRAB_TASK = 'DivingGameCrabTask'
    UPDATE_LOCALTOON_TASK = 'DivingGameUpdateLocalToonTask'
    COLLISION_DETECTION_PRIORITY = 5
    MAP_DIV = 2.8
    MAP_OFF = 14.0
    LAG_COMP = 1.25

    def __init__(self, cr):
        DistributedMinigame.__init__(self, cr)
        self.gameFSM = ClassicFSM.ClassicFSM('DistributedDivingGame', [State.State('off', self.enterOff, self.exitOff, ['swim']), State.State('swim', self.enterSwim, self.exitSwim, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
        self.addChildGameFSM(self.gameFSM)
        self.iCount = 0
        self.reachedFlag = 0
        self.grabbingTreasure = -1
        self.dead = 0

    def getTitle(self):
        return TTLocalizer.DivingGameTitle

    def getInstructions(self):
        p = self.avIdList.index(self.localAvId)
        if self.isSinglePlayer():
            text = TTLocalizer.DivingInstructionsSinglePlayer
        else:
            text = TTLocalizer.DivingInstructionsMultiPlayer
        return text

    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        loadBase = 'phase_4/models/minigames/'
        loadBaseShip = 'phase_5/models/props/'
        self.sndAmbience = base.loadSfx('phase_4/audio/sfx/AV_ambient_water.ogg')
        self.environModel = loader.loadModel(loadBase + 'diving_game.bam')
        self.boatModel = self.environModel.find('**/boat')
        self.skyModel = self.environModel.find('**/sky')
        self.waterModel = self.environModel.find('**/seawater')
        self.frontMap = self.environModel.find('**/sea_front')
        self.frontMap.setY(3)
        self.frontMap.setBin('fixed', 0)
        self.frontMap.setDepthTest(0)
        self.waterModel.setY(1.0)
        bubbleModel = self.environModel.find('**/bubbles1')
        bubbleModel.setY(1.0)
        bubbleModel = self.environModel.find('**/bubbles2')
        bubbleModel.setY(1.0)
        bubbleModel = self.environModel.find('**/bubbles3')
        bubbleModel.setY(1.0)
        bubbleModel = self.environModel.find('**/bubbles4')
        bubbleModel.setY(1.0)
        bubbleModel = self.environModel.find('**/bubbles5')
        bubbleModel.setY(1.0)
        self.mapModel = loader.loadModel(loadBase + 'diving_game.bam')
        boatMap = self.mapModel.find('**/boat')
        skyMap = self.mapModel.find('**/sky')
        frontMap = self.mapModel.find('**/sea_front')
        skyMap.hide()
        frontMap.hide()
        boatMap.setZ(28.5)
        self.crabs = []
        self.spawners = []
        self.toonSDs = {}
        avId = self.localAvId
        toonSD = DivingGameToonSD.DivingGameToonSD(avId, self)
        self.toonSDs[avId] = toonSD
        toonSD.load()
        crabSoundName = 'King_Crab.ogg'
        crabSoundPath = 'phase_4/audio/sfx/%s' % crabSoundName
        self.crabSound = loader.loadSfx(crabSoundPath)
        treasureSoundName = 'SZ_DD_treasure.ogg'
        treasureSoundPath = 'phase_4/audio/sfx/%s' % treasureSoundName
        self.treasureSound = loader.loadSfx(treasureSoundPath)
        hitSoundName = 'diving_game_hit.ogg'
        hitSoundPath = 'phase_4/audio/sfx/%s' % hitSoundName
        self.hitSound = loader.loadSfx(hitSoundPath)
        self.music = base.loadMusic('phase_4/audio/bgm/MG_Target.ogg')
        self.addSound('dropGold', 'diving_treasure_drop_off.ogg', 'phase_4/audio/sfx/')
        self.addSound('getGold', 'diving_treasure_pick_up.ogg', 'phase_4/audio/sfx/')
        self.swimSound = loader.loadSfx('phase_4/audio/sfx/diving_swim_loop.ogg')
        self.swimSound.setVolume(0.0)
        self.swimSound.setPlayRate(1.0)
        self.swimSound.setLoop(True)
        self.swimSound.play()

    def addSound(self, name, soundName, path = None):
        if not hasattr(self, 'soundTable'):
            self.soundTable = {}
        if path:
            self.soundPath = path
        soundSource = '%s%s' % (self.soundPath, soundName)
        self.soundTable[name] = loader.loadSfx(soundSource)

    def playSound(self, name, volume = 1.0):
        self.soundTable[name].setVolume(1.0)
        self.soundTable[name].play()

    def unload(self):
        self.notify.debug('unload')
        DistributedMinigame.unload(self)
        self.mapModel.removeNode()
        del self.mapModel
        if hasattr(self, 'soundTable'):
            del self.soundTable
        del self.sndAmbience
        del self.hitSound
        del self.crabSound
        del self.treasureSound
        self.swimSound.stop()
        del self.swimSound
        self.environModel.removeNode()
        del self.environModel
        self.removeChildGameFSM(self.gameFSM)
        for avId in self.toonSDs.keys():
            toonSD = self.toonSDs[avId]
            toonSD.unload()

        del self.toonSDs
        del self.gameFSM
        del self.music

    def fishCollision(self, collEntry):
        avId = int(collEntry.getFromNodePath().getName())
        toonSD = self.toonSDs[avId]
        name = collEntry.getIntoNodePath().getName()
        if len(name) >= 7:
            if name[0:6] == 'crabby':
                self.sendUpdate('handleCrabCollision', [avId, toonSD.status])
        else:
            spawnerId = int(name[2])
            spawnId = int(name[3:len(name)])
            if spawnId in self.spawners[spawnerId].fishArray:
                self.sendUpdate('handleFishCollision', [avId,
                 spawnId,
                 spawnerId,
                 toonSD.status])

    def fishSpawn(self, timestamp, fishcode, spawnerId, offset):
        if self.dead is 1:
            return
        ts = globalClockDelta.localElapsedTime(timestamp)
        if not hasattr(self, 'spawners'):
            return
        if abs(self.spawners[spawnerId].lastSpawn - timestamp) < 150:
            return
        fish = self.spawners[spawnerId].createFish(fishcode)
        fish.offset = offset
        fish.setPos(self.spawners[spawnerId].position)
        func = Func(self.fishRemove, fish.code)
        self.spawners[spawnerId].lastSpawn = timestamp
        iName = '%s %s' % (fish.name, self.iCount)
        self.iCount += 1
        if fish.name == 'clown':
            fish.moveLerp = Sequence(LerpPosInterval(fish, duration=8 * self.SPEEDMULT * self.LAG_COMP, startPos=self.spawners[spawnerId].position, pos=self.spawners[spawnerId].position + Point3(50 * self.spawners[spawnerId].direction, 0, (offset - 4) / 2.0), name=iName), func)
            fish.specialLerp = Sequence()
        elif fish.name == 'piano':
            fish.moveLerp = Sequence(LerpPosInterval(fish, duration=5 * self.SPEEDMULT * self.LAG_COMP, startPos=self.spawners[spawnerId].position, pos=self.spawners[spawnerId].position + Point3(50 * self.spawners[spawnerId].direction, 0, (offset - 4) / 2.0), name=iName), func)
            fish.specialLerp = Sequence()
        elif fish.name == 'pbj':
            fish.moveLerp = Sequence(LerpFunc(fish.setX, duration=12 * self.SPEEDMULT * self.LAG_COMP, fromData=self.spawners[spawnerId].position.getX(), toData=self.spawners[spawnerId].position.getX() + 50 * self.spawners[spawnerId].direction, name=iName), func)
            fish.specialLerp = LerpFunc(self.pbjMove, duration=5 * self.SPEEDMULT * self.LAG_COMP, fromData=0, toData=2.0 * 3.14159, extraArgs=[fish, self.spawners[spawnerId].position.getZ()], blendType='easeInOut')
        elif fish.name == 'balloon':
            fish.moveLerp = Sequence(LerpPosInterval(fish, duration=10 * self.SPEEDMULT * self.LAG_COMP, startPos=self.spawners[spawnerId].position, pos=self.spawners[spawnerId].position + Point3(50 * self.spawners[spawnerId].direction, 0, (offset - 4) / 2.0), name=iName), func)
            fish.specialLerp = Sequence(Wait(offset / 10.0 * 2 + 1.5), Parallel(LerpScaleInterval(fish, duration=0.3, startScale=Vec3(2, 2, 2), scale=Vec3(5, 3, 5), blendType='easeInOut')), Wait(1.0), Parallel(LerpScaleInterval(fish, duration=0.4, startScale=Vec3(5, 3, 5), scale=Vec3(2, 2, 2), blendType='easeInOut')))
        elif fish.name == 'bear' or fish.name == 'nurse':
            fish.moveLerp = Sequence(LerpPosInterval(fish, duration=20 * self.LAG_COMP, startPos=self.spawners[spawnerId].position, pos=self.spawners[spawnerId].position + Point3(50 * self.spawners[spawnerId].direction, 0, 0), name=iName), func)
            fish.specialLerp = Sequence()
        fish.moveLerp.start(ts)
        fish.specialLerp.loop(ts)

    def pbjMove(self, x, fish, Z):
        z = math.sin(x + fish.offset * 3) * 3
        fish.setZ(z + Z)

    def getIntroMovie(self):
        seq = Sequence()
        seq.append(Wait(2.0))
        seq.append(LerpFunc(camera.setZ, duration=5, fromData=36, toData=-23, blendType='easeInOut', name='intro'))
        seq.append(Wait(2.0))
        seq.append(LerpFunc(camera.setZ, duration=5, fromData=-23, toData=36 + 3, blendType='easeInOut', name='intro'))
        return seq

    def onstage(self):
        self.notify.debug('onstage')
        DistributedMinigame.onstage(self)
        base.localAvatar.collisionsOff()
        DistributedSmoothNode.activateSmoothing(1, 1)
        numToons = self.numPlayers
        self.NUMTREASURES = numToons
        camera.reparentTo(render)
        camera.setZ(36)
        camera.setHpr(0,0,0)
        camera.setX(0)
        base.camLens.setMinFov(31/(4./3.))
        camera.setY(-54)
        base.camLens.setFar(1500)
        self.introMovie = self.getIntroMovie()
        self.introMovie.start()
        self.accept('FishHit', self.fishCollision)
        toonSD = self.toonSDs[self.localAvId]
        toonSD.enter()
        toonSD.fsm.request('normal')
        toon = base.localAvatar
        toon.reparentTo(render)
        toon.setPos(-9, -1, 36)
        self.__placeToon(self.localAvId)
        self.arrowKeys = ArrowKeys.ArrowKeys()
        self.xVel = 0
        self.zVel = 0
        self.orientNode = toon.attachNewNode('orientNode')
        self.orientNode.setPos(0, 0, 1)
        self.orientNode2 = toon.attachNewNode('orientNode')
        self.orientNode2.setPos(0, 0, -1)
        self.environNode = render.attachNewNode('environNode')
        self.environModel.reparentTo(self.environNode)
        self.environModel.setScale(2.8, 2.8, 2.73)
        self.environModel.setPos(0, 0.5, -41)
        self.skyModel.setScale(1.3, 1.0, 1.0)
        boatoff = 6.75
        self.boatModel.reparentTo(self.environNode)
        self.boatModel.setPos(0, 3.0, 40 - boatoff)
        self.boatModel.setScale(2.8)
        cSphere = CollisionSphere(0.0, 0.0, 0.0 + 2.0, 3.0)
        cSphere.setTangible(0)
        name = 'boat'
        cSphereNode = CollisionNode(name)
        cSphereNode.setIntoCollideMask(DivingGameGlobals.CollideMask)
        cSphereNode.addSolid(cSphere)
        self.boatNode = cSphereNode
        self.boatCNP = self.boatModel.attachNewNode(cSphereNode)
        self.accept('reach-boat', self.__boatReached)
        self.boatTilt = Sequence(LerpFunc(self.boatModel.setR, duration=5, fromData=5, toData=-5, blendType='easeInOut', name='tilt'), LerpFunc(self.boatModel.setR, duration=5, fromData=-5, toData=5, blendType='easeInOut', name='tilt'))
        self.boatTilt.loop()
        self.mapScaleRatio = 40
        self.mapModel.reparentTo(base.a2dTopRight)
        self.mapModel.setScale(1.0 / self.mapScaleRatio)
        self.mapModel.setTransparency(1)
        self.mapModel.setPos(-0.22, 0.0, -1.30)
        self.mapModel.setColorScale(1, 1, 1, 0.7)
        self.mapModel.hide()
        if self.sndAmbience:
            self.sndAmbience.setLoop(True)
            self.sndAmbience.play()
            self.sndAmbience.setVolume(0.01)
        return

    def offstage(self):
        self.notify.debug('offstage')
        DistributedMinigame.offstage(self)
        self.introMovie.finish()
        self.boatTilt.finish()
        self.mapModel.hide()
        DistributedSmoothNode.activateSmoothing(1, 0)
        for avId in self.toonSDs.keys():
            self.toonSDs[avId].exit()

        base.camLens.setFar(ToontownGlobals.DefaultCameraFar)
        base.camLens.setMinFov(ToontownGlobals.DefaultCameraFov/(4./3.))
        base.setBackgroundColor(ToontownGlobals.DefaultBackgroundColor)
        self.arrowKeys.destroy()
        del self.arrowKeys
        self.environNode.removeNode()
        del self.environNode
        if None != self.sndAmbience:
            self.sndAmbience.stop()
        for avId in self.avIdList:
            av = self.getAvatar(avId)
            if av:
                av.dropShadow.show()
                av.resetLOD()
                av.setAnimState('neutral', 1.0)

        self.dead = 1
        self.__killCrabTask()
        for spawner in self.spawners:
            spawner.destroy()
            del spawner

        del self.spawners
        for crab in self.crabs:
            crab.moveLerp.finish()
            crab.moveLerp = None
            crab.removeNode()
            del crab

        if hasattr(self, 'treasures') and self.treasures:
            for i in xrange(self.NUMTREASURES):
                self.treasures[i].destroy()

            del self.treasures
        if hasattr(self, 'cSphereNodePath1'):
            self.cSphereNodePath1.removeNode()
            del self.cSphereNodePath1
        if hasattr(self, 'cSphereNodePath1'):
            self.cSphereNodePath2.removeNode()
            del self.cSphereNodePath2
        if hasattr(self, 'remoteToonCollNPs'):
            for np in self.remoteToonCollNPs.values():
                np.removeNode()

            del self.remoteToonCollNPs
        self.pusher = None
        self.cTrav = None
        self.cTrav2 = None
        base.localAvatar.collisionsOn()
        return

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

    def __placeToon(self, avId):
        toon = self.getAvatar(avId)
        i = self.avIdList.index(avId)
        numToons = float(self.numPlayers)
        x = -10 + i * 5
        toon.setPos(x, -1, 36)
        toon.setHpr(180, 180, 0)

    def getTelemetryLimiter(self):
        return TLGatherAllAvs('DivingGame', Functor(DivingGameRotationLimiter, 180, 180))

    def setGameReady(self):
        self.notify.debug('setGameReady')
        if not self.hasLocalToon:
            return
        if DistributedMinigame.setGameReady(self):
            return
        self.dead = 0
        self.difficultyPatterns = {ToontownGlobals.ToontownCentral: [1,
                                           1.5,
                                           65,
                                           3],
         ToontownGlobals.DonaldsDock: [1,
                                       1.3,
                                       65,
                                       1],
         ToontownGlobals.DaisyGardens: [2,
                                        1.2,
                                        65,
                                        1],
         ToontownGlobals.MinniesMelodyland: [2,
                                             1.0,
                                             65,
                                             1],
         ToontownGlobals.TheBrrrgh: [3,
                                     1.0,
                                     65,
                                     1],
         ToontownGlobals.DonaldsDreamland: [3,
                                            1.0,
                                            65,
                                            1]}
        pattern = self.difficultyPatterns[self.getSafezoneId()]
        self.NUMCRABS = pattern[0]
        self.SPEEDMULT = pattern[1]
        self.TIME = pattern[2]
        loadBase = 'phase_4/models/char/'
        for i in xrange(self.NUMCRABS):
            self.crabs.append(Actor.Actor(loadBase + 'kingCrab-zero.bam', {'anim': loadBase + 'kingCrab-swimLOOP.bam'}))

        for i in xrange(len(self.crabs)):
            crab = self.crabs[i]
            crab.reparentTo(render)
            crab.name = 'king'
            crab.crabId = i
            cSphere = CollisionSphere(0.0, 0.0, 1, 1.3)
            cSphereNode = CollisionNode('crabby' + str(i))
            cSphereNode.addSolid(cSphere)
            cSphereNode.setFromCollideMask(BitMask32.allOff())
            cSphereNode.setIntoCollideMask(DivingGameGlobals.CollideMask)
            cSphereNodePath = crab.attachNewNode(cSphereNode)
            cSphereNodePath.setScale(1, 3, 1)
            self.accept('hitby-' + 'crabby' + str(i), self.fishCollision)
            if i % 2 is 0:
                crab.setPos(20, 0, -40)
                crab.direction = -1
            else:
                crab.setPos(-20, 0, -40)
                crab.direction = 1
            crab.loop('anim')
            crab.setScale(1, 0.3, 1)
            crab.moveLerp = Sequence()

        self.collHandEvent = CollisionHandlerEvent()
        self.cTrav = CollisionTraverser('DistributedDiverGame')
        self.cTrav2 = CollisionTraverser('DistributedDiverGame')
        self.collHandEvent.addInPattern('reach-%in')
        self.collHandEvent.addAgainPattern('reach-%in')
        self.collHandEvent.addInPattern('into-%in')
        self.collHandEvent.addInPattern('hitby-%in')
        loadBase = 'phase_4/models/minigames/'
        self.treasures = []
        self.chestIcons = {}
        for i in xrange(self.NUMTREASURES):
            self.chestIcons[i] = loader.loadModel(loadBase + 'treasure_chest.bam')
            self.chestIcons[i].reparentTo(self.mapModel)
            self.chestIcons[i].setScale(1.5)
            treasure = DivingTreasure.DivingTreasure(i)
            self.accept('grab-' + str(i), self.__treasureGrabbed)
            self.collHandEvent.addInPattern('grab-%in')
            self.collHandEvent.addAgainPattern('grab-%in')
            self.treasures.append(treasure)

        self.cTrav.traverse(render)
        spawnX = 24 * self.LAG_COMP
        spawnY = 0.6
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(0, 1, Point3(-spawnX, spawnY, 25), self.collHandEvent))
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(1, -1, Point3(spawnX, spawnY, 16), self.collHandEvent))
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(2, 1, Point3(-spawnX, spawnY, 6), self.collHandEvent))
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(3, -1, Point3(spawnX, spawnY, -4), self.collHandEvent))
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(4, 1, Point3(-spawnX, spawnY, -15), self.collHandEvent))
        self.spawners.append(DivingFishSpawn.DivingFishSpawn(5, -1, Point3(spawnX, spawnY, -23), self.collHandEvent))
        for spawner in self.spawners:
            spawner.lastSpawn = 0

        cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.4)
        cSphereNode = CollisionNode('%s' % self.localAvId)
        cSphereNode.addSolid(cSphere)
        cSphereNode.setFromCollideMask(DivingGameGlobals.CollideMask)
        cSphereNode.setIntoCollideMask(BitMask32.allOff())
        headparts = base.localAvatar.getHeadParts()
        pos = headparts[2].getPos()
        self.cSphereNodePath1 = base.localAvatar.attachNewNode(cSphereNode)
        self.cSphereNodePath1.setPos(pos + Point3(0, 1.5, 1))
        self.cTrav.addCollider(self.cSphereNodePath1, self.collHandEvent)
        cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.4)
        cSphereNode = CollisionNode('%s' % self.localAvId)
        cSphereNode.addSolid(cSphere)
        cSphereNode.setFromCollideMask(DivingGameGlobals.CollideMask)
        cSphereNode.setFromCollideMask(BitMask32.allOff())
        cSphereNode.setIntoCollideMask(BitMask32.allOff())
        headparts = base.localAvatar.getHeadParts()
        pos = headparts[2].getPos()
        self.cSphereNodePath2 = base.localAvatar.attachNewNode(cSphereNode)
        self.cSphereNodePath2.setPos(pos + Point3(0, 1.5, -1))
        self.cTrav.addCollider(self.cSphereNodePath2, self.collHandEvent)
        self.pusher = CollisionHandlerPusher()
        self.pusher.addCollider(self.cSphereNodePath1, base.localAvatar)
        self.pusher.addCollider(self.cSphereNodePath2, base.localAvatar)
        self.pusher.setHorizontal(0)
        self.cTrav2.addCollider(self.cSphereNodePath1, self.pusher)
        self.cTrav2.addCollider(self.cSphereNodePath2, self.pusher)
        self.remoteToonCollNPs = {}
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                headparts = toon.getHeadParts()
                pos = headparts[2].getPos()
                cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.4)
                cSphereNode = CollisionNode('%s' % avId)
                cSphereNode.addSolid(cSphere)
                cSphereNode.setCollideMask(DivingGameGlobals.CollideMask)
                cSphereNP = toon.attachNewNode(cSphereNode)
                cSphereNP.setPos(pos + Point3(0, 1.5, 1))
                self.remoteToonCollNPs[int(str(avId) + str(1))] = cSphereNP
                cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.4)
                cSphereNode = CollisionNode('%s' % avId)
                cSphereNode.addSolid(cSphere)
                cSphereNode.setCollideMask(DivingGameGlobals.CollideMask)
                cSphereNP = toon.attachNewNode(cSphereNode)
                cSphereNP.setPos(pos + Point3(0, 1.5, -1))
                self.remoteToonCollNPs[int(str(avId) + str(1))] = cSphereNP
                toonSD = DivingGameToonSD.DivingGameToonSD(avId, self)
                self.toonSDs[avId] = toonSD
                toonSD.load()
                toonSD.enter()
                toonSD.fsm.request('normal')

        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                toon.reparentTo(render)
                self.__placeToon(avId)
                toon.startSmooth()

        self.remoteToons = {}
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            self.remoteToons[avId] = toon

    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        DistributedMinigame.setGameStart(self, timestamp)
        self.notify.debug('setGameStart')
        self.treasurePanel = TreasureScorePanel.TreasureScorePanel()
        self.treasurePanel.setPos(0.145, 0, -0.27)
        self.treasurePanel.reparentTo(base.a2dTopLeft)
        self.treasurePanel.makeTransparent(0.7)
        self.introMovie.finish()
        self.gameFSM.request('swim')

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

    def exitOff(self):
        pass

    def enterSwim(self):
        self.notify.debug('enterSwim')
        base.playMusic(self.music, looping=1, volume=0.9)
        self.localLerp = Sequence()
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.setTime(self.TIME)
        self.timer.countdown(self.TIME, self.timerExpired)
        self.mapModel.show()
        self.mapAvatars = {}
        avatarScale = 0.025 * self.mapScaleRatio
        for avId in self.remoteAvIdList:
            avatar = base.cr.doId2do.get(avId, False)
            if avatar != False:
                self.mapAvatars[avId] = LaffMeter.LaffMeter(avatar.style, avatar.hp, avatar.maxHp)
                self.mapAvatars[avId].reparentTo(self.mapModel)
                self.mapAvatars[avId].setScale(avatarScale)
                self.mapAvatars[avId].start()

        avatar = base.cr.doId2do[self.localAvId]
        self.mapAvatars[self.localAvId] = LaffMeter.LaffMeter(avatar.style, avatar.hp, avatar.maxHp)
        self.mapAvatars[self.localAvId].reparentTo(self.mapModel)
        self.mapAvatars[self.localAvId].setScale(avatarScale)
        self.mapAvatars[self.localAvId].start()
        self.accept('resetClock', self.__resetClock)
        self.__spawnUpdateLocalToonTask()
        self.__spawnCrabTask()
        self.__spawnTreasureBoundsTask()

    def __resetClock(self, tOffset):
        self.notify.debug('resetClock')
        self.gameStartTime += tOffset
        self.timer.countdown(self.timer.currentTime + tOffset, self.timerExpired)

    def timerExpired(self):
        self.notify.debug('local timer expired')
        self.dead = 1
        self.gameOver()

    def __initPosBroadcast(self):
        self.__posBroadcastPeriod = 0.2
        self.__timeSinceLastPosBroadcast = 0.0
        self.__lastPosBroadcast = self.getAvatar(self.localAvId).getPos()
        self.__storeStop = 0
        lt = self.getAvatar(self.localAvId)
        lt.d_clearSmoothing()
        lt.sendCurrentPosition()

    def __posBroadcast(self, dt):
        self.__timeSinceLastPosBroadcast += dt
        if self.__timeSinceLastPosBroadcast > self.__posBroadcastPeriod:
            self.__timeSinceLastPosBroadcast -= self.__posBroadcastPeriod
            self.getAvatar(self.localAvId).cnode.broadcastPosHprFull()

    def __spawnTreasureBoundsTask(self):
        taskMgr.remove(self.TREASURE_BOUNDS_TASK)
        taskMgr.add(self.__treasureBoundsTask, self.TREASURE_BOUNDS_TASK)

    def __killTreasureBoundsTask(self):
        taskMgr.remove(self.TREASURE_BOUNDS_TASK)

    def __treasureBoundsTask(self, task):
        for i in xrange(self.NUMTREASURES):
            self.chestIcons[i].setPos(self.treasures[i].chest.getPos(render) / self.MAP_DIV)
            self.chestIcons[i].setZ(self.chestIcons[i].getZ() + self.MAP_OFF)
            if self.treasures[i].treasureNode.getZ() < -36:
                self.treasures[i].treasureNode.setZ(-36)
            if self.treasures[i].treasureNode.getX() < -20:
                self.treasures[i].treasureNode.setX(-20)
            if self.treasures[i].treasureNode.getX() > 20:
                self.treasures[i].treasureNode.setX(20)

        return Task.cont

    def incrementScore(self, avId, newSpot, timestamp):
        if not self.hasLocalToon:
            return
        newSpot += -15
        ts = globalClockDelta.localElapsedTime(timestamp)
        toonSD = self.toonSDs[avId]
        if avId == self.localAvId:
            self.reachedFlag = 0
        if toonSD.status == 'treasure' and self.treasures and self.chestIcons:
            for i in xrange(self.NUMTREASURES):
                if self.treasures[i].grabbedId == avId:
                    self.treasures[i].treasureNode.wrtReparentTo(render)
                    self.treasures[i].grabbedId = 0
                    seq = Sequence()
                    shrink = LerpScaleInterval(self.treasures[i].treasureNode, duration=1.0, startScale=self.treasures[i].treasureNode.getScale(), scale=Vec3(0.001, 0.001, 0.001), blendType='easeIn')
                    shrinkIcon = LerpScaleInterval(self.chestIcons[i], duration=1.0, startScale=self.chestIcons[i].getScale(), scale=Vec3(0.001, 0.001, 0.001), blendType='easeIn')
                    jump = ProjectileInterval(self.treasures[i].treasureNode, duration=1.0, startPos=self.treasures[i].treasureNode.getPos(), endPos=Point3(0, 0, 40), gravityMult=0.7)
                    shrinkJump = Parallel(shrink, shrinkIcon, jump)
                    toonSD.fsm.request('normal')
                    grow = LerpScaleInterval(self.treasures[i].treasureNode, duration=1.0, scale=self.treasures[i].treasureNode.getScale(), startScale=Vec3(0.001, 0.001, 0.001), blendType='easeIn')
                    growIcon = LerpScaleInterval(self.chestIcons[i], duration=1.0, scale=self.chestIcons[i].getScale(), startScale=Vec3(0.001, 0.001, 0.001), blendType='easeIn')
                    place = Parallel(Func(self.treasures[i].treasureNode.setPos, Vec3(newSpot, 0.25, -36)), Func(self.treasures[i].treasureNode.setHpr, Vec3(0, 0, 0)))
                    growItems = Parallel(grow, growIcon)
                    resetChest = Func(self.treasures[i].chestNode.setIntoCollideMask, DivingGameGlobals.CollideMask)
                    seq = Sequence(shrinkJump, Wait(1.5), place, growItems, resetChest)
                    self.treasures[i].moveLerp.pause()
                    self.treasures[i].moveLerp = seq
                    self.treasures[i].moveLerp.start(ts)
                    self.playSound('dropGold')
                    self.treasurePanel.incrScore()

    def __boatReached(self, collEntry):
        toonSD = self.toonSDs[self.localAvId]
        if toonSD.status == 'treasure' and not self.reachedFlag:
            self.sendUpdate('treasureRecovered')
            self.reachedFlag = 1

    def __treasureGrabbed(self, collEntry):
        avId = int(collEntry.getFromNodePath().getName())
        chestId = int(collEntry.getIntoNodePath().getName())
        toonSD = self.toonSDs[avId]
        if toonSD.status == 'normal' and self.grabbingTreasure == -1:
            self.grabbingTreasure = chestId
            self.sendUpdate('pickupTreasure', [chestId])

    def setTreasureDropped(self, avId, timestamp):
        if not hasattr(self, 'treasures'):
            return
        ts = globalClockDelta.localElapsedTime(timestamp)
        for i in xrange(self.NUMTREASURES):
            if self.treasures[i].grabbedId == avId:
                self.treasures[i].grabbedId = 0
                toonSD = self.toonSDs[avId]
                dist = abs(36.0 + self.treasures[i].treasureNode.getZ(render))
                delta = dist / 72.0
                dur = 10 * delta
                self.treasures[i].treasureNode.wrtReparentTo(render)
                self.treasures[i].chestNode.setIntoCollideMask(BitMask32.allOff())
                resetChest = Func(self.treasures[i].chestNode.setIntoCollideMask, DivingGameGlobals.CollideMask)
                self.treasures[i].moveLerp.pause()
                self.treasures[i].moveLerp = Parallel(Sequence(Wait(1.0), resetChest), LerpFunc(self.treasures[i].treasureNode.setZ, duration=dur, fromData=self.treasures[i].treasureNode.getZ(render), toData=-36, blendType='easeIn'))
                self.treasures[i].moveLerp.start(ts)

    def performCrabCollision(self, avId, timestamp):
        if not self.hasLocalToon:
            return
        ts = globalClockDelta.localElapsedTime(timestamp)
        toonSD = self.toonSDs[avId]
        toon = self.getAvatar(avId)
        distance = base.localAvatar.getDistance(toon)
        volume = 0
        soundRange = 15.0
        if distance < soundRange:
            volume = (soundRange - distance) / soundRange
        if toonSD.status == 'normal' or toonSD.status == 'treasure':
            self.localLerp.finish()
            self.localLerp = Sequence(Func(toonSD.fsm.request, 'freeze'), Wait(3.0), Func(toonSD.fsm.request, 'normal'))
            self.localLerp.start(ts)
            self.hitSound.play()
            self.hitSound.setVolume(volume)

    def performFishCollision(self, avId, spawnId, spawnerId, timestamp):
        if not hasattr(self, 'spawners'):
            return
        toonSD = self.toonSDs[avId]
        ts = globalClockDelta.localElapsedTime(timestamp)
        toon = self.getAvatar(avId)
        distance = base.localAvatar.getDistance(toon)
        volume = 0
        soundRange = 15.0
        if distance < soundRange:
            volume = (soundRange - distance) / soundRange
        if toonSD.status == 'normal' or toonSD.status == 'treasure':
            self.localLerp.finish()
            self.localLerp = Sequence(Func(toonSD.fsm.request, 'freeze'), Wait(3.0), Func(toonSD.fsm.request, 'normal'))
            self.localLerp.start(ts)
        if spawnId in self.spawners[spawnerId].fishArray:
            fish = self.spawners[spawnerId].fishArray[spawnId]
            endX = self.spawners[spawnerId].position.getX()
            if fish.name == 'clown':
                fishSoundName = 'Clownfish.ogg'
            elif fish.name == 'pbj':
                fishSoundName = 'PBJ_Fish.ogg'
            elif fish.name == 'balloon':
                fishSoundName = 'BalloonFish.ogg'
            elif fish.name == 'bear':
                fishSoundName = 'Bear_Acuda.ogg'
            elif fish.name == 'nurse':
                fishSoundName = 'Nurse_Shark.ogg'
            elif fish.name == 'piano':
                fishSoundName = 'Piano_Tuna.ogg'
            else:
                fishSoundName = ' '
            fishSoundPath = 'phase_4/audio/sfx/%s' % fishSoundName
            fish.sound = loader.loadSfx(fishSoundPath)
            if fish.sound:
                fish.sound.play()
                fish.sound.setVolume(volume)
                self.hitSound.play()
                self.hitSound.setVolume(volume)
            if fish.name is 'bear' or fish.name is 'nurse':
                return
            colList = fish.findAllMatches('**/fc*')
            for col in colList:
                col.removeNode()

            fish.moveLerp.pause()
            if fish.name == 'clown' or fish.name == 'piano':
                if fish.name != 'piano':
                    endHpr = Vec3(fish.getH() * -1, 0, 0)
                elif fish.direction == -1:
                    endHpr = Vec3(180, 0, 0)
                else:
                    endHpr = Vec3(0, 0, 0)
                fish.moveLerp = Sequence(LerpHprInterval(fish, duration=0.4, startHpr=fish.getHpr(), hpr=endHpr), LerpFunc(fish.setX, duration=1.5, fromData=fish.getX(), toData=endX), Func(self.fishRemove, str(spawnerId) + str(spawnId)))
            elif fish.name == 'pbj':
                fish.moveLerp = Sequence(LerpFunc(fish.setX, duration=2, fromData=fish.getX(), toData=endX), Func(self.fishRemove, str(spawnerId) + str(spawnId)))
            elif fish.name == 'balloon':
                fish.specialLerp.pause()
                anim = Func(fish.play, 'anim', fromFrame=110, toFrame=200)
                fish.setH(180)
                speed = Func(fish.setPlayRate, 3.0, 'anim')
                fish.moveLerp = Sequence(Func(fish.stop, 'anim'), speed, anim, Wait(1.0), LerpScaleInterval(fish, duration=0.8, startScale=fish.getScale, scale=0.001, blendType='easeIn'), Func(self.fishRemove, str(spawnerId) + str(spawnId)))
                fish.sound.setTime(11.5)
            fish.moveLerp.start(ts)

    def fishRemove(self, code):
        spawnId = int(code[1:len(code)])
        spawnerId = int(code[0])
        if spawnId in self.spawners[spawnerId].fishArray:
            fish = self.spawners[spawnerId].fishArray[spawnId]
            fish.specialLerp.finish()
            fish.moveLerp.finish()
            fish.specialLerp = None
            fish.moveLerp = None
            fish.removeNode()
            del fish
            del self.spawners[spawnerId].fishArray[spawnId]
        else:
            import pdb
            pdb.setTrace()
        return

    def setTreasureGrabbed(self, avId, chestId):
        if not self.hasLocalToon:
            return
        if self.grabbingTreasure == chestId:
            self.grabbingTreasure = -1
        toonSD = self.toonSDs.get(avId)
        if toonSD and toonSD.status == 'normal':
            toonSD.fsm.request('treasure')
            self.treasures[chestId].moveLerp.pause()
            self.treasures[chestId].moveLerp = Sequence()
            self.treasures[chestId].chestNode.setIntoCollideMask(BitMask32.allOff())
            self.treasures[chestId].treasureNode.reparentTo(self.getAvatar(avId))
            headparts = self.getAvatar(avId).getHeadParts()
            pos = headparts[2].getPos()
            self.treasures[chestId].treasureNode.setPos(pos + Point3(0, 0.2, 3))
            self.treasures[chestId].grabbedId = avId
            timestamp = globalClockDelta.getFrameNetworkTime()
            self.playSound('getGold')

    def __spawnCrabTask(self):
        taskMgr.remove(self.CRAB_TASK)
        taskMgr.add(self.__crabTask, self.CRAB_TASK)

    def __killCrabTask(self):
        taskMgr.remove(self.CRAB_TASK)

    def __crabTask(self, task):
        dt = globalClock.getDt()
        for crab in self.crabs:
            if not crab.moveLerp.isPlaying():
                crab.moveLerp = Wait(1.0)
                crab.moveLerp.loop()
                self.sendUpdate('getCrabMoving', [crab.crabId, crab.getX(), crab.direction])
                return Task.cont

        return Task.cont

    def setCrabMoving(self, crabId, timestamp, rand1, rand2, crabX, dir):
        if self.dead == 1:
            self.__killCrabTask()
            return
        if not hasattr(self, 'crabs'):
            return
        crab = self.crabs[crabId]
        ts = globalClockDelta.localElapsedTime(timestamp)
        x = 0
        for i in xrange(self.NUMTREASURES):
            x += self.treasures[i].treasureNode.getX(render)

        x /= self.NUMTREASURES
        goalX = int(x + dir * (rand1 / 10.0) * 12 + 4.0)
        goalZ = -40 + 5 + 5 * (rand2 / 10.0)
        xTime = 1 + rand1 / 10.0 * 2
        zTime = 0.5 + rand2 / 10.0
        wait = rand1 / 10.0 + rand2 / 10.0 + 1
        crab.direction *= -1
        if goalX > 20:
            goalX = 20
        elif goalX < -20:
            goalX = 20
        loc = crab.getPos(render)
        distance = base.localAvatar.getDistance(crab)
        crabVolume = 0
        soundRange = 25.0
        if distance < soundRange:
            crabVolume = (soundRange - distance) / soundRange
        crabSoundInterval = SoundInterval(self.crabSound, loop=0, duration=1.6, startTime=0.0)
        seq = Sequence(Wait(wait), LerpPosInterval(crab, duration=xTime, startPos=Point3(crabX, 0, -40), pos=Point3(goalX, 0, -40), blendType='easeIn'), Parallel(Func(self.grabCrapVolume, crab), LerpPosInterval(crab, duration=zTime, startPos=Point3(goalX, 0, -40), pos=Point3(goalX, 0, goalZ), blendType='easeOut')), LerpPosInterval(crab, duration=zTime, startPos=Point3(goalX, 0, goalZ), pos=Point3(goalX, 0, -40), blendType='easeInOut'))
        crab.moveLerp.pause()
        crab.moveLerp = seq
        crab.moveLerp.start(ts)

    def grabCrapVolume(self, crab):
        if crab:
            distance = base.localAvatar.getDistance(crab)
            self.crabVolume = 0
            soundRange = 25.0
            if distance < soundRange:
                crabVolume = (soundRange - distance) / soundRange
                crabSoundInterval = SoundInterval(self.crabSound, loop=0, duration=1.6, startTime=0.0, volume=crabVolume)
                crabSoundInterval.start()

    def __spawnUpdateLocalToonTask(self):
        self.__initPosBroadcast()
        taskMgr.remove(self.UPDATE_LOCALTOON_TASK)
        taskMgr.add(self.__updateLocalToonTask, self.UPDATE_LOCALTOON_TASK)

    def __killUpdateLocalToonTask(self):
        taskMgr.remove(self.UPDATE_LOCALTOON_TASK)

    def __updateLocalToonTask(self, task):
        dt = globalClock.getDt()
        toonPos = base.localAvatar.getPos()
        toonHpr = base.localAvatar.getHpr()
        self.xVel *= 0.99
        self.zVel *= 0.99
        pos = [toonPos[0], toonPos[1], toonPos[2]]
        hpr = [toonHpr[0], toonHpr[1], toonHpr[2]]
        r = 0
        toonSD = self.toonSDs[self.localAvId]
        if toonSD.status == 'normal' or toonSD.status == 'treasure':
            if self.arrowKeys.leftPressed():
                r -= 80
            if self.arrowKeys.rightPressed():
                r += 80
            hpr[2] += r * dt
            pos1 = self.orientNode.getPos(render)
            pos2 = self.orientNode2.getPos(render)
            upVec = Vec2(pos1[0], pos1[2])
            bkVec = Vec2(pos2[0], pos2[2])
            forVec = upVec - Vec2(pos[0], pos[2])
            bckVec = bkVec - Vec2(pos[0], pos[2])
            r = 0
            if self.arrowKeys.upPressed():
                r += 20
                self.xVel = forVec[0] * 8
                self.zVel = forVec[1] * 8
            elif self.arrowKeys.downPressed():
                r -= 20
                self.xVel = bckVec[0] * 4
                self.zVel = bckVec[1] * 4
            if self.xVel > 20:
                self.xVel = 20
            elif self.xVel < -20:
                self.xVel = -20
            if self.zVel > 10:
                self.zVel = 10
            elif self.zVel < -10:
                self.zVel = -10
        swimVolume = (abs(self.zVel) + abs(self.xVel)) / 15.0
        self.swimSound.setVolume(swimVolume)
        pos[0] += self.xVel * dt
        pos[1] = -2
        pos[2] += self.zVel * dt
        found = 0
        for i in xrange(self.NUMTREASURES):
            if self.treasures[i].grabbedId == self.localAvId:
                found = 1
                i = self.NUMTREASURES + 1
                pos[2] -= 0.8 * dt

        if found == 0:
            pos[2] += 0.8 * dt
        if pos[2] < -38:
            pos[2] = -38
        elif pos[2] > 36:
            pos[2] = 36
        if pos[0] < -20:
            pos[0] = -20
        elif pos[0] > 20:
            pos[0] = 20
        base.localAvatar.setPos(pos[0], pos[1], pos[2])
        base.localAvatar.setHpr(hpr[0], hpr[1], hpr[2])
        posDiv = self.MAP_DIV
        self.mapAvatars[self.localAvId].setPos(pos[0] / posDiv, pos[1] / posDiv, pos[2] / posDiv + self.MAP_OFF)
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                pos = toon.getPos()
                self.mapAvatars[avId].setPos(pos / posDiv)
                self.mapAvatars[avId].setZ(self.mapAvatars[avId].getZ() + self.MAP_OFF)

        self.cTrav.traverse(render)
        self.cTrav2.traverse(render)
        self.__posBroadcast(dt)
        z = self.getAvatar(self.localAvId).getZ() + 3
        camBottom = math.tan(base.camLens.getVfov()/2.0*math.pi/180)*54
        z = max(z, -42+camBottom)
        camera.setZ(z)
        ambVolume = abs(z - 25.0) / 50.0 + 0.1
        if ambVolume < 0.0:
            ambVolume = 0.0
        if ambVolume > 1.0:
            ambVolume = 1.0
        ambVolume = pow(ambVolume, 0.75)
        self.sndAmbience.setVolume(ambVolume)
        return Task.cont

    def exitSwim(self):
        self.music.stop()
        self.ignore('resetClock')
        self.__killUpdateLocalToonTask()
        self.__killCrabTask()
        self.__killTreasureBoundsTask()
        self.timer.stop()
        self.timer.destroy()
        self.localLerp.finish()
        self.introMovie.finish()
        self.boatTilt.finish()
        self.treasurePanel.cleanup()
        self.mapAvatars[self.localAvId].destroy()
        del self.mapAvatars
        for i in xrange(self.NUMTREASURES):
            del self.chestIcons[i]

        del self.timer

    def enterCleanup(self):
        pass

    def exitCleanup(self):
        pass