789 lines
33 KiB
Python
789 lines
33 KiB
Python
from panda3d.otp import *
|
|
from .PurchaseBase import *
|
|
from direct.task.Task import Task
|
|
from toontown.toon import ToonHead
|
|
from toontown.toonbase import ToontownTimer
|
|
from direct.gui import DirectGuiGlobals as DGG
|
|
from direct.directnotify import DirectNotifyGlobal
|
|
from direct.showbase.PythonUtil import Functor
|
|
from toontown.minigame import TravelGameGlobals
|
|
from toontown.distributed import DelayDelete
|
|
from toontown.toonbase import ToontownGlobals
|
|
from . import MinigameGlobals
|
|
COUNT_UP_RATE = 0.15
|
|
COUNT_UP_DURATION = 0.5
|
|
DELAY_BEFORE_COUNT_UP = 1.0
|
|
DELAY_AFTER_COUNT_UP = 1.0
|
|
COUNT_DOWN_RATE = 0.075
|
|
COUNT_DOWN_DURATION = 0.5
|
|
DELAY_AFTER_COUNT_DOWN = 0.0
|
|
DELAY_AFTER_CELEBRATE = 2.6
|
|
COUNT_SFX_MIN_DELAY = 0.034
|
|
COUNT_SFX_START_T = 0.079
|
|
OVERMAX_SFX_MIN_DELAY = 0.067
|
|
OVERMAX_SFX_START_T = 0.021
|
|
|
|
class Purchase(PurchaseBase):
|
|
notify = DirectNotifyGlobal.directNotify.newCategory('Purchase')
|
|
|
|
def __init__(self, toon, pointsArray, playerMoney, ids, states, remain, doneEvent, metagameRound = -1, votesArray = None):
|
|
PurchaseBase.__init__(self, toon, doneEvent)
|
|
self.ids = ids
|
|
self.pointsArray = pointsArray
|
|
self.playerMoney = playerMoney
|
|
self.states = states
|
|
self.remain = remain
|
|
self.tutorialMode = 0
|
|
self.metagameRound = metagameRound
|
|
self.votesArray = votesArray
|
|
self.voteMultiplier = 1
|
|
self.fsm.addState(State.State('reward', self.enterReward, self.exitReward, ['purchase']))
|
|
doneState = self.fsm.getStateNamed('done')
|
|
doneState.addTransition('reward')
|
|
self.unexpectedEventNames = []
|
|
self.unexpectedExits = []
|
|
self.setupUnexpectedExitHooks()
|
|
|
|
def load(self):
|
|
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
|
|
PurchaseBase.load(self, purchaseModels)
|
|
interiorPhase = 3.5
|
|
self.bg = loader.loadModel('phase_%s/models/modules/toon_interior' % interiorPhase)
|
|
self.bg.setPos(0.0, 5.0, -1.0)
|
|
self.wt = self.bg.find('**/random_tc1_TI_wallpaper')
|
|
wallTex = loader.loadTexture('phase_%s/maps/wall_paper_a5.png' % interiorPhase)
|
|
self.wt.setTexture(wallTex, 100)
|
|
self.wt.setColorScale(0.8, 0.67, 0.549, 1.0)
|
|
self.bt = self.bg.find('**/random_tc1_TI_wallpaper_border')
|
|
wallTex = loader.loadTexture('phase_%s/maps/wall_paper_a5.png' % interiorPhase)
|
|
self.bt.setTexture(wallTex, 100)
|
|
self.bt.setColorScale(0.8, 0.67, 0.549, 1.0)
|
|
self.wb = self.bg.find('**/random_tc1_TI_wainscotting')
|
|
wainTex = loader.loadTexture('phase_%s/maps/wall_paper_b4.png' % interiorPhase)
|
|
self.wb.setTexture(wainTex, 100)
|
|
self.wb.setColorScale(0.473, 0.675, 0.488, 1.0)
|
|
self.playAgain = DirectButton(parent=self.frame, relief=None, scale=1.04, pos=(0.72, 0, -0.24), image=(purchaseModels.find('**/PurchScrn_BTN_UP'),
|
|
purchaseModels.find('**/PurchScrn_BTN_DN'),
|
|
purchaseModels.find('**/PurchScrn_BTN_RLVR'),
|
|
purchaseModels.find('**/PurchScrn_BTN_UP')), text=TTLocalizer.GagShopPlayAgain, text_fg=(0, 0.1, 0.7, 1), text_scale=0.05, text_pos=(0, 0.015, 0), image3_color=Vec4(0.6, 0.6, 0.6, 1), text3_fg=Vec4(0, 0, 0.4, 1), command=self.__handlePlayAgain)
|
|
self.backToPlayground = DirectButton(parent=self.frame, relief=None, scale=1.04, pos=(0.72, 0, -0.045), image=(purchaseModels.find('**/PurchScrn_BTN_UP'),
|
|
purchaseModels.find('**/PurchScrn_BTN_DN'),
|
|
purchaseModels.find('**/PurchScrn_BTN_RLVR'),
|
|
purchaseModels.find('**/PurchScrn_BTN_UP')), text=TTLocalizer.GagShopBackToPlayground, text_fg=(0, 0.1, 0.7, 1), text_scale=0.05, text_pos=(0, 0.015, 0), image3_color=Vec4(0.6, 0.6, 0.6, 1), text3_fg=Vec4(0, 0, 0.4, 1), command=self.__handleBackToPlayground)
|
|
self.timer = ToontownTimer.ToontownTimer()
|
|
self.timer.reparentTo(self.frame)
|
|
self.timer.posInTopRightCorner()
|
|
numAvs = 0
|
|
count = 0
|
|
localToonIndex = 0
|
|
for index in range(len(self.ids)):
|
|
avId = self.ids[index]
|
|
if avId == base.localAvatar.doId:
|
|
localToonIndex = index
|
|
if self.states[index] != PURCHASE_NO_CLIENT_STATE and self.states[index] != PURCHASE_DISCONNECTED_STATE:
|
|
numAvs = numAvs + 1
|
|
|
|
layoutList = (None,
|
|
(0,),
|
|
(0, 2),
|
|
(0, 1, 3),
|
|
(0, 1, 2, 3))
|
|
layout = layoutList[numAvs]
|
|
headFramePosList = (Vec3(0.105, 0, -0.384),
|
|
Vec3(0.105, 0, -0.776),
|
|
Vec3(0.85, 0, -0.555),
|
|
Vec3(-0.654, 0, -0.555))
|
|
AVID_INDEX = 0
|
|
LAYOUT_INDEX = 1
|
|
TOON_INDEX = 2
|
|
self.avInfoArray = [(base.localAvatar.doId, headFramePosList[0], localToonIndex)]
|
|
pos = 1
|
|
for index in range(len(self.ids)):
|
|
avId = self.ids[index]
|
|
if self.states[index] != PURCHASE_NO_CLIENT_STATE and self.states[index] != PURCHASE_DISCONNECTED_STATE:
|
|
if avId != base.localAvatar.doId:
|
|
if avId in base.cr.doId2do:
|
|
self.avInfoArray.append((avId, headFramePosList[layout[pos]], index))
|
|
pos = pos + 1
|
|
|
|
self.headFrames = []
|
|
for avInfo in self.avInfoArray:
|
|
av = base.cr.doId2do.get(avInfo[AVID_INDEX])
|
|
if av:
|
|
headFrame = PurchaseHeadFrame(av, purchaseModels)
|
|
headFrame.setAvatarState(self.states[avInfo[TOON_INDEX]])
|
|
headFrame.setPos(avInfo[LAYOUT_INDEX])
|
|
self.headFrames.append((avInfo[AVID_INDEX], headFrame))
|
|
|
|
purchaseModels.removeNode()
|
|
self.foreground = loader.loadModel('phase_3.5/models/modules/TT_A1')
|
|
self.foreground.setPos(12.5, -20, -5.5)
|
|
self.foreground.setHpr(180, 0, 0)
|
|
self.backgroundL = loader.loadModel('phase_3.5/models/modules/TT_A1')
|
|
self.backgroundL.setPos(-12.5, -25, -5)
|
|
self.backgroundL.setHpr(180, 0, 0)
|
|
self.backgroundR = self.backgroundL.copyTo(hidden)
|
|
self.backgroundR.setPos(20, -25, -5)
|
|
streets = loader.loadModel('phase_3.5/models/modules/street_modules')
|
|
sidewalk = streets.find('**/street_sidewalk_40x40')
|
|
self.sidewalk = sidewalk.copyTo(hidden)
|
|
self.sidewalk.setPos(-20, -25, -5.5)
|
|
self.sidewalk.setColor(0.9, 0.6, 0.4)
|
|
streets.removeNode()
|
|
doors = loader.loadModel('phase_4/models/modules/doors')
|
|
door = doors.find('**/door_single_square_ur_door')
|
|
self.door = door.copyTo(hidden)
|
|
self.door.setH(180)
|
|
self.door.setPos(0, -16.75, -5.5)
|
|
self.door.setScale(1.5, 1.5, 2.0)
|
|
self.door.setColor(1.0, 0.8, 0, 1)
|
|
doors.removeNode()
|
|
self.convertingVotesToBeansLabel = DirectLabel(text=TTLocalizer.TravelGameConvertingVotesToBeans, text_fg=VBase4(1, 1, 1, 1), relief=None, pos=(0.0, 0, -0.58), scale=0.075)
|
|
self.convertingVotesToBeansLabel.hide()
|
|
self.rewardDoubledJellybeanLabel = DirectLabel(text=TTLocalizer.PartyRewardDoubledJellybean, text_fg=(1.0, 0.125, 0.125, 1.0), text_shadow=(0, 0, 0, 1), relief=None, pos=(0.0, 0, -0.67), scale=0.08)
|
|
self.rewardDoubledJellybeanLabel.hide()
|
|
self.countSound = base.loader.loadSfx('phase_3.5/audio/sfx/tick_counter.ogg')
|
|
self.overMaxSound = base.loader.loadSfx('phase_3.5/audio/sfx/AV_collision.ogg')
|
|
self.celebrateSound = base.loader.loadSfx('phase_4/audio/sfx/MG_win.ogg')
|
|
return
|
|
|
|
def unload(self):
|
|
PurchaseBase.unload(self)
|
|
self.cleanupUnexpectedExitHooks()
|
|
self.bg.removeNode()
|
|
del self.bg
|
|
self.notify.debug('destroying head frames')
|
|
for headFrame in self.headFrames:
|
|
if not headFrame[1].isEmpty():
|
|
headFrame[1].reparentTo(hidden)
|
|
headFrame[1].destroy()
|
|
|
|
del self.headFrames
|
|
self.playAgain.destroy()
|
|
del self.playAgain
|
|
self.backToPlayground.destroy()
|
|
del self.backToPlayground
|
|
self.timer.stop()
|
|
del self.timer
|
|
for counter in self.counters:
|
|
counter.destroy()
|
|
del counter
|
|
|
|
del self.counters
|
|
for total in self.totalCounters:
|
|
total.destroy()
|
|
del total
|
|
|
|
del self.totalCounters
|
|
loader.unloadModel('phase_3.5/models/modules/TT_A1')
|
|
loader.unloadModel('phase_3.5/models/modules/street_modules')
|
|
loader.unloadModel('phase_4/models/modules/doors')
|
|
taskMgr.remove('countUpTask')
|
|
taskMgr.remove('countVotesUpTask')
|
|
taskMgr.remove('countDownTask')
|
|
taskMgr.remove('countVotesDownTask')
|
|
taskMgr.remove('celebrate')
|
|
taskMgr.remove('purchase-trans')
|
|
taskMgr.remove('delayAdd')
|
|
taskMgr.remove('delaySubtract')
|
|
self.foreground.removeNode()
|
|
del self.foreground
|
|
self.backgroundL.removeNode()
|
|
del self.backgroundL
|
|
self.backgroundR.removeNode()
|
|
del self.backgroundR
|
|
self.sidewalk.removeNode()
|
|
del self.sidewalk
|
|
self.door.removeNode()
|
|
del self.door
|
|
self.collisionFloor.removeNode()
|
|
del self.collisionFloor
|
|
del self.countSound
|
|
del self.celebrateSound
|
|
self.convertingVotesToBeansLabel.removeNode()
|
|
self.rewardDoubledJellybeanLabel.removeNode()
|
|
del self.convertingVotesToBeansLabel
|
|
del self.rewardDoubledJellybeanLabel
|
|
|
|
def showStatusText(self, text):
|
|
self.statusLabel['text'] = text
|
|
taskMgr.remove('resetStatusText')
|
|
taskMgr.doMethodLater(2.0, self.resetStatusText, 'resetStatusText')
|
|
|
|
def resetStatusText(self, task):
|
|
self.statusLabel['text'] = ''
|
|
return Task.done
|
|
|
|
def __handlePlayAgain(self):
|
|
for headFrame in self.headFrames:
|
|
headFrame[1].wrtReparentTo(aspect2d)
|
|
|
|
self.toon.inventory.reparentTo(hidden)
|
|
self.toon.inventory.hide()
|
|
taskMgr.remove('resetStatusText')
|
|
taskMgr.remove('showBrokeMsgTask')
|
|
self.statusLabel['text'] = TTLocalizer.GagShopWaitingOtherPlayers
|
|
messenger.send('purchasePlayAgain')
|
|
|
|
def handleDone(self, playAgain):
|
|
base.localAvatar.b_setParent(ToontownGlobals.SPHidden)
|
|
if playAgain:
|
|
self.doneStatus = {'loader': 'minigame',
|
|
'where': 'minigame'}
|
|
else:
|
|
self.doneStatus = {'loader': 'safeZoneLoader',
|
|
'where': 'playground'}
|
|
messenger.send(self.doneEvent)
|
|
|
|
def __handleBackToPlayground(self):
|
|
self.toon.inventory.reparentTo(hidden)
|
|
self.toon.inventory.hide()
|
|
messenger.send('purchaseBackToToontown')
|
|
|
|
def __timerExpired(self):
|
|
messenger.send('purchaseTimeout')
|
|
|
|
def findHeadFrame(self, id):
|
|
for headFrame in self.headFrames:
|
|
if headFrame[0] == id:
|
|
return headFrame[1]
|
|
|
|
return None
|
|
|
|
def __handleStateChange(self, playerStates):
|
|
self.states = playerStates
|
|
for avInfo in self.avInfoArray:
|
|
index = avInfo[2]
|
|
headFrame = self.findHeadFrame(avInfo[0])
|
|
state = self.states[index]
|
|
headFrame.setAvatarState(state)
|
|
|
|
def enter(self):
|
|
base.playMusic(self.music, looping=1, volume=0.8)
|
|
self.fsm.request('reward')
|
|
|
|
def enterReward(self):
|
|
numToons = 0
|
|
toonLayouts = ((2,),
|
|
(1, 3),
|
|
(0, 2, 4),
|
|
(0, 1, 3, 4))
|
|
toonPositions = (5.0,
|
|
1.75,
|
|
-0.25,
|
|
-1.75,
|
|
-5.0)
|
|
self.toons = []
|
|
self.toonsKeep = []
|
|
self.counters = []
|
|
self.totalCounters = []
|
|
camera.reparentTo(render)
|
|
base.camLens.setFov(ToontownGlobals.DefaultCameraFov)
|
|
camera.setPos(0, 16.0, 2.0)
|
|
camera.lookAt(0, 0, 0.75)
|
|
base.transitions.irisIn(0.4)
|
|
self.title.reparentTo(aspect2d)
|
|
self.foreground.reparentTo(render)
|
|
self.backgroundL.reparentTo(render)
|
|
self.backgroundR.reparentTo(render)
|
|
self.sidewalk.reparentTo(render)
|
|
self.door.reparentTo(render)
|
|
size = 20
|
|
z = -2.5
|
|
floor = CollisionPolygon(Point3(-size, -size, z), Point3(size, -size, z), Point3(size, size, z), Point3(-size, size, z))
|
|
floor.setTangible(1)
|
|
floorNode = CollisionNode('collision_floor')
|
|
floorNode.addSolid(floor)
|
|
self.collisionFloor = render.attachNewNode(floorNode)
|
|
NametagGlobals.setOnscreenChatForced(1)
|
|
for index in range(len(self.ids)):
|
|
avId = self.ids[index]
|
|
if self.states[index] != PURCHASE_NO_CLIENT_STATE and self.states[index] != PURCHASE_DISCONNECTED_STATE and avId in base.cr.doId2do:
|
|
numToons += 1
|
|
toon = base.cr.doId2do[avId]
|
|
toon.stopSmooth()
|
|
self.toons.append(toon)
|
|
self.toonsKeep.append(DelayDelete.DelayDelete(toon, 'Purchase.enterReward'))
|
|
counter = DirectLabel(parent=hidden, relief=None, pos=(0.0, 0.0, 0.0), text=str(0), text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0, -0.1, 0), text_font=ToontownGlobals.getSignFont())
|
|
counter['image'] = DGG.getDefaultDialogGeom()
|
|
counter['image_scale'] = (0.33, 1, 0.33)
|
|
counter.setScale(0.5)
|
|
counter.count = 0
|
|
counter.max = self.pointsArray[index]
|
|
self.counters.append(counter)
|
|
money = self.playerMoney[index]
|
|
totalCounter = DirectLabel(parent=hidden, relief=None, pos=(0.0, 0.0, 0.0), text=str(money), text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0, -0.1, 0), text_font=ToontownGlobals.getSignFont(), image=self.jarImage)
|
|
totalCounter.setScale(0.5)
|
|
totalCounter.count = money
|
|
totalCounter.max = toon.getMaxMoney()
|
|
self.totalCounters.append(totalCounter)
|
|
|
|
self.accept('clientCleanup', self._handleClientCleanup)
|
|
pos = 0
|
|
toonLayout = toonLayouts[numToons - 1]
|
|
for toon in self.toons:
|
|
thisPos = toonPositions[toonLayout[pos]]
|
|
toon.setPos(Vec3(thisPos, 1.0, -2.5))
|
|
toon.setHpr(Vec3(0, 0, 0))
|
|
toon.setAnimState('neutral', 1)
|
|
toon.setShadowHeight(0)
|
|
if not toon.isDisabled():
|
|
toon.reparentTo(render)
|
|
self.counters[pos].setPos(thisPos * -0.17, 0, toon.getHeight() / 10 + 0.25)
|
|
self.counters[pos].reparentTo(aspect2d)
|
|
self.totalCounters[pos].setPos(thisPos * -0.17, 0, -0.825)
|
|
self.totalCounters[pos].reparentTo(aspect2d)
|
|
pos += 1
|
|
|
|
self.maxPoints = max(self.pointsArray)
|
|
if self.votesArray:
|
|
self.maxVotes = max(self.votesArray)
|
|
numToons = len(self.toons)
|
|
self.voteMultiplier = TravelGameGlobals.PercentOfVotesConverted[numToons] / 100.0
|
|
self.maxBeansFromVotes = int(self.voteMultiplier * self.maxVotes)
|
|
else:
|
|
self.maxVotes = 0
|
|
self.maxBeansFromVotes = 0
|
|
|
|
def reqCountUp(state):
|
|
self.countUp()
|
|
return Task.done
|
|
|
|
countUpDelay = DELAY_BEFORE_COUNT_UP
|
|
taskMgr.doMethodLater(countUpDelay, reqCountUp, 'countUpTask')
|
|
|
|
def reqCountDown(state):
|
|
self.countDown()
|
|
return Task.done
|
|
|
|
countDownDelay = countUpDelay + COUNT_UP_DURATION + DELAY_AFTER_COUNT_UP
|
|
taskMgr.doMethodLater(countDownDelay, reqCountDown, 'countDownTask')
|
|
|
|
def celebrate(task):
|
|
for counter in task.counters:
|
|
counter.hide()
|
|
|
|
winningPoints = max(task.pointsArray)
|
|
for i in range(len(task.ids)):
|
|
if task.pointsArray[i] == winningPoints:
|
|
avId = task.ids[i]
|
|
if avId in base.cr.doId2do:
|
|
toon = base.cr.doId2do[avId]
|
|
toon.setAnimState('jump', 1.0)
|
|
|
|
base.playSfx(task.celebrateSound)
|
|
return Task.done
|
|
|
|
celebrateDelay = countDownDelay + COUNT_DOWN_DURATION + DELAY_AFTER_COUNT_DOWN
|
|
celebrateTask = taskMgr.doMethodLater(celebrateDelay, celebrate, 'celebrate')
|
|
celebrateTask.counters = self.counters
|
|
celebrateTask.pointsArray = self.pointsArray
|
|
celebrateTask.ids = self.ids
|
|
celebrateTask.celebrateSound = self.celebrateSound
|
|
|
|
def reqCountVotesUp(state):
|
|
self.countVotesUp()
|
|
return Task.done
|
|
|
|
def reqCountVotesDown(state):
|
|
self.countVotesDown()
|
|
return Task.done
|
|
|
|
if self.metagameRound == TravelGameGlobals.FinalMetagameRoundIndex:
|
|
countVotesUpDelay = celebrateDelay + DELAY_AFTER_CELEBRATE
|
|
taskMgr.doMethodLater(countVotesUpDelay, reqCountVotesUp, 'countVotesUpTask')
|
|
countVotesUpTime = self.maxVotes * COUNT_UP_RATE + DELAY_AFTER_COUNT_UP
|
|
countVotesDownDelay = countVotesUpDelay + countVotesUpTime
|
|
taskMgr.doMethodLater(countVotesDownDelay, reqCountVotesDown, 'countVotesDownTask')
|
|
celebrateDelay += countVotesUpTime + self.maxVotes * COUNT_DOWN_RATE + DELAY_AFTER_COUNT_DOWN
|
|
|
|
def reqPurchase(state):
|
|
self.fsm.request('purchase')
|
|
return Task.done
|
|
|
|
purchaseDelay = celebrateDelay + DELAY_AFTER_CELEBRATE
|
|
taskMgr.doMethodLater(purchaseDelay, reqPurchase, 'purchase-trans')
|
|
if base.skipMinigameReward:
|
|
self.fsm.request('purchase')
|
|
return
|
|
|
|
def _changeCounterUp(self, task, counter, newCount, toonId):
|
|
counter.count = newCount
|
|
counter['text'] = str(counter.count)
|
|
if toonId == base.localAvatar.doId:
|
|
now = globalClock.getRealTime()
|
|
if task.lastSfxT + COUNT_SFX_MIN_DELAY < now:
|
|
base.playSfx(task.countSound, time=COUNT_SFX_START_T)
|
|
task.lastSfxT = now
|
|
|
|
def _countUpTask(self, task):
|
|
now = globalClock.getRealTime()
|
|
startT = task.getStartTime()
|
|
if now >= startT + task.duration:
|
|
for counter, toonId in zip(self.counters, self.ids):
|
|
if counter.count != counter.max:
|
|
self._changeCounterUp(task, counter, counter.max, toonId)
|
|
|
|
return Task.done
|
|
t = (now - startT) / task.duration
|
|
for counter, toonId in zip(self.counters, self.ids):
|
|
curCount = int(triglerp(0, counter.max, t))
|
|
if curCount != counter.count:
|
|
self._changeCounterUp(task, counter, curCount, toonId)
|
|
|
|
return Task.cont
|
|
|
|
def countUp(self):
|
|
totalDelay = 0
|
|
if base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_TROLLEY_HOLIDAY) or base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_TROLLEY_HOLIDAY_MONTH):
|
|
self.rewardDoubledJellybeanLabel.show()
|
|
countUpTask = taskMgr.add(self._countUpTask, 'countUp')
|
|
countUpTask.duration = COUNT_UP_DURATION
|
|
countUpTask.countSound = self.countSound
|
|
countUpTask.lastSfxT = 0
|
|
|
|
def _changeCounterDown(self, task, counter, newCount, total, toonId):
|
|
counter.count = newCount
|
|
counter['text'] = str(counter.count)
|
|
total.count = total.startAmount + (counter.max - newCount)
|
|
if total.count > total.max:
|
|
total.count = total.max
|
|
total['text'] = str(total.count)
|
|
if total.count == total.max:
|
|
total['text_fg'] = (1, 0, 0, 1)
|
|
if toonId == base.localAvatar.doId:
|
|
now = globalClock.getRealTime()
|
|
if total.count < total.max:
|
|
minDelay = COUNT_SFX_MIN_DELAY
|
|
snd = task.countSound
|
|
startT = COUNT_SFX_START_T
|
|
else:
|
|
minDelay = OVERMAX_SFX_MIN_DELAY
|
|
snd = task.overMaxSound
|
|
startT = OVERMAX_SFX_START_T
|
|
if task.lastSfxT + minDelay < now:
|
|
task.lastSfxT = now
|
|
base.playSfx(snd, time=startT)
|
|
|
|
def _countDownTask(self, task):
|
|
now = globalClock.getRealTime()
|
|
startT = task.getStartTime()
|
|
if now >= startT + task.duration:
|
|
for counter, total, toonId in zip(self.counters, self.totalCounters, self.ids):
|
|
if counter.count != 0:
|
|
self._changeCounterDown(task, counter, 0, total, toonId)
|
|
|
|
return Task.done
|
|
t = (now - startT) / task.duration
|
|
for counter, total, toonId in zip(self.counters, self.totalCounters, self.ids):
|
|
curCount = int(triglerp(counter.max, 0, t))
|
|
if curCount != counter.count:
|
|
self._changeCounterDown(task, counter, curCount, total, toonId)
|
|
|
|
return Task.cont
|
|
|
|
def countDown(self):
|
|
totalDelay = 0
|
|
for total in self.totalCounters:
|
|
total.startAmount = total.count
|
|
|
|
countDownTask = taskMgr.add(self._countDownTask, 'countDown')
|
|
countDownTask.duration = COUNT_DOWN_DURATION
|
|
countDownTask.countSound = self.countSound
|
|
countDownTask.overMaxSound = self.overMaxSound
|
|
countDownTask.lastSfxT = 0
|
|
|
|
def countVotesUp(self):
|
|
totalDelay = 0
|
|
self.convertingVotesToBeansLabel.show()
|
|
if base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_TROLLEY_HOLIDAY) or base.cr.newsManager.isHolidayRunning(ToontownGlobals.JELLYBEAN_TROLLEY_HOLIDAY_MONTH):
|
|
self.rewardDoubledJellybeanLabel.show()
|
|
counterIndex = 0
|
|
for index in range(len(self.ids)):
|
|
avId = self.ids[index]
|
|
if self.states[index] != PURCHASE_NO_CLIENT_STATE and self.states[index] != PURCHASE_DISCONNECTED_STATE and avId in base.cr.doId2do:
|
|
self.counters[counterIndex].count = 0
|
|
self.counters[counterIndex].max = self.votesArray[index]
|
|
self.counters[counterIndex].show()
|
|
counterIndex += 1
|
|
|
|
def delayAdd(state):
|
|
state.counter.count += 1
|
|
state.counter['text'] = str(state.counter.count)
|
|
if state.toonId == base.localAvatar.doId:
|
|
base.playSfx(state.countSound)
|
|
return Task.done
|
|
|
|
for count in range(0, self.maxVotes):
|
|
for counter in self.counters:
|
|
index = self.counters.index(counter)
|
|
if count < counter.max:
|
|
addTask = taskMgr.doMethodLater(totalDelay, delayAdd, 'delayAdd')
|
|
addTask.counter = counter
|
|
addTask.toonId = self.ids[index]
|
|
addTask.countSound = self.countSound
|
|
|
|
totalDelay += COUNT_UP_RATE
|
|
|
|
def countVotesDown(self):
|
|
totalDelay = 0
|
|
|
|
def delaySubtract(state):
|
|
state.counter.count -= 1
|
|
state.counter['text'] = str(state.counter.count)
|
|
state.total.count += 1 * self.voteMultiplier
|
|
if state.total.count <= state.total.max:
|
|
state.total['text'] = str(int(state.total.count))
|
|
if state.total.count == state.total.max + 1:
|
|
state.total['text_fg'] = (1, 0, 0, 1)
|
|
if state.toonId == base.localAvatar.doId:
|
|
if state.total.count <= state.total.max:
|
|
base.playSfx(state.countSound)
|
|
else:
|
|
base.playSfx(state.overMaxSound)
|
|
return Task.done
|
|
|
|
for count in range(0, self.maxVotes):
|
|
for counter in self.counters:
|
|
if count < counter.max:
|
|
index = self.counters.index(counter)
|
|
subtractTask = taskMgr.doMethodLater(totalDelay, delaySubtract, 'delaySubtract')
|
|
subtractTask.counter = counter
|
|
subtractTask.total = self.totalCounters[index]
|
|
subtractTask.toonId = self.ids[index]
|
|
subtractTask.countSound = self.countSound
|
|
subtractTask.overMaxSound = self.overMaxSound
|
|
|
|
totalDelay += COUNT_DOWN_RATE
|
|
|
|
def exitReward(self):
|
|
self.ignore('clientCleanup')
|
|
taskMgr.remove('countUpTask')
|
|
taskMgr.remove('countVotesUpTask')
|
|
taskMgr.remove('countDownTask')
|
|
taskMgr.remove('countVotesDownTask')
|
|
taskMgr.remove('celebrate')
|
|
taskMgr.remove('purchase-trans')
|
|
taskMgr.remove('delayAdd')
|
|
taskMgr.remove('delaySubtract')
|
|
for toon in self.toons:
|
|
toon.detachNode()
|
|
|
|
del self.toons
|
|
if hasattr(self, 'toonsKeep'):
|
|
for delayDelete in self.toonsKeep:
|
|
delayDelete.destroy()
|
|
|
|
del self.toonsKeep
|
|
for counter in self.counters:
|
|
counter.reparentTo(hidden)
|
|
|
|
for total in self.totalCounters:
|
|
total.reparentTo(hidden)
|
|
|
|
self.foreground.reparentTo(hidden)
|
|
self.backgroundL.reparentTo(hidden)
|
|
self.backgroundR.reparentTo(hidden)
|
|
self.sidewalk.reparentTo(hidden)
|
|
self.door.reparentTo(hidden)
|
|
self.title.reparentTo(self.frame)
|
|
self.convertingVotesToBeansLabel.hide()
|
|
self.rewardDoubledJellybeanLabel.hide()
|
|
NametagGlobals.setOnscreenChatForced(0)
|
|
|
|
def _handleClientCleanup(self):
|
|
if hasattr(self, 'toonsKeep'):
|
|
for delayDelete in self.toonsKeep:
|
|
delayDelete.destroy()
|
|
|
|
del self.toonsKeep
|
|
self.ignore('clientCleanup')
|
|
|
|
def enterPurchase(self):
|
|
PurchaseBase.enterPurchase(self)
|
|
self.convertingVotesToBeansLabel.hide()
|
|
self.rewardDoubledJellybeanLabel.hide()
|
|
self.bg.reparentTo(render)
|
|
base.setBackgroundColor(0.05, 0.14, 0.4)
|
|
self.accept('purchaseStateChange', self.__handleStateChange)
|
|
self.playAgain.reparentTo(self.toon.inventory.purchaseFrame)
|
|
self.backToPlayground.reparentTo(self.toon.inventory.purchaseFrame)
|
|
self.pointDisplay.reparentTo(self.toon.inventory.purchaseFrame)
|
|
self.statusLabel.reparentTo(self.toon.inventory.purchaseFrame)
|
|
for headFrame in self.headFrames:
|
|
headFrame[1].show()
|
|
headFrame[1].reparentTo(self.toon.inventory.purchaseFrame)
|
|
|
|
if base.cr.periodTimerExpired:
|
|
base.cr.loginFSM.request('periodTimeout')
|
|
return
|
|
if not self.tutorialMode:
|
|
if not config.GetBool('disable-purchase-timer', 0):
|
|
self.timer.countdown(self.remain, self.__timerExpired)
|
|
if config.GetBool('metagame-disable-playAgain', 0):
|
|
if self.metagameRound > -1:
|
|
self.disablePlayAgain()
|
|
else:
|
|
self.timer.hide()
|
|
self.disablePlayAgain()
|
|
self.accept('disableGagPanel', Functor(self.toon.inventory.setActivateMode, 'gagTutDisabled', gagTutMode=1))
|
|
self.accept('disableBackToPlayground', self.disableBackToPlayground)
|
|
self.accept('enableGagPanel', self.handleEnableGagPanel)
|
|
self.accept('enableBackToPlayground', self.enableBackToPlayground)
|
|
for avId, headFrame in self.headFrames:
|
|
if avId != self.newbieId:
|
|
headFrame.hide()
|
|
|
|
messenger.send('gagScreenIsUp')
|
|
if base.autoPlayAgain or self.doMetagamePlayAgain():
|
|
base.transitions.fadeOut(0)
|
|
self.__handlePlayAgain()
|
|
|
|
def exitPurchase(self):
|
|
PurchaseBase.exitPurchase(self)
|
|
self.ignore('disableGagPanel')
|
|
self.ignore('disableBackToPlayground')
|
|
self.ignore('enableGagPanel')
|
|
self.ignore('enableBackToPlayground')
|
|
self.bg.reparentTo(hidden)
|
|
self.playAgain.reparentTo(self.frame)
|
|
self.backToPlayground.reparentTo(self.frame)
|
|
self.pointDisplay.reparentTo(self.frame)
|
|
self.statusLabel.reparentTo(self.frame)
|
|
self.ignore('purchaseStateChange')
|
|
base.setBackgroundColor(ToontownGlobals.DefaultBackgroundColor)
|
|
if base.autoPlayAgain or self.doMetagamePlayAgain():
|
|
base.transitions.fadeIn()
|
|
|
|
def disableBackToPlayground(self):
|
|
self.backToPlayground['state'] = DGG.DISABLED
|
|
|
|
def enableBackToPlayground(self):
|
|
self.backToPlayground['state'] = DGG.NORMAL
|
|
|
|
def disablePlayAgain(self):
|
|
self.playAgain['state'] = DGG.DISABLED
|
|
|
|
def enablePlayAgain(self):
|
|
self.playAgain['state'] = DGG.NORMAL
|
|
|
|
def enterTutorialMode(self, newbieId):
|
|
self.tutorialMode = 1
|
|
self.newbieId = newbieId
|
|
|
|
def handleEnableGagPanel(self):
|
|
self.toon.inventory.setActivateMode('purchase', gagTutMode=1)
|
|
self.checkForBroke()
|
|
|
|
def handleGagTutorialDone(self):
|
|
self.enableBackToPlayground()
|
|
|
|
def doMetagamePlayAgain(self):
|
|
if hasattr(self, 'metagamePlayAgainResult'):
|
|
return self.metagamePlayAgainResult
|
|
numToons = 0
|
|
for avId in self.ids:
|
|
if avId in base.cr.doId2do and avId not in self.unexpectedExits:
|
|
numToons += 1
|
|
|
|
self.metagamePlayAgainResult = False
|
|
if numToons > 1:
|
|
if self.metagameRound > -1 and self.metagameRound < TravelGameGlobals.FinalMetagameRoundIndex:
|
|
self.metagamePlayAgainResult = True
|
|
return self.metagamePlayAgainResult
|
|
|
|
def setupUnexpectedExitHooks(self):
|
|
for avId in self.ids:
|
|
if avId in base.cr.doId2do:
|
|
toon = base.cr.doId2do[avId]
|
|
eventName = toon.uniqueName('disable')
|
|
self.accept(eventName, self.__handleUnexpectedExit, extraArgs=[avId])
|
|
self.unexpectedEventNames.append(eventName)
|
|
|
|
def cleanupUnexpectedExitHooks(self):
|
|
for eventName in self.unexpectedEventNames:
|
|
self.ignore(eventName)
|
|
|
|
def __handleUnexpectedExit(self, avId):
|
|
self.unexpectedExits.append(avId)
|
|
|
|
|
|
class PurchaseHeadFrame(DirectFrame):
|
|
notify = DirectNotifyGlobal.directNotify.newCategory('Purchase')
|
|
|
|
def __init__(self, av, purchaseModels):
|
|
DirectFrame.__init__(self, relief=None, image=purchaseModels.find('**/Char_Pnl'))
|
|
self.initialiseoptions(PurchaseHeadFrame)
|
|
self.statusLabel = DirectLabel(parent=self, relief=None, text='', text_scale=TTLocalizer.PstatusLabel, text_wordwrap=7.5, text_fg=(0.05, 0.14, 0.4, 1), text_pos=(0.1, 0, 0))
|
|
self.av = av
|
|
self.avKeep = DelayDelete.DelayDelete(av, 'PurchaseHeadFrame.av')
|
|
self.accept('clientCleanup', self._handleClientCleanup)
|
|
self.head = self.stateNodePath[0].attachNewNode('head', 20)
|
|
self.head.setPosHprScale(-0.22, 10.0, -0.1, 180.0, 0.0, 0.0, 0.1, 0.1, 0.1)
|
|
self.headModel = ToonHead.ToonHead()
|
|
self.headModel.setupHead(self.av.style, forGui=1)
|
|
self.headModel.reparentTo(self.head)
|
|
self.tag2Node = NametagFloat2d()
|
|
self.tag2Node.setContents(Nametag.CName)
|
|
self.av.nametag.addNametag(self.tag2Node)
|
|
self.tag2 = self.attachNewNode(self.tag2Node.upcastToPandaNode())
|
|
self.tag2.setPosHprScale(-0.22, 10.0, 0.12, 0, 0, 0, 0.046, 0.046, 0.046)
|
|
self.tag1Node = NametagFloat2d()
|
|
self.tag1Node.setContents(Nametag.CSpeech | Nametag.CThought)
|
|
self.av.nametag.addNametag(self.tag1Node)
|
|
self.tag1 = self.attachNewNode(self.tag1Node.upcastToPandaNode())
|
|
self.tag1.setPosHprScale(-0.15, 0, -0.1, 0, 0, 0, 0.046, 0.046, 0.046)
|
|
self.hide()
|
|
return
|
|
|
|
def destroy(self):
|
|
DirectFrame.destroy(self)
|
|
del self.statusLabel
|
|
self.headModel.delete()
|
|
del self.headModel
|
|
self.head.removeNode()
|
|
del self.head
|
|
self.av.nametag.removeNametag(self.tag1Node)
|
|
self.av.nametag.removeNametag(self.tag2Node)
|
|
self.tag1.removeNode()
|
|
self.tag2.removeNode()
|
|
del self.tag1
|
|
del self.tag2
|
|
del self.tag1Node
|
|
del self.tag2Node
|
|
del self.av
|
|
self.removeAvKeep()
|
|
|
|
def setAvatarState(self, state):
|
|
if state == PURCHASE_DISCONNECTED_STATE:
|
|
self.statusLabel['text'] = TTLocalizer.GagShopPlayerDisconnected % self.av.getName()
|
|
self.statusLabel['text_pos'] = (0.015, 0.072, 0)
|
|
self.head.hide()
|
|
self.tag1.hide()
|
|
self.tag2.hide()
|
|
elif state == PURCHASE_EXIT_STATE:
|
|
self.statusLabel['text'] = TTLocalizer.GagShopPlayerExited % self.av.getName()
|
|
self.statusLabel['text_pos'] = (0.015, 0.072, 0)
|
|
self.head.hide()
|
|
self.tag1.hide()
|
|
self.tag2.hide()
|
|
elif state == PURCHASE_PLAYAGAIN_STATE:
|
|
self.statusLabel['text'] = TTLocalizer.GagShopPlayerPlayAgain
|
|
self.statusLabel['text_pos'] = (0.1, -0.12, 0)
|
|
elif state == PURCHASE_WAITING_STATE:
|
|
self.statusLabel['text'] = TTLocalizer.GagShopPlayerBuying
|
|
self.statusLabel['text_pos'] = (0.1, -0.12, 0)
|
|
elif state == PURCHASE_NO_CLIENT_STATE:
|
|
Purchase.notify.warning("setAvatarState('no client state'); OK for gag purchase tutorial")
|
|
else:
|
|
Purchase.notify.warning('unknown avatar state: %s' % state)
|
|
|
|
def _handleClientCleanup(self):
|
|
self.destroy()
|
|
|
|
def removeAvKeep(self):
|
|
if hasattr(self, 'avKeep'):
|
|
self.notify.debug('destroying avKeep %s' % self.avKeep)
|
|
self.avKeep.destroy()
|
|
del self.avKeep
|
|
self.ignore('clientCleanup')
|