def startConclusion(self):
DistributedPartyCatchActivity.notify.debug('startConclusion')
for avId in self.toonIds:
if avId in self.toonSDs:
toonSD = self.toonSDs[avId]
toonSD.fsm.request('notPlaying')
self.destroyCatchCollisions()
if base.localAvatar.doId not in self.toonIds:
return
else:
self.localToonExiting()
if self.fruitsCaught >= self.numFruits:
finishText = TTLocalizer.PartyCatchActivityFinishPerfect
else:
finishText = TTLocalizer.PartyCatchActivityFinish
perfectTextSubnode = hidden.attachNewNode(self.__genText(finishText))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')), Func(destroyText),
WaitInterval(0.5))
soundTrack = SoundInterval(self.sndPerfect)
self.finishIval = Parallel(textTrack, soundTrack)
self.finishIval.start()
def turnDown(self, doInterval=DoIntervalDefault):
self.faceUp = 0
if doInterval:
self.clearFlipIval()
self.flipIval = Parallel(
LerpHprInterval(self, self.FlipTime, Vec3(0, 0, 180)),
SoundInterval(self.turnDownSound,
node=self,
listenerNode=base.localAvatar,
cutOff=240))
self.flipIval.start()
else:
self.setR(180)
def handleMatch(self, cardA, cardB, withBonus):
self.notify.debug('we got a match %d %d' % (cardA, cardB))
self.matches += 1
if cardA in self.faceUpList:
self.faceUpList.remove(cardA)
if cardB in self.faceUpList:
self.faceUpList.remove(cardB)
self.inactiveList.append(cardA)
self.inactiveList.append(cardB)
matchIval = Parallel()
for card in [cardA, cardB]:
self.cards[card].setTransparency(1)
cardSeq = Sequence(
LerpColorScaleInterval(self.cards[card],
duration=1,
colorScale=Vec4(1.0, 1.0, 1.0, 0.0)),
Func(self.cards[card].hide))
matchIval.append(cardSeq)
if withBonus:
matchIval.append(
SoundInterval(self.matchWithBonusSfx,
node=self.cards[card],
listenerNode=base.localAvatar,
cutOff=240))
else:
matchIval.append(
SoundInterval(self.matchSfx,
node=self.cards[card],
listenerNode=base.localAvatar,
cutOff=240))
matchIval.start()
# report we're done if all cards are matched
if len(self.inactiveList) == len(self.cards):
self.sendUpdate('reportDone')
def buildTracks(self, mode=0):
if not self.avatar:
return
self.cleanupTracks()
if mode == 0:
self.actorTrack = Sequence(
self.getAnimationTrack(self.buttonAnim,
startFrame=self.hitStartFrame,
endFrame=self.completeFrame,
playRate=self.playRate))
self.soundTrack = Sequence(
Wait(self.buttonHold),
SoundInterval(self.buttonSfx, node=self.avatar))
def setEntityState(self, state):
DistributedEntity.setEntityState(self, state)
self.clearSequence()
if state == self.StateEmpty:
self.setColorScale(0.5, 0.5, 0.5, 1.0)
self.playSound('empty')
self.stopSound('start')
self.stopSound('giveLaff')
elif state == self.StateAvailable:
self.setColorScale(1, 1, 1, 1)
elif state == self.StateGiving:
self.setSequence(
Sequence(
SoundInterval(self.getSound('start'),
duration=self.getSound('start').length() /
2.0),
Func(
self.setSequence,
SoundInterval(
self.getSound('giveLaff'),
duration=self.getSound('giveLaff').length() / 4.0),
True)))
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.ogg')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(Func(splat.reparentTo, render), Func(splat.setPos, x, y, z), soundIval, Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def enterFlyAway(self, ts=0, doFadeOut=0):
self.show()
if not self.propeller:
self.generatePropeller()
sfx = self.propellerSounds['out']
if hasattr(self, 'uniqueName'):
name = self.uniqueName('enterFlyAway')
else:
name = 'enterFlyAway'
dur = self.getDuration('land')
actInt = ActorInterval(self,
'land',
loop=0,
startTime=dur,
endTime=0.0)
lastSpinFrame = 8
propDur = self.propeller.getDuration('chan')
fr = self.propeller.getFrameRate('chan')
spinTime = lastSpinFrame / fr
openTime = (lastSpinFrame + 1) / fr
propTrack = Parallel(
SoundInterval(sfx, node=self),
Sequence(
Func(self.propeller.show),
ActorInterval(self.propeller,
'chan',
endTime=openTime,
startTime=propDur),
ActorInterval(self.propeller,
'chan',
constrainedLoop=1,
duration=propDur - openTime,
startTime=spinTime,
endTime=0.0)))
self.suitTrack = Parallel(actInt,
propTrack,
name=self.taskName('trackName'))
if doFadeOut:
fadeOut = Sequence(
Wait(4.0), Func(self.setTransparency, 1),
self.colorScaleInterval(1,
colorScale=VBase4(1, 1, 1, 0),
startColorScale=VBase4(1, 1, 1, 1)),
Func(self.clearColorScale), Func(self.clearTransparency),
Func(self.reparentTo, hidden))
self.suitTrack.append(fadeOut)
self.suitTrack.setDoneEvent(self.suitTrack.getName())
self.acceptOnce(self.suitTrack.getDoneEvent(), self.exitFlyAway)
self.suitTrack.delayDelete = DelayDelete.DelayDelete(self, name)
self.suitTrack.start(ts)
self.disableRay()
def createDinerMoveIval(self, suit, destPos, chairInfo):
dur = suit.getDuration('landing')
fr = suit.getFrameRate('landing')
landingDur = dur
totalDur = 7.2999999999999998
animTimeInAir = totalDur - dur
flyingDur = animTimeInAir
impactLength = dur - animTimeInAir
tableIndex = chairInfo[0]
chairIndex = chairInfo[1]
table = self.bossCog.tables[tableIndex]
chairLocator = table.chairLocators[chairIndex]
chairPos = chairLocator.getPos(self)
chairHpr = chairLocator.getHpr(self)
suit.setPos(chairPos)
table.setDinerStatus(chairIndex, table.HIDDEN)
suit.setHpr(chairHpr)
wayPoint = (chairPos + destPos) / 2.0
wayPoint.setZ(wayPoint.getZ() + 20)
moveIval = Sequence(
Func(suit.headsUp, self), Func(suit.pose, 'landing', 0),
ProjectileInterval(suit,
duration=flyingDur,
startPos=chairPos,
endPos=destPos,
gravityMult=0.25),
ActorInterval(suit, 'landing'))
if suit.prop == None:
suit.prop = BattleProps.globalPropPool.getProp('propeller')
propDur = suit.prop.getDuration('propeller')
lastSpinFrame = 8
fr = suit.prop.getFrameRate('propeller')
spinTime = lastSpinFrame / fr
openTime = (lastSpinFrame + 1) / fr
suit.attachPropeller()
propTrack = Parallel(
SoundInterval(suit.propInSound, duration=flyingDur, node=suit),
Sequence(
ActorInterval(suit.prop,
'propeller',
constrainedLoop=1,
duration=flyingDur + 1,
startTime=0.0,
endTime=spinTime),
ActorInterval(suit.prop,
'propeller',
duration=landingDur,
startTime=openTime), Func(suit.detachPropeller)))
result = Parallel(moveIval, propTrack)
return result
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
elif numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {'num': numBarrelsSaved}
elif numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {'num': numBarrelsSaved}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text = perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text = perfectText):
text.removeNode()
def safeGameOver(self = self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(Func(perfectText.reparentTo, aspect2d), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=0.3, startScale=0.0), LerpFunctionInterval(fadeFunc, fromData=0.0, toData=1.0, duration=0.5)), Wait(2.0), Parallel(LerpScaleInterval(perfectText, duration=0.5, scale=1.0), LerpFunctionInterval(fadeFunc, fromData=1.0, toData=0.0, duration=0.5, blendType='easeIn')), Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
#For the Alpha Blueprint ARG
if config.GetBool('want-blueprint4-ARG', False):
MinigameGlobals.generateDebugARGPhrase()
def loadAssets(self):
self.beltModel = NodePath('beltModel')
self.beltModel.reparentTo(self.boss.geom)
self.startLocator = self.boss.geom.find('**/conveyer_belt_start_%d' %
(self.index + 1))
self.endLocator = self.boss.geom.find('**/conveyer_belt_end_%d' %
(self.index + 1))
center = (self.startLocator.getPos() + self.endLocator.getPos()) / 2.0
self.beltHeight = center.getZ()
self.beltHeight += 0.1
center.setZ(0)
self.beltLength = (self.endLocator.getPos() -
self.startLocator.getPos()).length()
self.distBetweenFoodNodes = self.beltLength / self.NumFoodNodes
self.notify.debug('setting beltModelPos to %s' % center)
self.beltModel.setPos(center)
self.setupFoodNodes()
self.setupFoodIvals()
self.setupToonupIvals()
if self.index == 0:
self.beltActorModel = loader.loadModel(
'phase_12/models/bossbotHQ/food_belt1_model')
else:
self.beltActorModel = loader.loadModel(
'phase_12/models/bossbotHQ/food_belt2_model')
if self.beltActorModel:
self.beltActor = Actor.Actor(self.beltActorModel)
if self.index == 0:
self.beltActor.loadAnims(
{'idle': 'phase_12/models/bossbotHQ/food_belt1'})
else:
self.beltActor.loadAnims(
{'idle': 'phase_12/models/bossbotHQ/food_belt2'})
self.beltActor.setBlend(
frameBlend=config.GetBool('interpolate-animations', True))
self.beltActor.reparentTo(render)
self.beltActor.setPlayRate(self.BeltActorPlayRate, 'idle')
mesh = self.beltActor.find('**/mesh_tide1')
joint = self.beltActor.find('**/uvj_WakeWhiteTide1')
mesh.setTexProjector(mesh.findTextureStage('default'), joint,
self.beltActor)
self.beltActor.setPos(self.startLocator.getPos())
self.beltSound = base.loader.loadSfx(
'phase_12/audio/sfx/CHQ_FACT_conveyor_belt.ogg')
self.beltSound.setLoop(1)
self.beltSoundInterval = SoundInterval(self.beltSound,
node=self.beltModel,
listenerNode=base.localAvatar,
seamlessLoop=True,
volume=0.25,
cutOff=100)
def enterDie(self, ts = 0):
self.show()
self.clearStunnedIval()
self.generateCog(isLose = 1)
self.nametag.clearChatText()
self.deleteNameTag()
self.deathSound = base.audio3d.loadSfx("phase_3.5/audio/sfx/Cog_Death_Full.ogg")
base.audio3d.attachSoundToObject(self.deathSound, self)
trackName = self.uniqueName('enterDie')
smallGears = ParticleLoader.loadParticleEffect('phase_3.5/etc/gearExplosionSmall.ptf')
smallGears.getParticlesNamed('particles-1').setPoolSize(30)
smallGears.setShaderOff(1)
singleGear = ParticleLoader.loadParticleEffect('phase_3.5/etc/gearExplosion.ptf')
singleGear.getParticlesNamed('particles-1').setPoolSize(1)
singleGear.setShaderOff(1)
smallGearExplosion = ParticleLoader.loadParticleEffect('phase_3.5/etc/gearExplosion.ptf')
smallGearExplosion.getParticlesNamed('particles-1').setPoolSize(10)
smallGearExplosion.setShaderOff(1)
bigGearExplosion = ParticleLoader.loadParticleEffect('phase_3.5/etc/gearExplosionBig.ptf')
bigGearExplosion.getParticlesNamed('particles-1').setPoolSize(30)
bigGearExplosion.setShaderOff(1)
smallGears.setDepthWrite(False)
smallGears.hide(CIGlobals.ShadowCameraBitmask)
singleGear.setDepthWrite(False)
singleGear.hide(CIGlobals.ShadowCameraBitmask)
smallGearExplosion.setDepthWrite(False)
smallGearExplosion.hide(CIGlobals.ShadowCameraBitmask)
bigGearExplosion.setDepthWrite(False)
bigGearExplosion.hide(CIGlobals.ShadowCameraBitmask)
self.smallGears = smallGears
self.smallGears.setPos(self.find('**/joint_head').getPos() + (0,0, 2))
self.singleGear = singleGear
self.smallGearExp = smallGearExplosion
self.bigGearExp = bigGearExplosion
gearTrack = Sequence(Wait(0.7), Func(self.doSingleGear), Wait(1.5), Func(self.doSmallGears), Wait(3.0), Func(self.doBigExp))
self.suitTrack = Parallel(Sequence(Wait(0.8), SoundInterval(self.deathSound, duration = 4.28)),
Sequence(Wait(0.7), Func(self.doSingleGear), Wait(4.5),
Func(self.suitExplode), Wait(1.0), Func(self.disableBodyCollisions)), gearTrack,
Sequence(ActorInterval(self, 'lose', duration = 6), Func(self.getGeomNode().hide)), name = trackName)
self.suitTrack.setDoneEvent(self.suitTrack.getName())
self.acceptOnce(self.suitTrack.getName(), self.exitDie)
if self.isDistributed():
self.suitTrack.delayDelete = DelayDelete.DelayDelete(self, trackName)
self.suitTrack.start(ts)
def start(self):
SoundGag.start(self)
tracks = Parallel()
INSTRUMENT_SCALE_MODIFIER = 0.5
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax1 = Vec3(0.3, 0.4, 0.2)
instrMax1 *= INSTRUMENT_SCALE_MODIFIER
instrMax2 = Vec3(0.3, 0.3, 0.3)
instrMax2 *= INSTRUMENT_SCALE_MODIFIER
instrStretch1 = Vec3(0.3, 0.5, 0.25)
instrStretch1 *= INSTRUMENT_SCALE_MODIFIER
instrStretch2 = Vec3(0.3, 0.7, 0.3)
instrStretch2 *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-0.6, -0.9, 0.15)
self.gag.setHpr(145, 0, 85)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(Func(self.placeProp, self.handJoint, self.megaphone), Func(self.placeProp, self.handJoint, self.gag), Func(setInstrumentStats))
grow1 = self.getScaleIntervals(self.gag, duration=0.3, startScale=instrMin, endScale=instrMax1)
grow2 = self.getScaleIntervals(self.gag, duration=0.3, startScale=instrMax1, endScale=instrMax2)
instrumentAppear = Parallel(Sequence(grow1, grow2))
stretchInstr1 = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrMax2, endScale=instrStretch1, blendType='easeOut')
stretchInstr2 = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrStretch1, endScale=instrStretch2, blendType='easeOut')
stretchInstr = Sequence(stretchInstr1, stretchInstr2)
backInstr = self.getScaleBlendIntervals(self.gag, duration=0.1, startScale=instrStretch2, endScale=instrMax2, blendType='easeOut')
attackTrack = Sequence(stretchInstr, Wait(1), backInstr)
delayTime = 2.45
delayUntilAppearSound = 1.0
megaphoneTrack = Sequence(megaphoneShow, Wait(delayUntilAppearSound), SoundInterval(self.appearSfx, node=self.avatar), Wait(delayTime + 1.0), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
instrumentshrink = self.getScaleIntervals(self.gag, duration=0.1, startScale=instrMax2, endScale=instrMin)
soundTrack = Sequence(Wait(delayTime), Parallel(attackTrack, SoundInterval(self.soundSfx, node=self.avatar), Sequence(Wait(1.5), instrumentshrink), Func(self.damageCogsNearby), Wait(0.4), Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
self.tracks = tracks
def __getShovelAppearInterval(self, shovel, avatar):
# Must pass the shovel and the avatar using the shovel.
return Parallel(
Sequence(
Func(shovel.reparentTo,
avatar.find('**/def_joint_right_hold')),
ShowInterval(shovel),
SoundInterval(self.shovelAppearSfx, node=avatar,
duration=1.0)),
LerpScaleInterval(shovel,
duration=SHOVEL_APPEAR_TIME,
scale=(1.0, 1.0, 1.0),
startScale=0.01,
blendType='easeOut'))
def fireWater(self, origin, target):
color = VBase4(0.75, 0.75, 1, 0.8)
dScaleUp = 0.1
dHold = 0.3
dScaleDown = 0.1
horizScale = 0.1
vertScale = 0.1
sprayTrack = self.getSprayTrack(color, origin, target, dScaleUp, dHold, dScaleDown, horizScale, vertScale)
duration = self.squirtSfx.length()
if sprayTrack.getDuration() < duration:
duration = sprayTrack.getDuration()
soundTrack = SoundInterval(self.squirtSfx, node=self.waterPitcherModel, duration=duration)
self.fireTrack = Parallel(sprayTrack, soundTrack)
self.fireTrack.start()
def onSetAction(self, action):
self.model.show()
self.model.setPos(self.ModelOrigin)
self.model.setHpr(self.ModelAngles)
self.model.setLightOff()
self.avatar.doingActivity = False
if action == self.StateAttack:
self.avatar.doingActivity = True
joint = self.model.find('**/joint_toSpray')
def positionAndOrientSpray():
self.sprayMdl.setPos(joint.getPos(render))
self.sprayMdl.setHpr(joint.getHpr(render))
self.setAnimTrack(Parallel(
self.getAnimationTrack('watercooler', fullBody=False),
Sequence(
Wait(1.01), Func(self.model.show),
LerpScaleInterval(self.model, 0.5,
Point3(1.15, 1.15, 1.15)), Wait(1.6),
Func(self.sprayMdl.show),
Func(self.sprayMdl.reparentTo, render),
Func(positionAndOrientSpray),
LerpScaleInterval(self.sprayMdl,
duration=0.3,
scale=(1.0, 15.0, 1.0),
startScale=(1.0, 1.0, 1.0)),
Func(self.sprayMdl.hide),
Func(self.sprayMdl.reparentTo, hidden)),
Sequence(Wait(1.1),
SoundInterval(self.coolerAppearSfx, duration=1.4722),
Wait(0.4),
SoundInterval(self.sprayOnlySfx, duration=2.313))),
startNow=True)
def enterShoot(self, target=None):
if not target:
target = base.localAvatar
self.pose("collapse", 1)
self.shootTrack = Sequence(
Parallel(
Sequence(
LerpFunc(self.blendAnimFromBase,
fromData=0,
toData=1,
duration=0.25,
extraArgs=['collapse']),
ActorInterval(self,
"collapse",
startFrame=1,
endFrame=5,
playRate=0.8),
ActorInterval(self,
"collapse",
startFrame=5,
endFrame=22,
playRate=0.7),
ActorInterval(self,
"collapse",
startFrame=22,
endFrame=5,
playRate=0.7),
LerpFunc(self.blendAnimFromBase,
fromData=1,
toData=0,
duration=0.25,
extraArgs=['collapse'])),
Sequence(Wait(0.1), SoundInterval(self.whipSound, node=self)),
Sequence(Wait(0.55), SoundInterval(self.shootSound,
node=self)),
Sequence(Wait(0.635), Func(self.fireLaser, target))))
self.shootTrack.start()
def loadAssets(self):
"""Load and setup the assets for the food belt."""
# later on this will become a loadModel call
self.beltModel = NodePath('beltModel')
self.beltModel.reparentTo(self.boss.geom)
self.startLocator = self.boss.geom.find(
'**/conveyer_belt_start_%d' % (self.index+1))
self.endLocator = self.boss.geom.find('**/conveyer_belt_end_%d' % (self.index+1))
center = (self.startLocator.getPos() + self.endLocator.getPos())/2.0
self.beltHeight = center.getZ()
self.beltHeight += 0.1
center.setZ(0)
self.beltLength = (self.endLocator.getPos() - self.startLocator.getPos()).length()
self.distBetweenFoodNodes = self.beltLength / self.NumFoodNodes
self.notify.debug('setting beltModelPos to %s' % center)
self.beltModel.setPos(center)
self.setupFoodNodes()
self.setupFoodIvals()
self.setupToonupIvals()
if self.index == 0:
self.beltActorModel = loader.loadModel("phase_12/models/bossbotHQ/food_belt1_model")
else:
self.beltActorModel = loader.loadModel("phase_12/models/bossbotHQ/food_belt2_model")
if (self.beltActorModel):
self.beltActor = Actor.Actor(self.beltActorModel)
if self.index == 0:
self.beltActor.loadAnims({'idle': "phase_12/models/bossbotHQ/food_belt1"})
else:
self.beltActor.loadAnims({'idle': "phase_12/models/bossbotHQ/food_belt2"})
self.beltActor.reparentTo(render)
# adjust this number as necessary to match up with the food intervals
self.beltActor.setPlayRate(self.BeltActorPlayRate, 'idle')
#self.beltActor.loop('idle')
# 1st uv animation
mesh = self.beltActor.find('**/mesh_tide1')
joint = self.beltActor.find('**/uvj_WakeWhiteTide1')
mesh.setTexProjector(mesh.findTextureStage('default'), joint, self.beltActor)
self.beltActor.setPos(self.startLocator.getPos())
self.beltSound = base.loader.loadSfx("phase_12/audio/sfx/CHQ_FACT_conveyor_belt.wav")
self.beltSound.setLoop(1)
self.beltSoundInterval = SoundInterval(self.beltSound, node=self.beltModel,
listenerNode = base.localAvatar,
seamlessLoop = True,
volume = 0.25,
cutOff = 100)
def exitDoorEnterOpening(self, ts):
bldgActor = self.getBuildingActor()
leftDoor = bldgActor.controlJoint(None, 'modelRoot', 'def_left_door')
if self.leftSwing:
h = -100
else:
h = 100
if not leftDoor.isEmpty():
otherNP = self.getDoorNodePath()
trackName = 'doorDoorExitTrack-%d' % self.doId
self.finishDoorExitTrack()
self.doorExitTrack = Parallel(SoundInterval(self.openSfx, node=leftDoor), Sequence(LerpHprInterval(nodePath=leftDoor, duration=0.6, hpr=VBase3(h, 0, 0), startHpr=VBase3(0, 0, 0), blendType='easeInOut')), name=trackName)
self.doorExitTrack.start(ts)
else:
self.notify.warning('exitDoorEnterOpening(): did not find leftDoor')
def emitSound(soundPath, pos, volume=1.0, other=None):
if isinstance(soundPath, list) or isinstance(soundPath, tuple):
if len(soundPath) == 0:
return
import random
soundPath = random.choice(soundPath)
from direct.interval.IntervalGlobal import Sequence, SoundInterval, Func
if not other:
other = render
soundNode = render.attachNewNode("sound")
soundNode.setPos(other, pos)
sound = base.loadSfxOnNode(soundPath, soundNode)
Sequence(SoundInterval(sound, volume=volume),
Func(base.audio3d.detachSound, sound),
Func(soundNode.removeNode)).start()
def enterWestToEast(self, ts=0):
moPath = Mopath.Mopath()
moPath.loadFile(self.westEast)
moIval = MopathInterval(moPath, self.boat)
self.track = Parallel(
SoundInterval(self.soundShipBell, node=self.boat),
SoundInterval(self.soundDockCreak, node=self.westPier), moIval,
LerpQuatInterval(self.westPier,
duration=5.0,
quat=(-90, self.pierDownP, 0),
startHpr=(-90, self.pierUpP, 0)),
Sequence(
Wait(15.0),
Parallel(
LerpQuatInterval(self.eastPier,
duration=5.0,
quat=(90, self.pierUpP, 0),
startHpr=(90, self.pierDownP, 0)),
Sequence(
Wait(2.0),
SoundInterval(self.soundDockCreak,
node=self.eastPier))),
SoundInterval(self.soundFogHorn, node=self.boat)))
self.track.start(ts)
def enterOpening(self, ts):
bldgActor = self.getBuildingActor()
rightDoor = bldgActor.controlJoint(None, 'modelRoot', 'def_right_door')
if rightDoor.isEmpty():
self.notify.warning('enterOpening(): did not find rightDoor')
return
otherNP = self.getDoorNodePath()
trackName = 'doorOpen-%d' % self.doId
if self.rightSwing:
h = 100
else:
h = -100
self.finishDoorTrack()
self.doorTrack = Parallel(SoundInterval(self.openSfx, node=rightDoor), Sequence(HprInterval(rightDoor, VBase3(0, 0, 0)), Wait(0.4), LerpHprInterval(nodePath=rightDoor, duration=0.6, hpr=VBase3(h, 0, 0), startHpr=VBase3(0, 0, 0), blendType='easeInOut')), name=trackName)
self.doorTrack.start(ts)
def buildTracks(self):
if not self.avatar:
return
self.cleanupTracks()
self.actorTrack = Sequence(
ActorInterval(self.avatar,
self.buttonAnim,
startFrame=self.chooseLocFrame,
endFrame=self.completeFrame,
playRate=self.playRate))
self.soundTrack = Sequence(
Wait(self.buttonHold),
SoundInterval(self.buttonSfx, node=self.avatar))
self.actorTrack.start()
self.soundTrack.start()
def enterLeftDoorOpening(self, ts=0):
if self.leftTrack:
self.leftTrack.finish()
self.leftTrack = None
self.leftTrack = Sequence(
Wait(0.5),
Parallel(
Func(self.toggleDoorHole, 'left', True),
LerpQuatInterval(self.leftDoor,
duration=0.7,
quat=(self.getLeftDoorOpenH(), 0, 0),
startHpr=(self.getLeftDoorClosedH(), 0, 0),
blendType='easeInOut'),
SoundInterval(self.doorOpenSound, node=self.leftDoor)))
self.leftTrack.start()
def onCollision(self, entry):
if not self.gag:
return
intoNP = entry.getIntoNodePath()
avNP = intoNP.getParent()
hitCog = False
self.fallSoundInterval.pause()
self.fallSoundInterval = None
shrinkTrack = Sequence()
if self.avatar.doId == base.localAvatar.doId:
for key in base.cr.doId2do.keys():
obj = base.cr.doId2do[key]
if obj.__class__.__name__ in CIGlobals.SuitClasses:
if obj.getKey() == avNP.getKey():
obj.sendUpdate('hitByGag', [self.getID()])
self.avatar.b_trapActivate(self.getID(),
self.avatar.doId, 0,
obj.doId)
hitCog = True
gagObj = self.gag
if hitCog:
SoundInterval(self.hitSfx, node=self.gag).start()
shrinkTrack.append(Wait(0.5))
else:
SoundInterval(self.missSfx, node=self.gag).start()
shrinkTrack.append(Wait(0.25))
shrinkTrack.append(
LerpScaleInterval(self.gag,
0.3,
Point3(0.01, 0.01, 0.01),
startScale=self.gag.getScale()))
shrinkTrack.append(Func(gagObj.removeNode))
shrinkTrack.append(Func(self.cleanupGag))
shrinkTrack.start()
return
def showGrab(self):
self.nodePath.hide()
self.collNodePath.hide()
self.collNode.setIntoCollideMask(BitMask32(0))
if self.penalty:
self.track = Parallel(
SoundInterval(self.penaltyGrabSound),
Sequence(
Func(self.kaboom.showThrough),
LerpScaleInterval(self.kaboom,
duration=0.5,
scale=Point3(10, 10, 10),
blendType='easeOut'),
Func(self.kaboom.hide)))
self.track.start()
def loadAssets(self):
self.tableGroup = loader.loadModel('phase_12/models/bossbotHQ/BanquetTableChairs')
tableLocator = self.boss.geom.find('**/TableLocator_%d' % (self.index + 1))
if tableLocator.isEmpty():
self.tableGroup.reparentTo(render)
self.tableGroup.setPos(0, 75, 0)
else:
self.tableGroup.reparentTo(tableLocator)
self.tableGeom = self.tableGroup.find('**/Geometry')
self.setupDiners()
self.setupChairCols()
self.squirtSfx = loader.loadSfx('phase_4/audio/sfx/AA_squirt_seltzer_miss.ogg')
self.hitBossSfx = loader.loadSfx('phase_5/audio/sfx/SA_watercooler_spray_only.ogg')
self.hitBossSoundInterval = SoundInterval(self.hitBossSfx, node=self.boss, volume=1.0)
self.serveFoodSfx = loader.loadSfx('phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.ogg')
self.pitcherMoveSfx = base.loader.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg')
def __tickNearbyCogs(self):
self.__selectNearbyCogs()
tickTrack = Parallel()
tickDuration = 0.4
for cog in self.selectedCogs:
if not cog.isDead():
base.audio3d.attachSoundToObject(self.tickSfx, cog)
tickTrack.append(Parallel(Sequence(
LerpColorScaleInterval(cog, tickDuration, VBase4(1, 0, 0, 1)),
Func(cog.clearColorScale),
Func(cog.d_disableMovement)
), SoundInterval(self.tickSfx, duration = tickDuration, node = cog)))
else:
self.selectedCogs.remove(cog)
return tickTrack
def showSplat(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.suit.getPos())
self.splat.setZ(3)
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound, volume=1.0),
Sequence(
Func(self.splat.showThrough),
LerpScaleInterval(self.splat,
duration=0.5,
scale=1.75,
startScale=Point3(0.1, 0.1, 0.1),
blendType='easeOut'), Func(self.splat.hide)))
self.kaboomTrack.start()
def startEntity(self):
if self.entityTrack:
self.entityTrack.pause()
self.entityTrack = None
if self.getLocation():
x, y, z = self.getLocation()
self.gag.setPos(x, y, z - 0.45)
if not self.gag:
self.build()
self.gag.setScale(GagGlobals.PNT3NEAR0)
self.gag.reparentTo(render)
LerpScaleInterval(self.gag, 1.2, Point3(1.7, 1.7, 1.7)).start()
track = Sequence(Wait(0.7))
if self.isSafeLocation(self.gag):
self.entities.append(self.gag)
# Let's suck the closest suit into our trap.
suits = []
for obj in base.cr.doId2do.values():
if obj.__class__.__name__ == "DistributedSuit":
if obj.getPlace() == base.localAvatar.zoneId:
suits.append(obj)
nearestCog = self.getClosestObject(self.gag, suits)
suits = []
if nearestCog and nearestCog.getDistance(
self.gag) <= self.minSafeDistance:
self.onActivate(self.gag, nearestCog)
else:
track.append(
SoundInterval(self.hitSfx, duration=0.5, node=self.gag))
base.taskMgr.doMethodLater(self.lifeTime,
self.__clearEntity,
'Clear Entity',
extraArgs=[self.gag],
appendTask=True)
self.gag = None
else:
# We're too close to another trap, let's clear them out.
self.cleanupGag()
for ent in [
self.gag,
self.getClosestObject(self.gag, self.entities)
]:
if ent:
self.__doDustClear(ent)
track.append(Func(self.completeTrap))
track.start()
self.entityTrack = track
def serveFood(self, food, chairIndex):
self.removeFoodModel(chairIndex)
serviceLoc = self.serviceLocs.get(chairIndex)
if not food or food.isEmpty():
foodModel = loader.loadModel('phase_12/models/bossbotHQ/canoffood')
foodModel.setScale(ToontownGlobals.BossbotFoodModelScale)
foodModel.reparentTo(serviceLoc)
else:
food.wrtReparentTo(serviceLoc)
tray = food.find('**/tray')
if not tray.isEmpty():
tray.hide()
ivalDuration = 1.5
foodMoveIval = Parallel(SoundInterval(self.serveFoodSfx, node=food), ProjectileInterval(food, duration=ivalDuration, startPos=food.getPos(serviceLoc), endPos=serviceLoc.getPos(serviceLoc)), LerpHprInterval(food, ivalDuration, Point3(0, -360, 0)))
intervalName = 'serveFood-%d-%d' % (self.index, chairIndex)
foodMoveIval.start()
self.activeIntervals[intervalName] = foodMoveIval
