oldschool-toontown/toontown/minigame/DistributedPatternGame.py

from pandac.PandaModules import *
from toontown.toonbase.ToonBaseGlobal import *
from direct.interval.IntervalGlobal import *
from DistributedMinigame import *
from direct.gui.DirectGui import *
from pandac.PandaModules import *
from direct.fsm import ClassicFSM, State
from direct.fsm import State
from toontown.toonbase import ToontownTimer
import PatternGameGlobals
from toontown.toon import ToonHead
from toontown.char import CharDNA
from toontown.char import Char
import ArrowKeys
import random
from toontown.toonbase import ToontownGlobals
import string
from toontown.toonbase import TTLocalizer

class DistributedPatternGame(DistributedMinigame):
    phase4snd = 'phase_4/audio/sfx/'
    ButtonSoundNames = (phase4snd + 'm_match_trumpet.mp3',
     phase4snd + 'm_match_guitar.mp3',
     phase4snd + 'm_match_drums.mp3',
     phase4snd + 'm_match_piano.mp3')
    bgm = 'phase_4/audio/bgm/m_match_bg1.mid'
    strWatch = TTLocalizer.PatternGameWatch
    strGo = TTLocalizer.PatternGameGo
    strRight = TTLocalizer.PatternGameRight
    strWrong = TTLocalizer.PatternGameWrong
    strPerfect = TTLocalizer.PatternGamePerfect
    strBye = TTLocalizer.PatternGameBye
    strWaitingOtherPlayers = TTLocalizer.PatternGameWaitingOtherPlayers
    strPleaseWait = TTLocalizer.PatternGamePleaseWait
    strRound = TTLocalizer.PatternGameRound
    minnieAnimNames = ['up',
     'left',
     'down',
     'right']
    toonAnimNames = ['up',
     'left',
     'down',
     'right',
     'slip-forward',
     'slip-backward',
     'victory']

    def __init__(self, cr):
        DistributedMinigame.__init__(self, cr)
        self.gameFSM = ClassicFSM.ClassicFSM('DistributedPatternGame', [State.State('off', self.enterOff, self.exitOff, ['waitForServerPattern']),
         State.State('waitForServerPattern', self.enterWaitForServerPattern, self.exitWaitForServerPattern, ['showServerPattern', 'cleanup']),
         State.State('showServerPattern', self.enterShowServerPattern, self.exitShowServerPattern, ['getUserInput', 'playBackPatterns', 'cleanup']),
         State.State('getUserInput', self.enterGetUserInput, self.exitGetUserInput, ['waitForPlayerPatterns', 'playBackPatterns', 'cleanup']),
         State.State('waitForPlayerPatterns', self.enterWaitForPlayerPatterns, self.exitWaitForPlayerPatterns, ['playBackPatterns', 'cleanup', 'checkGameOver']),
         State.State('playBackPatterns', self.enterPlayBackPatterns, self.exitPlayBackPatterns, ['checkGameOver', 'cleanup']),
         State.State('checkGameOver', self.enterCheckGameOver, self.exitCheckGameOver, ['waitForServerPattern', 'cleanup']),
         State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
        self.addChildGameFSM(self.gameFSM)
        self.arrowColor = VBase4(1, 0, 0, 1)
        self.xColor = VBase4(1, 0, 0, 1)
        self.celebrate = 0
        self.oldBgColor = None
        self.trans = VBase4(1, 0, 0, 0)
        self.opaq = VBase4(1, 0, 0, 1)
        self.normalTextColor = VBase4(0.537, 0.84, 0.33, 1.0)
        self.__otherToonIndex = {}
        return

    def getTitle(self):
        return TTLocalizer.PatternGameTitle

    def getInstructions(self):
        return TTLocalizer.PatternGameInstructions

    def getMaxDuration(self):
        inputDur = PatternGameGlobals.NUM_ROUNDS * PatternGameGlobals.InputTime
        return inputDur * 1.3

    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.hide()
        self.room = loader.loadModel('phase_4/models/minigames/matching_room')
        self.buttonSounds = []
        for soundName in self.ButtonSoundNames:
            self.buttonSounds.append(base.loader.loadSfx(soundName))

        self.correctSound = base.loader.loadSfx('phase_4/audio/sfx/MG_pos_buzzer.wav')
        self.incorrectSound = base.loader.loadSfx('phase_4/audio/sfx/MG_neg_buzzer.wav')
        self.perfectSound = base.loader.loadSfx('phase_4/audio/sfx/MG_win.mp3')
        self.fallSound = base.loader.loadSfx('phase_4/audio/sfx/MG_Tag_A.mp3')
        self.music = base.loader.loadMusic(self.bgm)
        self.waitingText = DirectLabel(text=self.strPleaseWait, text_fg=(0.9, 0.9, 0.9, 1.0), frameColor=(1, 1, 1, 0), text_font=ToontownGlobals.getSignFont(), pos=(0, 0, -.78), scale=0.12)
        self.roundText = DirectLabel(text=self.strRound % 1, text_fg=self.normalTextColor, frameColor=(1, 1, 1, 0), text_font=ToontownGlobals.getSignFont(), pos=(0.014, 0, -.84), scale=0.12)
        self.roundText.hide()
        self.waitingText.hide()
        matchingGameGui = loader.loadModel('phase_3.5/models/gui/matching_game_gui')
        minnieArrow = matchingGameGui.find('**/minnieArrow')
        minnieX = matchingGameGui.find('**/minnieX')
        minnieCircle = matchingGameGui.find('**/minnieCircle')
        self.arrows = [None] * 5
        for x in range(0, 5):
            self.arrows[x] = minnieArrow.copyTo(hidden)
            self.arrows[x].hide()

        self.xs = [None] * 5
        for x in range(0, 5):
            self.xs[x] = minnieX.copyTo(hidden)
            self.xs[x].hide()

        self.statusBalls = []
        self.totalMoves = PatternGameGlobals.INITIAL_ROUND_LENGTH + PatternGameGlobals.ROUND_LENGTH_INCREMENT * (PatternGameGlobals.NUM_ROUNDS - 1)
        for x in range(0, 4):
            self.statusBalls.append([None] * self.totalMoves)

        for x in range(0, 4):
            for y in range(0, self.totalMoves):
                self.statusBalls[x][y] = minnieCircle.copyTo(hidden)
                self.statusBalls[x][y].hide()

        minnieArrow.removeNode()
        minnieX.removeNode()
        minnieCircle.removeNode()
        matchingGameGui.removeNode()
        self.minnie = Char.Char()
        m = self.minnie
        dna = CharDNA.CharDNA()
        dna.newChar('mn')
        m.setDNA(dna)
        m.setName(TTLocalizer.Minnie)
        m.reparentTo(hidden)
        self.backRowHome = Point3(3, 11, 0)
        self.backRowXSpacing = 1.8
        self.frontRowHome = Point3(0, 18, 0)
        self.frontRowXSpacing = 3.0
        self.stdNumDanceStepPingFrames = self.minnie.getNumFrames(self.minnieAnimNames[0])
        self.stdNumDanceStepPingPongFrames = self.__numPingPongFrames(self.stdNumDanceStepPingFrames)
        self.buttonPressDelayPercent = (self.stdNumDanceStepPingFrames - 1.0) / self.stdNumDanceStepPingPongFrames
        self.animPlayRates = []
        animPlayRate = 1.4
        animPlayRateMult = 1.06
        for i in range(PatternGameGlobals.NUM_ROUNDS):
            self.animPlayRates.append(animPlayRate)
            animPlayRate *= animPlayRateMult

        return

    def unload(self):
        self.notify.debug('unload')
        DistributedMinigame.unload(self)
        self.timer.destroy()
        del self.timer
        del self.lt
        del self.buttonSounds
        del self.music
        del self.__otherToonIndex
        del self.correctSound
        del self.incorrectSound
        del self.perfectSound
        del self.fallSound
        self.waitingText.destroy()
        del self.waitingText
        self.roundText.destroy()
        del self.roundText
        for x in self.arrowDict.values():
            x[0].removeNode()
            x[1].removeNode()
            if len(x) == 3:
                for y in x[2]:
                    y.removeNode()

        del self.arrowDict
        for x in self.arrows:
            if x:
                x.removeNode()

        del self.arrows
        for x in self.xs:
            if x:
                x.removeNode()

        del self.xs
        for x in self.statusBalls:
            if x:
                for y in x:
                    if y:
                        y.removeNode()
                        del y

        del self.statusBalls
        self.room.removeNode()
        del self.room
        self.minnie.delete()
        del self.minnie
        self.removeChildGameFSM(self.gameFSM)
        del self.gameFSM

    def onstage(self):
        self.notify.debug('onstage')
        DistributedMinigame.onstage(self)
        self.arrowDict = {}
        self.lt = base.localAvatar
        camera.reparentTo(render)
        camera.setPosHpr(0.0, -14.59, 10.56, 0.0, -16.39, 0.0)
        base.camLens.setFov(24.66)
        NametagGlobals.setGlobalNametagScale(0.6)
        self.arrowKeys = ArrowKeys.ArrowKeys()
        self.room.reparentTo(render)
        self.room.setPosHpr(0.0, 18.39, -ToontownGlobals.FloorOffset, 0.0, 0.0, 0.0)
        self.room.setScale(1)
        for anim in self.minnieAnimNames:
            self.minnie.pose(anim, 0)

        for anim in self.toonAnimNames:
            self.lt.pose(anim, 0)

        self.minnieAnimSpeedMult = {}
        self.toonAnimSpeedMult = {}
        for anim in self.minnieAnimNames:
            numFrames = self.minnie.getNumFrames(anim)
            self.minnieAnimSpeedMult[anim] = float(self.__numPingPongFrames(numFrames)) / float(self.stdNumDanceStepPingPongFrames)

        for anim in self.toonAnimNames:
            numFrames = self.lt.getNumFrames(anim)
            self.toonAnimSpeedMult[anim] = float(self.__numPingPongFrames(numFrames)) / float(self.stdNumDanceStepPingPongFrames)

        lt = self.lt
        lt.reparentTo(render)
        lt.useLOD(1000)
        lt.setPos(-3.5, 11, 0.0)
        lt.setScale(1)
        self.makeToonLookatCamera(lt)
        lt.loop('neutral')
        lt.startBlink()
        lt.startLookAround()
        self.arrowDict['lt'] = [self.arrows.pop(), self.xs.pop(), self.statusBalls.pop()]
        jj = self.lt.nametag3d
        for k in range(0, 2):
            self.arrowDict['lt'][k].setBillboardAxis()
            self.arrowDict['lt'][k].setBin('fixed', 100)
            self.arrowDict['lt'][k].reparentTo(jj)
            if k == 0:
                self.arrowDict['lt'][k].setScale(2.5)
                self.arrowDict['lt'][k].setColor(self.arrowColor)
            else:
                self.arrowDict['lt'][k].setScale(4, 4, 4)
                self.arrowDict['lt'][k].setColor(self.xColor)
            self.arrowDict['lt'][k].setPos(0, 0, 1)

        self.formatStatusBalls(self.arrowDict['lt'][2], jj)
        m = self.minnie
        m.reparentTo(render)
        m.setPos(-1.6, 20, 0)
        m.setScale(1)
        self.makeToonLookatCamera(m)
        m.loop('neutral')
        m.startBlink()
        self.minnie.nametag.manage(base.marginManager)
        self.minnie.startEarTask()
        self.minnie.setPickable(0)
        self.minnie.nametag.getNametag3d().setChatWordwrap(8)
        self.arrowDict['m'] = [self.arrows.pop(), self.xs.pop()]
        jj = self.minnie.nametag3d
        for k in range(0, 2):
            self.arrowDict['m'][k].setBillboardAxis()
            self.arrowDict['m'][k].setBin('fixed', 100)
            self.arrowDict['m'][k].setColor(self.arrowColor)
            self.arrowDict['m'][k].reparentTo(jj)
            self.arrowDict['m'][k].setScale(4)
            self.arrowDict['m'][k].setPos(0, 0, 1.7)

        base.playMusic(self.music, looping=1, volume=1)

    def offstage(self):
        self.notify.debug('offstage')
        DistributedMinigame.offstage(self)
        self.music.stop()
        base.camLens.setFov(ToontownGlobals.DefaultCameraFov)
        NametagGlobals.setGlobalNametagScale(1.0)
        self.arrowKeys.destroy()
        del self.arrowKeys
        self.room.reparentTo(hidden)
        self.roundText.hide()
        self.minnie.nametag.unmanage(base.marginManager)
        self.minnie.stopEarTask()
        self.minnie.stop()
        self.minnie.stopBlink()
        self.minnie.reparentTo(hidden)
        self.lt.setScale(1)
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                toon.setScale(1)

        for avId in self.avIdList:
            av = self.getAvatar(avId)
            if av:
                av.resetLOD()
                for anim in self.toonAnimNames:
                    av.setPlayRate(1.0, anim)

    def setGameReady(self):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameReady')
        if DistributedMinigame.setGameReady(self):
            return
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                self.arrowDict[avId] = [self.arrows.pop(), self.xs.pop(), self.statusBalls.pop()]
                jj = toon.nametag3d
                for k in range(0, 2):
                    self.arrowDict[avId][k].setBillboardAxis()
                    self.arrowDict[avId][k].setBin('fixed', 100)
                    self.arrowDict[avId][k].reparentTo(jj)
                    if k == 0:
                        self.arrowDict[avId][k].setScale(2.5)
                        self.arrowDict[avId][k].setColor(self.arrowColor)
                    else:
                        self.arrowDict[avId][k].setScale(4, 4, 4)
                        self.arrowDict[avId][k].setColor(self.xColor)
                    self.arrowDict[avId][k].setPos(0, 0, 1)

                self.formatStatusBalls(self.arrowDict[avId][2], jj)
                toon.reparentTo(render)
                toon.useLOD(1000)
                toon.setPos(self.getBackRowPos(avId))
                toon.setScale(0.9)
                self.makeToonLookatCamera(toon)
                for anim in self.toonAnimNames:
                    toon.pose(anim, 0)

                toon.loop('neutral')

        if self.isSinglePlayer():
            self.waitingText['text'] = self.strPleaseWait
        else:
            self.waitingText['text'] = self.strWaitingOtherPlayers
        self.animTracks = {}
        for avId in self.avIdList:
            self.animTracks[avId] = None

        self.__initGameVars()
        return

    def setGameStart(self, timestamp):
        if not self.hasLocalToon:
            return
        self.notify.debug('setGameStart')
        DistributedMinigame.setGameStart(self, timestamp)
        self.gameFSM.request('waitForServerPattern')

    def __initGameVars(self):
        self.round = 0
        self.perfectGame = 1

    def __numPingPongFrames(self, numFrames):
        return numFrames * 2 - 1

    def makeToonLookatCamera(self, toon):
        toon.headsUp(camera)

    def setText(self, t, newtext):
        t['text'] = newtext

    def setTextFG(self, t, fg):
        t['text_fg'] = fg

    def getWalkTrack(self, toon, posList, startPos = None, lookAtCam = 1, endHeading = 180):
        walkSpeed = 7
        origPos = toon.getPos()
        origHpr = toon.getHpr()
        track = Sequence(Func(toon.loop, 'run'))
        if startPos:
            toon.setPos(startPos)
            track.append(Func(toon.setPos, startPos))
        for endPos in posList:
            toon.headsUp(Point3(endPos))
            track.append(Func(toon.setHpr, Point3(toon.getH(), 0, 0)))
            lastPos = toon.getPos()
            distance = Vec3(endPos - lastPos).length()
            duration = distance / walkSpeed
            toon.setPos(endPos)
            track.append(LerpPosInterval(toon, duration=duration, pos=Point3(endPos), startPos=Point3(lastPos)))

        if lookAtCam:
            saveHpr = toon.getHpr()
            toon.headsUp(camera)
            endHeading = toon.getHpr()[0]
            toon.setHpr(saveHpr)
        curHeading = toon.getH()
        if endHeading - curHeading > 180.0:
            endHeading -= 360
        elif endHeading - curHeading < -180.0:
            endHeading += 360
        endHpr = Point3(endHeading, 0, 0)
        duration = abs(endHeading - curHeading) / 180.0 * 0.3
        track.extend([Func(toon.loop, 'walk'), LerpHprInterval(toon, duration, endHpr), Func(toon.loop, 'neutral')])
        toon.setPos(origPos)
        toon.setHpr(origHpr)
        return track

    def getDanceStepDuration(self):
        numFrames = self.stdNumDanceStepPingPongFrames
        return numFrames / abs(self.animPlayRate * self.minnieAnimSpeedMult[self.minnieAnimNames[0]] * self.minnie.getFrameRate(self.minnieAnimNames[0]))

    def __getDanceStepAnimTrack(self, toon, anim, speedScale):
        numFrames = toon.getNumFrames(anim)
        return Sequence(Func(toon.pingpong, anim, fromFrame=0, toFrame=numFrames - 1), Wait(self.getDanceStepDuration()))

    def __getMinnieDanceStepAnimTrack(self, minnie, direction):
        animName = self.minnieAnimNames[direction]
        return self.__getDanceStepAnimTrack(minnie, animName, self.minnieAnimSpeedMult[animName])

    def __getToonDanceStepAnimTrack(self, toon, direction):
        animName = self.toonAnimNames[direction]
        return self.__getDanceStepAnimTrack(toon, animName, self.toonAnimSpeedMult[animName])

    def getDanceStepButtonSoundTrack(self, index):
        duration = self.getDanceStepDuration()
        wait = duration * self.buttonPressDelayPercent
        return Sequence(Wait(wait), Func(base.playSfx, self.__getButtonSound(index)), Wait(duration - wait))

    def getDanceArrowAnimTrack(self, toonID, pattern, speedy):
        track = Sequence()
        track.append(Func(self.showArrow, toonID))
        for buttonIndex in pattern:
            track.append(self.getDanceArrowSingleTrack(toonID, buttonIndex, speedy))

        track.append(Func(self.hideArrow, toonID))
        return track

    def changeArrow(self, toonID, index):
        self.arrowDict[toonID][0].setR(-(90 - 90 * index))

    def showArrow(self, toonID):
        self.arrowDict[toonID][0].show()

    def hideArrow(self, toonID):
        self.arrowDict[toonID][0].hide()

    def showX(self, toonID):
        self.arrowDict[toonID][1].show()

    def hideX(self, toonID):
        self.arrowDict[toonID][1].hide()

    def celebrated(self):
        self.celebrate = 1

    def returnCelebrationIntervals(self, turnOn):
        ri = []
        if turnOn:
            ri.append(ActorInterval(actor=self.lt, animName='victory', duration=5.5))
        else:
            ri.append(Func(self.lt.loop, 'neutral'))
        for avId in self.remoteAvIdList:
            toon = self.getAvatar(avId)
            if toon:
                if turnOn:
                    ri.append(ActorInterval(actor=toon, animName='victory', duration=5.5))
                else:
                    ri.append(Func(toon.loop, 'neutral'))

        if len(self.remoteAvIdList) == 0:
            return ri
        else:
            return Parallel(ri)

    def formatStatusBalls(self, sb, jj):
        for x in range(0, self.totalMoves):
            sb[x].setBillboardAxis()
            sb[x].setBin('fixed', 100)
            sb[x].reparentTo(jj)
            sb[x].setScale(1)
            xpos = +(int(self.totalMoves / 2) * 0.25) - 0.25 * x
            sb[x].setPos(xpos, 0, 0.3)

    def showStatusBalls(self, toonID):
        sb = self.arrowDict[toonID][2]
        for x in range(0, len(self.__serverPattern)):
            sb[x].setColor(1, 1, 1, 1)
            sb[x].show()

    def hideStatusBalls(self, toonID):
        sb = self.arrowDict[toonID][2]
        for x in range(0, len(sb)):
            sb[x].hide()

    def colorStatusBall(self, toonID, which, good):
        if good:
            self.arrowDict[toonID][2][which].setColor(0, 1, 0, 1)
        else:
            self.arrowDict[toonID][2][which].setColor(1, 0, 0, 1)

    def getDanceArrowSingleTrack(self, toonID, index, speedy):
        duration = self.getDanceStepDuration()
        wait = duration * self.buttonPressDelayPercent
        d = duration - wait
        if speedy:
            track = Sequence(Func(self.changeArrow, toonID, index), Wait(wait))
        else:
            track = Sequence(Func(self.changeArrow, toonID, index), Wait(wait), LerpColorInterval(self.arrowDict[toonID][0], d, self.trans, self.opaq))
        return track

    def getDanceSequenceAnimTrack(self, toon, pattern):
        getDanceStepTrack = self.__getToonDanceStepAnimTrack
        if toon == self.minnie:
            getDanceStepTrack = self.__getMinnieDanceStepAnimTrack
        tracks = Sequence()
        for direction in pattern:
            tracks.append(getDanceStepTrack(toon, direction))

        if len(pattern):
            tracks.append(Func(toon.loop, 'neutral'))
        return tracks

    def getDanceSequenceButtonSoundTrack(self, pattern):
        track = Sequence()
        for buttonIndex in pattern:
            track.append(self.getDanceStepButtonSoundTrack(buttonIndex))

        return track

    def __getRowPos(self, rowHome, xSpacing, index, numSpots):
        xOffset = xSpacing * index - xSpacing * (numSpots - 1) / 2.0
        return rowHome + Point3(xOffset, 0, 0)

    def getBackRowPos(self, avId):
        index = self.remoteAvIdList.index(avId)
        return self.__getRowPos(self.backRowHome, self.backRowXSpacing, index, len(self.remoteAvIdList))

    def getFrontRowPos(self, avId):
        index = self.avIdList.index(avId)
        return self.__getRowPos(self.frontRowHome, self.frontRowXSpacing, index, len(self.avIdList))

    def __setMinnieChat(self, str, giggle):
        str = string.replace(str, '%s', self.getAvatar(self.localAvId).getName())
        self.minnie.setChatAbsolute(str, CFSpeech)
        if giggle:
            self.minnie.playDialogue('statementA', 1)

    def __clearMinnieChat(self):
        self.minnie.clearChat()

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

    def exitOff(self):
        pass

    def enterWaitForServerPattern(self):
        self.notify.debug('enterWaitForServerPattern')
        self.sendUpdate('reportPlayerReady', [])

    def setPattern(self, pattern):
        if not self.hasLocalToon:
            return
        self.notify.debug('setPattern: ' + str(pattern))
        self.__serverPattern = pattern
        self.gameFSM.request('showServerPattern')

    def exitWaitForServerPattern(self):
        pass

    def enterShowServerPattern(self):
        self.notify.debug('enterShowServerPattern')
        self.round += 1
        self.roundText.show()
        self.roundText.setScale(0.12)
        self.roundText['text'] = self.strRound % self.round
        self.animPlayRate = self.animPlayRates[self.round - 1]
        for avId in self.avIdList:
            toon = self.getAvatar(avId)
            if toon:
                for anim in self.toonAnimNames:
                    toon.setPlayRate(self.animPlayRate * self.toonAnimSpeedMult[anim], anim)

        for anim in self.minnieAnimNames:
            self.minnie.setPlayRate(self.animPlayRate * self.minnieAnimSpeedMult[anim], anim)

        text = self.strWatch
        danceTrack = self.getDanceSequenceAnimTrack(self.minnie, self.__serverPattern)
        arrowTrack = self.getDanceArrowAnimTrack('m', self.__serverPattern, 0)
        soundTrack = self.getDanceSequenceButtonSoundTrack(self.__serverPattern)
        self.showTrack = Sequence(Func(self.__setMinnieChat, text, 1), Wait(0.5), Parallel(danceTrack, soundTrack, arrowTrack), Wait(0.2), Func(self.__clearMinnieChat), Func(self.gameFSM.request, 'getUserInput'))
        self.showTrack.start()

    def exitShowServerPattern(self):
        if self.showTrack.isPlaying():
            self.showTrack.pause()
        del self.showTrack

    def enterGetUserInput(self):
        self.notify.debug('enterGetUserInput')
        self.setupTrack = None
        self.proceedTrack = None

        def startTimer(self = self):
            self.currentStartTime = globalClock.getFrameTime()
            self.timer.show()
            self.timer.countdown(PatternGameGlobals.InputTime, self.__handleInputTimeout)

        def enableKeys(self = self):

            def keyPress(self, index):
                self.__pressHandler(index)

            def keyRelease(self, index):
                self.__releaseHandler(index)

            self.arrowKeys.setPressHandlers([lambda self = self, keyPress = keyPress: keyPress(self, 0),
             lambda self = self, keyPress = keyPress: keyPress(self, 2),
             lambda self = self, keyPress = keyPress: keyPress(self, 3),
             lambda self = self, keyPress = keyPress: keyPress(self, 1)])
            self.arrowKeys.setReleaseHandlers([lambda self = self, keyRelease = keyRelease: keyRelease(self, 0),
             lambda self = self, keyRelease = keyRelease: keyRelease(self, 2),
             lambda self = self, keyRelease = keyRelease: keyRelease(self, 3),
             lambda self = self, keyRelease = keyRelease: keyRelease(self, 1)])

        self.__localPattern = []
        self.__otherToonIndex.clear()
        self.showStatusBalls('lt')
        for avId in self.remoteAvIdList:
            self.showStatusBalls(avId)
            self.__otherToonIndex[avId] = 0

        self.setupTrack = Sequence(Func(self.__setMinnieChat, self.strGo, 0), Func(self.setText, self.roundText, TTLocalizer.PatternGameGo), Func(self.roundText.setScale, 0.3), Func(enableKeys), Func(startTimer), Wait(0.8), Func(self.__clearMinnieChat), Func(self.setText, self.roundText, ' '), Func(self.roundText.setScale, 0.12), Func(self.setTextFG, self.roundText, self.normalTextColor))
        self.setupTrack.start()
        return

    def __handleInputTimeout(self):
        self.__doneGettingInput(self.__localPattern)

    def __pressHandler(self, index):
        self.__buttonPressed(index)

    def __releaseHandler(self, index):
        pass

    def remoteButtonPressed(self, avId, index, wrong):
        if not self.hasLocalToon:
            return
        if self.gameFSM.getCurrentState().getName() not in ['getUserInput', 'waitForPlayerPatterns']:
            return
        if avId != self.localAvId:
            if self.animTracks[avId]:
                self.animTracks[avId].finish()
            av = self.getAvatar(avId)
            if wrong:
                acts = ['slip-forward', 'slip-backward']
                ag = random.choice(acts)
                self.arrowDict[avId][0].hide()
                self.animTracks[avId] = Sequence(Func(self.showX, avId), Func(self.colorStatusBall, avId, self.__otherToonIndex[avId], 0), ActorInterval(actor=av, animName=ag, duration=2.35), Func(av.loop, 'neutral'), Func(self.hideX, avId))
            else:
                self.colorStatusBall(avId, self.__otherToonIndex[avId], 1)
                arrowTrack = self.getDanceArrowAnimTrack(avId, [index], 1)
                potTrack = self.getDanceSequenceAnimTrack(av, [index])
                self.animTracks[avId] = Parallel(potTrack, arrowTrack)
            self.__otherToonIndex[avId] += 1
            self.animTracks[avId].start()

    def __getButtonSound(self, index):
        return self.buttonSounds[index]

    def __buttonPressed(self, index):
        if len(self.__localPattern) >= len(self.__serverPattern):
            return
        if self.animTracks[self.localAvId]:
            self.animTracks[self.localAvId].finish()
        badd = 0
        if index != self.__serverPattern[len(self.__localPattern)]:
            badd = 1
            acts = ['slip-forward', 'slip-backward']
            ag = random.choice(acts)
            self.animTracks[self.localAvId] = Sequence(Func(self.showX, 'lt'), Func(self.colorStatusBall, 'lt', len(self.__localPattern), 0), ActorInterval(actor=self.lt, animName=ag, duration=2.35), Func(self.lt.loop, 'neutral'), Func(self.hideX, 'lt'))
            self.arrowDict['lt'][0].hide()
            base.playSfx(self.fallSound)
        else:
            self.colorStatusBall('lt', len(self.__localPattern), 1)
            base.playSfx(self.__getButtonSound(index))
            arrowTrack = self.getDanceArrowAnimTrack('lt', [index], 1)
            potTrack = self.getDanceSequenceAnimTrack(self.lt, [index])
            self.animTracks[self.localAvId] = Parallel(potTrack, arrowTrack)
        self.sendUpdate('reportButtonPress', [index, badd])
        self.animTracks[self.localAvId].start()
        self.__localPattern.append(index)
        if len(self.__localPattern) == len(self.__serverPattern) or badd:
            self.__doneGettingInput(self.__localPattern)

    def __doneGettingInput(self, pattern):
        self.arrowKeys.setPressHandlers(self.arrowKeys.NULL_HANDLERS)
        self.currentTotalTime = globalClock.getFrameTime() - self.currentStartTime
        self.proceedTrack = Sequence(Wait(self.getDanceStepDuration()), Func(self.sendUpdate, 'reportPlayerPattern', [pattern, self.currentTotalTime]), Func(self.gameFSM.request, 'waitForPlayerPatterns'))
        self.proceedTrack.start()

    def exitGetUserInput(self):
        self.timer.stop()
        self.timer.hide()
        self.arrowKeys.setPressHandlers(self.arrowKeys.NULL_HANDLERS)
        self.arrowKeys.setReleaseHandlers(self.arrowKeys.NULL_HANDLERS)
        if self.setupTrack and self.setupTrack.isPlaying():
            self.setupTrack.pause()
        if self.proceedTrack and self.proceedTrack.isPlaying():
            self.proceedTrack.pause()
        del self.setupTrack
        del self.proceedTrack
        self.__clearMinnieChat()

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

    def setPlayerPatterns(self, pattern1, pattern2, pattern3, pattern4, fastestAvId):
        if not self.hasLocalToon:
            return
        self.fastestAvId = fastestAvId
        self.notify.debug('setPlayerPatterns:' + ' pattern1:' + str(pattern1) + ' pattern2:' + str(pattern2) + ' pattern3:' + str(pattern3) + ' pattern4:' + str(pattern4))
        self.playerPatterns = {}
        patterns = [pattern1,
         pattern2,
         pattern3,
         pattern4]
        for i in range(len(self.avIdList)):
            self.playerPatterns[self.avIdList[i]] = patterns[i]

        self.gameFSM.request('playBackPatterns')

    def exitWaitForPlayerPatterns(self):
        self.waitingText.hide()

    def enterPlayBackPatterns(self):
        self.notify.debug('enterPlayBackPatterns')
        if self.fastestAvId == self.localAvId:
            self.roundText.setScale(0.1)
            if self.numPlayers != 2:
                self.roundText['text'] = TTLocalizer.PatternGameFastest
            else:
                self.roundText['text'] = TTLocalizer.PatternGameFaster
            jumpTrack = Sequence(ActorInterval(actor=self.lt, animName='jump', duration=1.7), Func(self.lt.loop, 'neutral'))
        elif self.fastestAvId == 0:
            if self.round == PatternGameGlobals.NUM_ROUNDS:
                self.roundText['text'] = ' '
            else:
                self.roundText.setScale(0.1)
                self.roundText['text'] = TTLocalizer.PatternGameYouCanDoIt
            jumpTrack = Sequence(Wait(0.5), Wait(0.5))
        elif self.fastestAvId == 1:
            self.roundText.setScale(0.1)
            self.roundText['text'] = TTLocalizer.PatternGameGreatJob
            jumpTrack = Sequence(Wait(0.5), Wait(0.5))
        else:
            self.roundText.setScale(0.08)
            av = self.getAvatar(self.fastestAvId)
            jumpTrack = Sequence(ActorInterval(actor=av, animName='jump', duration=1.7), Func(av.loop, 'neutral'))
            if self.numPlayers != 2:
                rewardStr = TTLocalizer.PatternGameOtherFastest
            else:
                rewardStr = TTLocalizer.PatternGameOtherFaster
            self.roundText['text'] = av.getName() + rewardStr
        success = self.playerPatterns[self.localAvId] == self.__serverPattern
        self.hideStatusBalls('lt')
        for avId in self.remoteAvIdList:
            self.hideStatusBalls(avId)

        if success:
            sound = self.correctSound
            text = self.strRight
        else:
            self.perfectGame = 0
            sound = self.incorrectSound
            text = self.strWrong
        soundTrack = Sequence(Func(base.playSfx, sound), Wait(1.6))
        textTrack = Sequence(Wait(0.2), Func(self.__setMinnieChat, text, 0), Wait(1.3), Func(self.__clearMinnieChat))
        self.playBackPatternsTrack = Sequence(Parallel(soundTrack, textTrack, jumpTrack), Func(self.gameFSM.request, 'checkGameOver'))
        self.playBackPatternsTrack.start()

    def exitPlayBackPatterns(self):
        if self.playBackPatternsTrack.isPlaying():
            self.playBackPatternsTrack.pause()
        del self.playBackPatternsTrack

    def enterCheckGameOver(self):
        self.notify.debug('enterCheckGameOver')
        self.__winTrack = None
        if self.round < PatternGameGlobals.NUM_ROUNDS:
            self.gameFSM.request('waitForServerPattern')
        else:
            text = self.strBye
            sound = None
            delay = 2.0
            if self.perfectGame:
                text = self.strPerfect
                sound = self.perfectSound
                delay = 2.2
            if self.celebrate:
                text = TTLocalizer.PatternGameImprov
                self.__winTrack = Sequence(Func(self.__setMinnieChat, text, 1), Func(base.playSfx, self.perfectSound), Sequence(self.returnCelebrationIntervals(1)), Sequence(self.returnCelebrationIntervals(0)), Func(self.__clearMinnieChat), Func(self.gameOver))
            else:
                self.__winTrack = Sequence(Func(self.__setMinnieChat, text, 1), Func(base.playSfx, sound), Wait(delay), Func(self.__clearMinnieChat), Func(self.gameOver))
            self.__winTrack.start()
        return

    def exitCheckGameOver(self):
        if self.__winTrack and self.__winTrack.isPlaying():
            self.__winTrack.pause()
        del self.__winTrack

    def enterCleanup(self):
        self.notify.debug('enterCleanup')
        for track in self.animTracks.values():
            if track and track.isPlaying():
                track.pause()

        del self.animTracks

    def exitCleanup(self):
        pass