888 lines
30 KiB
Python
888 lines
30 KiB
Python
from panda3d.core import *
|
|
from toontown.toonbase.ToonBaseGlobal import *
|
|
from direct.distributed.ClockDelta import *
|
|
from direct.interval.IntervalGlobal import *
|
|
from .DistributedMinigame import *
|
|
from direct.gui.DirectGui import *
|
|
from panda3d.core import *
|
|
from direct.fsm import ClassicFSM, State
|
|
from direct.fsm import State
|
|
from direct.task.Task import Task
|
|
from toontown.toonbase import ToontownTimer
|
|
from . import RaceGameGlobals
|
|
from toontown.toonbase import ToontownGlobals
|
|
from toontown.toonbase import TTLocalizer
|
|
|
|
class DistributedRaceGame(DistributedMinigame):
|
|
|
|
def __init__(self, cr):
|
|
DistributedMinigame.__init__(self, cr)
|
|
self.gameFSM = ClassicFSM.ClassicFSM('DistributedRaceGame', [State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
|
|
State.State('inputChoice', self.enterInputChoice, self.exitInputChoice, ['waitServerChoices', 'moveAvatars', 'cleanup']),
|
|
State.State('waitServerChoices', self.enterWaitServerChoices, self.exitWaitServerChoices, ['moveAvatars', 'cleanup']),
|
|
State.State('moveAvatars', self.enterMoveAvatars, self.exitMoveAvatars, ['inputChoice', 'winMovie', 'cleanup']),
|
|
State.State('winMovie', self.enterWinMovie, self.exitWinMovie, ['cleanup']),
|
|
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
|
|
self.addChildGameFSM(self.gameFSM)
|
|
self.posHprArray = (((-9.03,
|
|
0.06,
|
|
0.025,
|
|
-152.9),
|
|
(-7.43,
|
|
-2.76,
|
|
0.025,
|
|
-152.68),
|
|
(-6.02,
|
|
-5.48,
|
|
0.025,
|
|
-157.54),
|
|
(-5.01,
|
|
-8.32,
|
|
0.025,
|
|
-160.66),
|
|
(-4.05,
|
|
-11.36,
|
|
0.025,
|
|
-170.22),
|
|
(-3.49,
|
|
-14.18,
|
|
0.025,
|
|
-175.76),
|
|
(-3.12,
|
|
-17.15,
|
|
0.025,
|
|
-177.73),
|
|
(-3.0,
|
|
-20.32,
|
|
0.025,
|
|
178.49),
|
|
(-3.09,
|
|
-23.44,
|
|
0.025,
|
|
176.59),
|
|
(-3.43,
|
|
-26.54,
|
|
0.025,
|
|
171.44),
|
|
(-4.07,
|
|
-29.44,
|
|
0.025,
|
|
163.75),
|
|
(-5.09,
|
|
-32.27,
|
|
0.025,
|
|
158.2),
|
|
(-6.11,
|
|
-35.16,
|
|
0.025,
|
|
154.98),
|
|
(-7.57,
|
|
-37.78,
|
|
0.025,
|
|
154.98),
|
|
(-9.28,
|
|
-40.65,
|
|
0.025,
|
|
150.41)),
|
|
((-6.12,
|
|
1.62,
|
|
0.025,
|
|
-152.9),
|
|
(-4.38,
|
|
-1.35,
|
|
0.025,
|
|
-150.92),
|
|
(-3.08,
|
|
-4.3,
|
|
0.025,
|
|
-157.9),
|
|
(-1.85,
|
|
-7.26,
|
|
0.025,
|
|
-162.54),
|
|
(-0.93,
|
|
-10.49,
|
|
0.025,
|
|
-167.71),
|
|
(-0.21,
|
|
-13.71,
|
|
0.025,
|
|
-171.79),
|
|
(0.21,
|
|
-17.08,
|
|
0.025,
|
|
-174.92),
|
|
(0.31,
|
|
-20.2,
|
|
0.025,
|
|
177.1),
|
|
(0.17,
|
|
-23.66,
|
|
0.025,
|
|
174.82),
|
|
(-0.23,
|
|
-26.91,
|
|
0.025,
|
|
170.51),
|
|
(-0.99,
|
|
-30.2,
|
|
0.025,
|
|
162.54),
|
|
(-2.02,
|
|
-33.28,
|
|
0.025,
|
|
160.48),
|
|
(-3.28,
|
|
-36.38,
|
|
0.025,
|
|
157.96),
|
|
(-4.67,
|
|
-39.17,
|
|
0.025,
|
|
154.13),
|
|
(-6.31,
|
|
-42.15,
|
|
0.025,
|
|
154.13)),
|
|
((-2.99,
|
|
3.09,
|
|
0.025,
|
|
-154.37),
|
|
(-1.38,
|
|
-0.05,
|
|
0.025,
|
|
-154.75),
|
|
(-0.19,
|
|
-3.29,
|
|
0.025,
|
|
-159.22),
|
|
(1.17,
|
|
-6.51,
|
|
0.025,
|
|
-162.74),
|
|
(2.28,
|
|
-9.8,
|
|
0.025,
|
|
-168.73),
|
|
(3.09,
|
|
-13.28,
|
|
0.025,
|
|
-173.49),
|
|
(3.46,
|
|
-16.63,
|
|
0.025,
|
|
-176.81),
|
|
(3.69,
|
|
-20.38,
|
|
0.025,
|
|
179.14),
|
|
(3.61,
|
|
-24.12,
|
|
0.025,
|
|
175.78),
|
|
(3.0,
|
|
-27.55,
|
|
0.025,
|
|
170.87),
|
|
(2.15,
|
|
-30.72,
|
|
0.025,
|
|
167.41),
|
|
(1.04,
|
|
-34.26,
|
|
0.025,
|
|
162.11),
|
|
(-0.15,
|
|
-37.44,
|
|
0.025,
|
|
158.59),
|
|
(-1.64,
|
|
-40.52,
|
|
0.025,
|
|
153.89),
|
|
(-3.42,
|
|
-43.63,
|
|
0.025,
|
|
153.89)),
|
|
((0.0,
|
|
4.35,
|
|
0.025,
|
|
-154.37),
|
|
(1.52,
|
|
1.3,
|
|
0.025,
|
|
-155.67),
|
|
(3.17,
|
|
-2.07,
|
|
0.025,
|
|
-155.67),
|
|
(4.47,
|
|
-5.41,
|
|
0.025,
|
|
-163.0),
|
|
(5.56,
|
|
-9.19,
|
|
0.025,
|
|
-168.89),
|
|
(6.22,
|
|
-12.66,
|
|
0.025,
|
|
-171.67),
|
|
(6.67,
|
|
-16.56,
|
|
0.025,
|
|
-176.53),
|
|
(6.93,
|
|
-20.33,
|
|
0.025,
|
|
179.87),
|
|
(6.81,
|
|
-24.32,
|
|
0.025,
|
|
175.19),
|
|
(6.22,
|
|
-27.97,
|
|
0.025,
|
|
170.81),
|
|
(5.59,
|
|
-31.73,
|
|
0.025,
|
|
167.54),
|
|
(4.48,
|
|
-35.42,
|
|
0.025,
|
|
161.92),
|
|
(3.06,
|
|
-38.82,
|
|
0.025,
|
|
158.56),
|
|
(1.4,
|
|
-42.0,
|
|
0.025,
|
|
154.32),
|
|
(-0.71,
|
|
-45.17,
|
|
0.025,
|
|
153.27)))
|
|
self.avatarPositions = {}
|
|
self.modelCount = 8
|
|
self.cameraTopView = (-22.78,
|
|
-41.65,
|
|
31.53,
|
|
-51.55,
|
|
-42.68,
|
|
-2.96)
|
|
self.timer = None
|
|
self.timerStartTime = None
|
|
self.walkSeqs = {}
|
|
self.runSeqs = {}
|
|
return None
|
|
|
|
def getTitle(self):
|
|
return TTLocalizer.RaceGameTitle
|
|
|
|
def getInstructions(self):
|
|
return TTLocalizer.RaceGameInstructions
|
|
|
|
def getMaxDuration(self):
|
|
return 60
|
|
|
|
def load(self):
|
|
self.notify.debug('load')
|
|
DistributedMinigame.load(self)
|
|
self.raceBoard = loader.loadModel('phase_4/models/minigames/race')
|
|
self.raceBoard.setPosHpr(0, 0, 0, 0, 0, 0)
|
|
self.raceBoard.setScale(0.8)
|
|
self.dice = loader.loadModel('phase_4/models/minigames/dice')
|
|
self.dice1 = self.dice.find('**/dice_button1')
|
|
self.dice2 = self.dice.find('**/dice_button2')
|
|
self.dice3 = self.dice.find('**/dice_button3')
|
|
self.dice4 = self.dice.find('**/dice_button4')
|
|
self.diceList = [self.dice1,
|
|
self.dice2,
|
|
self.dice3,
|
|
self.dice4]
|
|
self.music = base.loader.loadMusic('phase_4/audio/bgm/minigame_race.ogg')
|
|
self.posBuzzer = base.loader.loadSfx('phase_4/audio/sfx/MG_pos_buzzer.ogg')
|
|
self.negBuzzer = base.loader.loadSfx('phase_4/audio/sfx/MG_neg_buzzer.ogg')
|
|
self.winSting = base.loader.loadSfx('phase_4/audio/sfx/MG_win.ogg')
|
|
self.loseSting = base.loader.loadSfx('phase_4/audio/sfx/MG_lose.ogg')
|
|
self.diceButtonList = []
|
|
for i in range(1, 5):
|
|
button = self.dice.find('**/dice_button' + str(i))
|
|
button_down = self.dice.find('**/dice_button' + str(i) + '_down')
|
|
button_ro = self.dice.find('**/dice_button' + str(i) + '_ro')
|
|
diceButton = DirectButton(image=(button,
|
|
button_down,
|
|
button_ro,
|
|
None), relief=None, pos=(-0.9 + (i - 1) * 0.2, 0.0, -0.85), scale=0.25, command=self.handleInputChoice, extraArgs=[i])
|
|
diceButton.hide()
|
|
self.diceButtonList.append(diceButton)
|
|
|
|
self.waitingChoicesLabel = DirectLabel(text=TTLocalizer.RaceGameWaitingChoices, text_fg=VBase4(1, 1, 1, 1), relief=None, pos=(-0.6, 0, -0.75), scale=0.075)
|
|
self.waitingChoicesLabel.hide()
|
|
self.chanceMarker = loader.loadModel('phase_4/models/minigames/question_mark')
|
|
self.chanceCard = loader.loadModel('phase_4/models/minigames/chance_card')
|
|
self.chanceCardText = OnscreenText('', fg=(1.0, 0, 0, 1), scale=0.14, font=ToontownGlobals.getSignFont(), wordwrap=14, pos=(0.0, 0.2), mayChange=1)
|
|
self.chanceCardText.hide()
|
|
self.cardSound = base.loader.loadSfx('phase_3.5/audio/sfx/GUI_stickerbook_turn.ogg')
|
|
self.chanceMarkers = []
|
|
return
|
|
|
|
def unload(self):
|
|
self.notify.debug('unload')
|
|
DistributedMinigame.unload(self)
|
|
self.raceBoard.removeNode()
|
|
del self.raceBoard
|
|
self.dice.removeNode()
|
|
del self.dice
|
|
self.chanceMarker.removeNode()
|
|
del self.chanceMarker
|
|
self.chanceCardText.removeNode()
|
|
del self.chanceCardText
|
|
self.chanceCard.removeNode()
|
|
del self.chanceCard
|
|
self.waitingChoicesLabel.destroy()
|
|
del self.waitingChoicesLabel
|
|
del self.music
|
|
del self.posBuzzer
|
|
del self.negBuzzer
|
|
del self.winSting
|
|
del self.loseSting
|
|
del self.cardSound
|
|
for button in self.diceButtonList:
|
|
button.destroy()
|
|
|
|
del self.diceButtonList
|
|
for marker in self.chanceMarkers:
|
|
marker.removeNode()
|
|
del marker
|
|
|
|
del self.chanceMarkers
|
|
self.removeChildGameFSM(self.gameFSM)
|
|
del self.gameFSM
|
|
|
|
def onstage(self):
|
|
self.notify.debug('onstage')
|
|
DistributedMinigame.onstage(self)
|
|
base.playMusic(self.music, looping=1, volume=0.8)
|
|
self.raceBoard.reparentTo(render)
|
|
camera.reparentTo(render)
|
|
p = self.cameraTopView
|
|
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
|
|
base.transitions.irisIn(0.4)
|
|
base.setBackgroundColor(0.1875, 0.7929, 0)
|
|
|
|
def offstage(self):
|
|
self.notify.debug('offstage')
|
|
DistributedMinigame.offstage(self)
|
|
self.music.stop()
|
|
base.setBackgroundColor(ToontownGlobals.DefaultBackgroundColor)
|
|
self.raceBoard.reparentTo(hidden)
|
|
self.chanceCard.reparentTo(hidden)
|
|
self.chanceCardText.hide()
|
|
if hasattr(self, 'chanceMarkers'):
|
|
for marker in self.chanceMarkers:
|
|
marker.reparentTo(hidden)
|
|
|
|
def setGameReady(self):
|
|
if not self.hasLocalToon:
|
|
return
|
|
self.notify.debug('setGameReady')
|
|
if DistributedMinigame.setGameReady(self):
|
|
return
|
|
self.resetPositions()
|
|
for i in range(self.numPlayers):
|
|
avId = self.avIdList[i]
|
|
if self.localAvId == avId:
|
|
self.localAvLane = i
|
|
avatar = self.getAvatar(avId)
|
|
if avatar:
|
|
avatar.reparentTo(render)
|
|
avatar.setAnimState('neutral', 1)
|
|
self.positionInPlace(avatar, i, 0)
|
|
|
|
def setGameStart(self, timestamp):
|
|
if not self.hasLocalToon:
|
|
return
|
|
self.notify.debug('setGameStart')
|
|
DistributedMinigame.setGameStart(self, timestamp)
|
|
self.gameFSM.request('inputChoice')
|
|
|
|
def enterOff(self):
|
|
self.notify.debug('enterOff')
|
|
|
|
def exitOff(self):
|
|
pass
|
|
|
|
def enterInputChoice(self):
|
|
self.notify.debug('enterInputChoice')
|
|
for button in self.diceButtonList:
|
|
button.show()
|
|
|
|
self.timer = ToontownTimer.ToontownTimer()
|
|
self.timer.hide()
|
|
if self.timerStartTime != None:
|
|
self.startTimer()
|
|
return
|
|
|
|
def startTimer(self):
|
|
now = globalClock.getFrameTime()
|
|
elapsed = now - self.timerStartTime
|
|
self.timer.posInTopRightCorner()
|
|
self.timer.setTime(RaceGameGlobals.InputTimeout)
|
|
self.timer.countdown(RaceGameGlobals.InputTimeout - elapsed, self.handleChoiceTimeout)
|
|
self.timer.show()
|
|
|
|
def setTimerStartTime(self, timestamp):
|
|
if not self.hasLocalToon:
|
|
return
|
|
self.timerStartTime = globalClockDelta.networkToLocalTime(timestamp)
|
|
if self.timer != None:
|
|
self.startTimer()
|
|
return
|
|
|
|
def exitInputChoice(self):
|
|
for button in self.diceButtonList:
|
|
button.hide()
|
|
|
|
if self.timer != None:
|
|
self.timer.destroy()
|
|
self.timer = None
|
|
self.timerStartTime = None
|
|
self.ignore('diceButton')
|
|
return
|
|
|
|
def handleChoiceTimeout(self):
|
|
self.sendUpdate('setAvatarChoice', [0])
|
|
self.gameFSM.request('waitServerChoices')
|
|
|
|
def handleInputChoice(self, choice):
|
|
self.sendUpdate('setAvatarChoice', [choice])
|
|
self.gameFSM.request('waitServerChoices')
|
|
|
|
def enterWaitServerChoices(self):
|
|
self.notify.debug('enterWaitServerChoices')
|
|
self.waitingChoicesLabel.show()
|
|
|
|
def exitWaitServerChoices(self):
|
|
self.waitingChoicesLabel.hide()
|
|
|
|
def localToonWon(self):
|
|
localToonPosition = self.avatarPositions[self.localAvId]
|
|
if localToonPosition >= RaceGameGlobals.NumberToWin:
|
|
self.notify.debug('localToon won')
|
|
return 1
|
|
else:
|
|
return 0
|
|
|
|
def anyAvatarWon(self):
|
|
for position in list(self.avatarPositions.values()):
|
|
if position >= RaceGameGlobals.NumberToWin:
|
|
self.notify.debug('anyAvatarWon: Somebody won')
|
|
return 1
|
|
|
|
self.notify.debug('anyAvatarWon: Nobody won')
|
|
return 0
|
|
|
|
def showNumbers(self, task):
|
|
self.notify.debug('showing numbers...')
|
|
self.diceInstanceList = []
|
|
for i in range(len(task.choiceList)):
|
|
avId = self.avIdList[i]
|
|
choice = task.choiceList[i]
|
|
if choice == 0:
|
|
self.diceInstanceList.append(None)
|
|
else:
|
|
diceInstance = self.diceList[choice - 1].copyTo(self.raceBoard)
|
|
self.diceInstanceList.append(diceInstance)
|
|
dicePosition = self.avatarPositions[avId] + 1
|
|
diceInstance.setScale(4.0)
|
|
self.positionInPlace(diceInstance, i, dicePosition)
|
|
diceInstance.setP(-90)
|
|
diceInstance.setZ(0.05)
|
|
diceInstance.setDepthOffset(1)
|
|
|
|
return Task.done
|
|
|
|
def showMatches(self, task):
|
|
self.notify.debug('showing matches...')
|
|
for i in range(len(task.choiceList)):
|
|
avId = self.avIdList[i]
|
|
choice = task.choiceList[i]
|
|
if choice != 0:
|
|
diceInstance = self.diceInstanceList[i]
|
|
freq = task.choiceList.count(choice)
|
|
if freq == 1:
|
|
diceInstance.setColor(0.2, 1, 0.2, 1)
|
|
if avId == self.localAvId:
|
|
base.playSfx(self.posBuzzer)
|
|
else:
|
|
diceInstance.setColor(1, 0.2, 0.2, 1)
|
|
if avId == self.localAvId:
|
|
base.playSfx(self.negBuzzer)
|
|
|
|
return Task.done
|
|
|
|
def hideNumbers(self, task):
|
|
self.notify.debug('hiding numbers...')
|
|
for dice in self.diceInstanceList:
|
|
if dice:
|
|
dice.removeNode()
|
|
|
|
self.diceInstanceList = []
|
|
return Task.done
|
|
|
|
def enterMoveAvatars(self, choiceList, positionList, rewardList):
|
|
self.notify.debug('in enterMoveAvatars:')
|
|
tasks = []
|
|
self.avatarPositionsCopy = self.avatarPositions.copy()
|
|
for i in range(0, len(choiceList) // self.numPlayers):
|
|
startIndex = i * self.numPlayers
|
|
endIndex = startIndex + self.numPlayers
|
|
self.choiceList = choiceList[startIndex:endIndex]
|
|
self.positionList = positionList[startIndex:endIndex]
|
|
self.rewardList = rewardList[startIndex:endIndex]
|
|
self.notify.debug(' turn: ' + str(i + 1))
|
|
self.notify.debug(' choiceList: ' + str(self.choiceList))
|
|
self.notify.debug(' positionList: ' + str(self.positionList))
|
|
self.notify.debug(' rewardList: ' + str(self.rewardList))
|
|
longestLerpTime = self.getLongestLerpTime(i > 0)
|
|
self.notify.debug('longestLerpTime: ' + str(longestLerpTime))
|
|
if i == 0:
|
|
snt = Task(self.showNumbers)
|
|
snt.choiceList = self.choiceList
|
|
smt = Task(self.showMatches)
|
|
smt.choiceList = self.choiceList
|
|
tasks += [snt, Task.pause(0.5), smt]
|
|
if longestLerpTime > 0.0:
|
|
self.notify.debug('someone moved...')
|
|
mat = Task(self.moveAvatars)
|
|
mat.choiceList = self.choiceList
|
|
mat.positionList = self.positionList
|
|
mat.rewardList = self.rewardList
|
|
mat.name = 'moveAvatars'
|
|
if i == 0:
|
|
tasks += [Task.pause(0.75),
|
|
mat,
|
|
Task.pause(0.75),
|
|
Task(self.hideNumbers),
|
|
Task.pause(longestLerpTime - 0.5)]
|
|
else:
|
|
mat.chance = 1
|
|
tasks += [mat, Task.pause(longestLerpTime)]
|
|
tasks += self.showChanceRewards()
|
|
else:
|
|
self.notify.debug('no one moved...')
|
|
tasks += [Task.pause(1.0), Task(self.hideNumbers)]
|
|
|
|
self.notify.debug('task list : ' + str(tasks))
|
|
wdt = Task(self.walkDone)
|
|
wdt.name = 'walk done'
|
|
tasks.append(wdt)
|
|
moveTask = Task.sequence(*tasks)
|
|
taskMgr.add(moveTask, 'moveAvatars')
|
|
|
|
def walkDone(self, task):
|
|
self.choiceList = []
|
|
self.positionList = []
|
|
if self.anyAvatarWon():
|
|
self.gameFSM.request('winMovie')
|
|
else:
|
|
self.gameFSM.request('inputChoice')
|
|
return Task.done
|
|
|
|
def getLongestLerpTime(self, afterFirst):
|
|
self.notify.debug('afterFirst: ' + str(afterFirst))
|
|
longestTime = 0.0
|
|
for i in range(len(self.choiceList)):
|
|
freq = self.choiceList.count(self.choiceList[i])
|
|
if afterFirst or freq == 1:
|
|
oldPosition = self.avatarPositionsCopy[self.avIdList[i]]
|
|
newPosition = self.positionList[i]
|
|
self.avatarPositionsCopy[self.avIdList[i]] = newPosition
|
|
squares_walked = abs(newPosition - oldPosition)
|
|
longestTime = max(longestTime, self.getWalkDuration(squares_walked))
|
|
|
|
return longestTime
|
|
|
|
def showChanceRewards(self):
|
|
tasks = []
|
|
for reward in self.rewardList:
|
|
self.notify.debug('showChanceRewards: reward = ' + str(reward))
|
|
index = self.rewardList.index(reward)
|
|
if reward != -1:
|
|
self.notify.debug('adding tasks!')
|
|
hcc = Task(self.hideChanceMarker)
|
|
hcc.chanceMarkers = self.chanceMarkers
|
|
hcc.index = index
|
|
sct = Task(self.showChanceCard)
|
|
sct.chanceCard = self.chanceCard
|
|
sct.cardSound = self.cardSound
|
|
stt = Task(self.showChanceCardText)
|
|
rewardEntry = RaceGameGlobals.ChanceRewards[reward]
|
|
stt.rewardIdx = reward
|
|
if rewardEntry[0][0] < 0 or rewardEntry[0][1] > 0:
|
|
stt.sound = self.negBuzzer
|
|
else:
|
|
stt.sound = self.posBuzzer
|
|
stt.picker = self.avIdList[index]
|
|
rct = Task(self.resetChanceCard)
|
|
task = Task.sequence(hcc, sct, Task.pause(1.0), stt, Task.pause(3.0), rct, Task.pause(0.25))
|
|
tasks.append(task)
|
|
|
|
return tasks
|
|
|
|
def showChanceCard(self, task):
|
|
base.playSfx(task.cardSound)
|
|
self.chanceCard.reparentTo(render)
|
|
quat = Quat()
|
|
quat.setHpr((270, 0, -85.24))
|
|
self.chanceCard.posQuatInterval(1.0, (19.62, 13.41, 13.14), quat, other=camera, name='cardLerp').start()
|
|
return Task.done
|
|
|
|
def hideChanceMarker(self, task):
|
|
task.chanceMarkers[task.index].reparentTo(hidden)
|
|
return Task.done
|
|
|
|
def showChanceCardText(self, task):
|
|
self.notify.debug('showing chance reward: ' + str(task.rewardIdx))
|
|
name = self.getAvatar(task.picker).getName()
|
|
rewardEntry = RaceGameGlobals.ChanceRewards[task.rewardIdx]
|
|
cardText = ''
|
|
if rewardEntry[1] != -1:
|
|
rewardstr_fmt = TTLocalizer.RaceGameCardText
|
|
if rewardEntry[2] > 0:
|
|
rewardstr_fmt = TTLocalizer.RaceGameCardTextBeans
|
|
cardText = rewardstr_fmt % {'name': name,
|
|
'reward': rewardEntry[1]}
|
|
else:
|
|
rewardstr_fmt = TTLocalizer.RaceGameCardTextHi1
|
|
cardText = rewardstr_fmt % {'name': name}
|
|
base.playSfx(task.sound)
|
|
self.chanceCardText.setText(cardText)
|
|
self.chanceCardText.show()
|
|
return Task.done
|
|
|
|
def resetChanceCard(self, task):
|
|
self.chanceCardText.hide()
|
|
self.chanceCard.reparentTo(hidden)
|
|
self.chanceCard.setPosHpr(0, 0, 0, 0, 0, 0)
|
|
return Task.done
|
|
|
|
def moveCamera(self):
|
|
bestPosIdx = list(self.avatarPositions.values())[0]
|
|
best_lane = 0
|
|
cur_lane = 0
|
|
for pos in list(self.avatarPositions.values()):
|
|
if pos > bestPosIdx:
|
|
bestPosIdx = pos
|
|
best_lane = cur_lane
|
|
cur_lane = cur_lane + 1
|
|
|
|
bestPosIdx = min(RaceGameGlobals.NumberToWin, bestPosIdx)
|
|
localToonPosition = self.avatarPositions[self.localAvId]
|
|
savedCamPos = camera.getPos()
|
|
savedCamHpr = camera.getHpr()
|
|
pos1_idx = min(RaceGameGlobals.NumberToWin - 4, localToonPosition)
|
|
pos1 = self.posHprArray[self.localAvLane][pos1_idx]
|
|
bestPosLookAtIdx = bestPosIdx + 1
|
|
localToonLookAtIdx = localToonPosition + 4
|
|
if localToonLookAtIdx >= bestPosLookAtIdx:
|
|
pos2_idx = localToonLookAtIdx
|
|
pos2_idx = min(RaceGameGlobals.NumberToWin, pos2_idx)
|
|
pos2 = self.posHprArray[self.localAvLane][pos2_idx]
|
|
else:
|
|
pos2_idx = bestPosLookAtIdx
|
|
pos2_idx = min(RaceGameGlobals.NumberToWin, pos2_idx)
|
|
pos2 = self.posHprArray[best_lane][pos2_idx]
|
|
posDeltaVecX = pos2[0] - pos1[0]
|
|
posDeltaVecY = pos2[1] - pos1[1]
|
|
DistanceMultiplier = 0.8
|
|
camposX = pos2[0] + DistanceMultiplier * posDeltaVecX
|
|
camposY = pos2[1] + DistanceMultiplier * posDeltaVecY
|
|
race_fraction = bestPosIdx / float(RaceGameGlobals.NumberToWin)
|
|
CamHeight = 10.0 * race_fraction + (1.0 - race_fraction) * 22.0
|
|
CamPos = Vec3(camposX, camposY, pos2[2] + CamHeight)
|
|
camera.setPos(CamPos)
|
|
camera_lookat_idx = min(RaceGameGlobals.NumberToWin - 6, localToonPosition)
|
|
posLookAt = self.posHprArray[self.localAvLane][camera_lookat_idx]
|
|
camera.lookAt(posLookAt[0], posLookAt[1], posLookAt[2])
|
|
CamQuat = Quat()
|
|
CamQuat.setHpr(camera.getHpr())
|
|
camera.setPos(savedCamPos)
|
|
camera.setHpr(savedCamHpr)
|
|
camera.posQuatInterval(0.75, CamPos, CamQuat).start()
|
|
|
|
def getWalkDuration(self, squares_walked):
|
|
walkDuration = abs(squares_walked / 1.2)
|
|
if squares_walked > 4:
|
|
walkDuration = walkDuration * 0.3
|
|
return walkDuration
|
|
|
|
def moveAvatars(self, task):
|
|
self.notify.debug('In moveAvatars: ')
|
|
self.notify.debug(' choiceList: ' + str(task.choiceList))
|
|
self.notify.debug(' positionList: ' + str(task.positionList))
|
|
self.notify.debug(' rewardList: ' + str(task.rewardList))
|
|
for i in range(len(self.choiceList)):
|
|
avId = self.avIdList[i]
|
|
choice = task.choiceList[i]
|
|
position = task.positionList[i]
|
|
chance = max(0, hasattr(task, 'chance'))
|
|
if choice != 0:
|
|
oldPosition = self.avatarPositions[avId]
|
|
self.avatarPositions[avId] = position
|
|
self.moveCamera()
|
|
if not chance and task.choiceList.count(choice) != 1:
|
|
self.notify.debug('duplicate choice!')
|
|
else:
|
|
avatar = self.getAvatar(avId)
|
|
if avatar:
|
|
squares_walked = abs(position - oldPosition)
|
|
if squares_walked > 4:
|
|
self.notify.debug('running')
|
|
avatar.setPlayRate(1.0, 'run')
|
|
self.runInPlace(avatar, i, oldPosition, position, self.getWalkDuration(squares_walked))
|
|
else:
|
|
if choice > 0:
|
|
self.notify.debug('walking forwards')
|
|
avatar.setPlayRate(1.0, 'walk')
|
|
else:
|
|
self.notify.debug('walking backwards')
|
|
avatar.setPlayRate(-1.0, 'walk')
|
|
self.walkInPlace(avatar, i, position, self.getWalkDuration(squares_walked))
|
|
|
|
return Task.done
|
|
|
|
def exitMoveAvatars(self):
|
|
self.notify.debug('In exitMoveAvatars: removing hooks')
|
|
taskMgr.remove('moveAvatars')
|
|
return None
|
|
|
|
def gameOverCallback(self, task):
|
|
self.gameOver()
|
|
return Task.done
|
|
|
|
def enterWinMovie(self):
|
|
self.notify.debug('enterWinMovie')
|
|
if self.localToonWon():
|
|
base.playSfx(self.winSting)
|
|
else:
|
|
base.playSfx(self.loseSting)
|
|
for avId in self.avIdList:
|
|
avPosition = self.avatarPositions[avId]
|
|
if avPosition >= RaceGameGlobals.NumberToWin:
|
|
avatar = self.getAvatar(avId)
|
|
if avatar:
|
|
lane = str(self.avIdList.index(avId))
|
|
if lane in list(self.runSeqs.keys()):
|
|
runSeq = self.runSeqs[lane]
|
|
if runSeq:
|
|
runSeq.finish()
|
|
del self.runSeqs[lane]
|
|
if lane in list(self.walkSeqs.keys()):
|
|
walkSeq = self.walkSeqs[lane]
|
|
if walkSeq:
|
|
walkSeq.finish()
|
|
del self.walkSeqs[lane]
|
|
avatar.setAnimState('jump', 1.0)
|
|
|
|
taskMgr.doMethodLater(4.0, self.gameOverCallback, 'playMovie')
|
|
|
|
def exitWinMovie(self):
|
|
taskMgr.remove('playMovie')
|
|
self.winSting.stop()
|
|
self.loseSting.stop()
|
|
|
|
def enterCleanup(self):
|
|
self.notify.debug('enterCleanup')
|
|
|
|
def exitCleanup(self):
|
|
pass
|
|
|
|
def positionInPlace(self, avatar, lane, place):
|
|
place = min(place, len(self.posHprArray[lane]) - 1)
|
|
posH = self.posHprArray[lane][place]
|
|
avatar.setPosHpr(self.raceBoard, posH[0], posH[1], posH[2], posH[3], 0, 0)
|
|
|
|
def walkInPlace(self, avatar, lane, place, time):
|
|
place = min(place, len(self.posHprArray[lane]) - 1)
|
|
posH = self.posHprArray[lane][place]
|
|
|
|
def stopWalk(raceBoard = self.raceBoard, posH = posH):
|
|
avatar.setAnimState('neutral', 1)
|
|
if raceBoard.isEmpty():
|
|
avatar.setPosHpr(0, 0, 0, 0, 0, 0)
|
|
else:
|
|
avatar.setPosHpr(raceBoard, posH[0], posH[1], posH[2], posH[3], 0, 0)
|
|
|
|
posQuat = Quat()
|
|
posQuat.setHpr((posH[3], 0, 0))
|
|
walkSeq = Sequence(Func(avatar.setAnimState, 'walk', 1),
|
|
avatar.posQuatInterval(time, (posH[0], posH[1], posH[2]), posQuat, other=self.raceBoard),
|
|
Func(stopWalk))
|
|
self.walkSeqs[str(lane)] = walkSeq
|
|
walkSeq.start()
|
|
|
|
def runInPlace(self, avatar, lane, currentPlace, newPlace, time):
|
|
place = min(newPlace, len(self.posHprArray[lane]) - 1)
|
|
step = (place - currentPlace) // 3
|
|
pos1 = self.posHprArray[lane][currentPlace + step]
|
|
pos2 = self.posHprArray[lane][currentPlace + 2 * step]
|
|
pos3 = self.posHprArray[lane][place]
|
|
|
|
def stopRun(raceBoard = self.raceBoard, pos3 = pos3):
|
|
avatar.setAnimState('neutral', 1)
|
|
avatar.setPosHpr(raceBoard, pos3[0], pos3[1], pos3[2], pos3[3], 0, 0)
|
|
|
|
pos1Quat = Quat()
|
|
pos1Quat.setHpr((pos1[3], 0, 0))
|
|
pos2Quat = Quat()
|
|
pos2Quat.setHpr((pos2[3], 0, 0))
|
|
pos3Quat = Quat()
|
|
pos3Quat.setHpr((pos3[3], 0, 0))
|
|
runSeq = Sequence(Func(avatar.setAnimState, 'run', 1),
|
|
avatar.posQuatInterval(time / 3.0, (pos1[0], pos1[1], pos1[2]), pos1Quat, other=self.raceBoard),
|
|
avatar.posQuatInterval(time / 3.0, (pos2[0], pos2[1], pos2[2]), pos2Quat, other=self.raceBoard),
|
|
avatar.posQuatInterval(time / 3.0, (pos3[0], pos3[1], pos3[2]), pos3Quat, other=self.raceBoard),
|
|
Func(stopRun))
|
|
self.runSeqs[str(lane)] = runSeq
|
|
runSeq.start()
|
|
|
|
def setAvatarChoice(self, choice):
|
|
self.notify.error('setAvatarChoice should not be called on the client')
|
|
|
|
def setAvatarChose(self, avId):
|
|
if not self.hasLocalToon:
|
|
return
|
|
self.notify.debug('setAvatarChose: avatar: ' + str(avId) + ' choose a number')
|
|
|
|
def setChancePositions(self, positions):
|
|
if not self.hasLocalToon:
|
|
return
|
|
row = 0
|
|
for pos in positions:
|
|
marker = self.chanceMarker.copyTo(render)
|
|
posHpr = self.posHprArray[row][pos]
|
|
marker.setPosHpr(self.raceBoard, posHpr[0], posHpr[1], posHpr[2], posHpr[3] + 180, 0, 0.025)
|
|
marker.setScale(0.7)
|
|
marker.setDepthOffset(1)
|
|
self.chanceMarkers.append(marker)
|
|
row += 1
|
|
|
|
def setServerChoices(self, choices, positions, rewards):
|
|
if not self.hasLocalToon:
|
|
return
|
|
for i in range(len(positions)):
|
|
if positions[i] > RaceGameGlobals.NumberToWin:
|
|
positions[i] = RaceGameGlobals.NumberToWin
|
|
if positions[i] < 0:
|
|
positions[i] = 0
|
|
|
|
self.notify.debug('setServerChoices: %s positions: %s rewards: %s ' % (choices, positions, rewards))
|
|
self.gameFSM.request('moveAvatars', [choices, positions, rewards])
|
|
|
|
def resetPositions(self):
|
|
for avId in self.avIdList:
|
|
self.avatarPositions[avId] = 0
|