def getToonJumpTrack(av, seatIndex):
def getJumpDest(av=av, node=self.golfKart):
dest = Point3(0, 0, 0)
if hasattr(self, 'golfKart') and self.golfKart:
dest = Vec3(self.golfKart.getPos(av.getParent()))
seatNode = self.golfKart.find('**/seat' +
str(seatIndex + 1))
dest += seatNode.getPos(self.golfKart)
dna = av.getStyle()
dest -= hipOffset
if seatIndex < 2:
dest.setY(dest.getY() + 2 * hipOffset.getY())
dest.setZ(dest.getZ() + 0.1)
else:
self.notify.warning(
'getJumpDestinvalid golfKart, returning (0,0,0)')
return dest
def getJumpHpr(av=av, node=self.golfKart):
hpr = Point3(0, 0, 0)
if hasattr(self, 'golfKart') and self.golfKart:
hpr = self.golfKart.getHpr(av.getParent())
if seatIndex < 2:
hpr.setX(hpr.getX() + 180)
else:
hpr.setX(hpr.getX())
angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX())
hpr.setX(angle)
else:
self.notify.warning(
'getJumpHpr invalid golfKart, returning (0,0,0)')
return hpr
toonJumpTrack = Parallel(
ActorInterval(av, 'jump'),
Sequence(
Wait(0.43),
Parallel(
LerpHprInterval(av, hpr=getJumpHpr, duration=0.9),
ProjectileInterval(av,
endPos=getJumpDest,
duration=0.9))))
return toonJumpTrack
def makeToonGrabInterval(self, toon):
origPos = toon.getPos(self.root)
origHpr = toon.getHpr(self.root)
a = self.accomodateToon(toon)
newPos = toon.getPos()
newHpr = toon.getHpr()
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
self.notify.debug('toon.setPosHpr %s %s' % (origPos, origHpr))
toon.setPosHpr(origPos, origHpr)
walkTime = 0.2
reach = Sequence()
if reach.getDuration() < walkTime:
reach = Sequence(ActorInterval(toon, 'walk', loop=1, duration=walkTime - reach.getDuration()), reach)
i = Sequence(Parallel(toon.posInterval(walkTime, newPos, origPos), toon.hprInterval(walkTime, newHpr, origHpr), reach), Func(toon.stopLookAround))
if toon == base.localAvatar:
i.append(Func(self.switchToAnimState, 'GolfPuttLoop'))
i.append(Func(self.startAdjustClubTask))
i = Parallel(i, a)
return i
def enterFallForward(self):
self.notify.debug('enterFallForward')
if self.isLocal:
base.playSfx(self.activity.sndOof)
duration = 2.0
animName = self.FallFwdAnim
startFrame = 12
totalFrames = self.toon.getNumFrames(animName)
frames = totalFrames - 1 - startFrame
pauseFrame = 19
frameRate = self.toon.getFrameRate(animName)
newRate = frames / (duration * 0.5)
playRate = newRate / frameRate
def resume(self = self):
self.fsm.request('normal')
self.fallFwdIval = Sequence(ActorInterval(self.toon, animName, startTime=startFrame / newRate, endTime=pauseFrame / newRate, playRate=playRate), WaitInterval(duration / 2.0), ActorInterval(self.toon, animName, startTime=pauseFrame / newRate, endTime=totalFrames / newRate, playRate=playRate), FunctionInterval(resume))
self.fallFwdIval.start()
def start(self):
SquirtGag.start(self)
self.buildFlower()
self.build()
self.equip()
if self.isLocal():
self.startTimeout()
self.origin = self.getSprayStartPos()
def attachFlower():
flowerJoint = self.avatar.find('**/def_joint_attachFlower')
if flowerJoint.isEmpty():
flowerJoint = self.avatar.find('**/joint_attachFlower')
self.flower.reparentTo(flowerJoint)
self.flower.setY(self.flower.getY())
# The variables we'll need.
totalAnimationTime = 2.5
flowerAppear = 1.0
flowerScaleTime = 0.5
# Let's start building the track.
animTrack = ActorInterval(self.avatar, 'push-button')
self.track.append(animTrack)
flowerTrack = Sequence(
Func(attachFlower), Wait(flowerAppear),
LerpScaleInterval(self.flower,
flowerScaleTime,
1.5,
startScale=GagGlobals.PNT3NEAR0),
Wait(totalAnimationTime - flowerScaleTime - flowerAppear))
flowerTrack.append(Func(self.release))
flowerTrack.append(
LerpScaleInterval(self.flower, flowerScaleTime,
GagGlobals.PNT3NEAR0))
flowerTrack.append(
LerpScaleInterval(self.gag, flowerScaleTime, GagGlobals.PNT3NEAR0))
flowerTrack.append(Func(self.unEquip))
self.track.append(flowerTrack)
self.track.start()
def throwTeamInWater(self, losingTeam):
self.notify.debug('throwTeamInWater( %s )' %
PartyGlobals.TeamActivityTeams.getString(losingTeam))
splashSet = False
for toonId in self.toonIds[losingTeam]:
self.fallenToons.append(toonId)
toon = self.getAvatar(toonId)
fallenPosIndex = self.toonIds[losingTeam].index(toonId)
if fallenPosIndex < 0 or fallenPosIndex >= 4:
fallenPosIndex = 0
newPos = self.fallenPositions[fallenPosIndex]
if self.toonIdsToAnimIntervals.has_key(
toonId
) and self.toonIdsToAnimIntervals[toonId] is not None:
if self.toonIdsToAnimIntervals[toonId].isPlaying():
self.toonIdsToAnimIntervals[toonId].finish()
if toon:
parallel = Parallel(
ActorInterval(actor=toon,
animName='slip-forward',
duration=2.0),
LerpPosInterval(toon,
duration=2.0,
pos=newPos,
other=self.root))
else:
self.notify.warning('toon %d is none, skipping slip-forward' %
toonId)
parallel = Parallel()
if not splashSet:
splashSet = True
parallel.append(self.splashInterval)
if toon:
self.toonIdsToAnimIntervals[toonId] = Sequence(
parallel, Func(toon.loop, 'neutral'))
else:
self.notify.warning(
'toon %d is none, skipping toon.loop(neutral)' % toonId)
self.toonIdsToAnimIntervals[toonId] = parallel
self.toonIdsToAnimIntervals[toonId].start()
return
def start(self):
Gag.start(self)
if self.sprayTrack:
self.sprayTrack.pause()
self.sprayTrack = None
if self.tracks:
self.tracks.pause()
self.tracks = None
if self.anim:
self.build()
self.equip()
duration = base.localAvatar.getDuration(
self.toonAnim, toFrame=self.enableReleaseFrame)
self.sprayAttempt = Parallel(
ActorInterval(self.avatar,
self.toonAnim,
startFrame=self.startAnimFrame,
endFrame=self.enableReleaseFrame,
playRate=self.playRate), Wait(duration - 0.15),
Func(self.setSquirtEnabled, True)).start()
def __handleJumpLand(self):
if (self.jumpEnSeq):
self.jumpEnSeq.finish()
self.jumpEnSeq = None
if (self.jumpStSeq):
self.jumpStSeq.finish()
if (self.didFlip):
taskMgr.remove('doFlip')
self.flipSeq.finish()
self.toon.getGeomNode().wrtReparentTo(self.toon)
self.didFlip = False
spd, rot, sli = self.toon.walkControls.getSpeeds()
self.jumpEnSeq = Sequence(
ActorInterval(self.toon, 'zend', startFrame = 3, playRate = 1.0 if (not spd and not rot and not sli) else 3.0),
Func(self.toon.setAnimState, 'Happy')
)
self.jumpEnSeq.start()
def emptySlot(self, index, avId):
toon = self.cr.doId2do.get(avId)
toon.stopSmooth()
currToonPos = toon.getPos(render)
toon.wrtReparentTo(render)
slotPos = self.STAND_POSITIONS[index]
endPos = (-20, slotPos.getY(), 1.4)
toon.setPos(self.trolleyCar, endPos)
endPosWrtRender = toon.getPos(render)
toon.setPos(currToonPos)
toon.headsUp(self.trolleyCar, endPos)
if index <= 3:
track = Sequence(Parallel(
ActorInterval(toon, 'start-sit', startTime=1, endTime=0.0),
Sequence(
Wait(0.5),
LerpPosInterval(toon,
0.25,
Point3(-5, -4.5 + index * 3, 1.4),
other=self.trolleyCar))),
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
1,
Point3(21 - index * 3, -5, 0.02),
other=self.trolleyStation),
Func(toon.setAnimState, 'neutral'),
Func(toon.startSmooth),
name=toon.uniqueName('emptyTrolley'),
autoPause=1)
else:
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
duration=1.0,
pos=endPosWrtRender,
startPos=currToonPos),
Func(toon.setAnimState, 'neutral'), Func(toon.startSmooth))
if avId == base.localAvatar.doId:
self.localAvOnTrolley = False
track.append(Func(self.__hoppedOffTrolley))
track.start()
def equip(self):
print "equip again"
self.cleanupLocationSeeker()
self.buildButton()
self.button.reparentTo(self.avatar.find('**/def_joint_left_hold'))
if self.isLocal():
fpsCam = base.localAvatar.getFPSCam()
vm = fpsCam.viewModel
fpsCam.setVMGag(self.button,
pos=(-0.04, 0.05, -0.01),
hpr=(328.39, 268.95, 359.48),
scale=0.559,
hand=1)
fpsCam.setVMAnimTrack(
Sequence(ActorInterval(vm, 'button_draw'),
Func(vm.loop, 'button_idle')))
self.locationSeeker = LocationSeeker(self.avatar, self,
self.minDistance,
self.maxDistance)
self.locationSeeker.setShadowType(self.isCircle, self.shadowScale)
self.avatar.acceptOnce(
self.locationSeeker.getLocationSelectedName(),
base.localAvatar.releaseGag)
self.helpInfo = OnscreenText(
text='Move the shadow with your mouse\nClick to release',
pos=(0, -0.75),
font=CIGlobals.getToonFont(),
fg=(1, 1, 1, 1),
shadow=(0, 0, 0, 1))
self.helpInfo.hide() # yeet
self.doDrawAndHold(self.buttonAnim,
0,
self.chooseLocFrame,
bobStart=self.chooseLocFrame,
bobEnd=self.chooseLocFrame,
holdCallback=self.locationSeeker.startSeeking
if self.isLocal() else None)
def getSplicedLerpAnimsTrack(self,
av,
animName,
origDuration,
newDuration,
startTime=0,
fps=30):
track = Sequence()
addition = 0
numIvals = int(origDuration * fps)
timeInterval = newDuration / numIvals
animInterval = origDuration / numIvals
for _ in range(0, numIvals):
track.append(Wait(timeInterval))
track.append(
ActorInterval(av,
animName,
startTime=startTime + addition,
duration=animInterval))
addition += animInterval
return track
def makeToonReleaseInterval(self, toon):
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -5, 0))
if self.gotHitByBoss:
grabIval = Sequence(Func(self.detachClub), name='makeToonReleaseInterval-gotHitByBoss')
if not toon.isEmpty():
toonIval = Sequence(Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)), name='makeToonReleaseInterval-toonIval')
grabIval.append(toonIval)
else:
grabIval = Sequence(Func(self.detachClub))
if not toon.isEmpty():
toonIval = Sequence(LerpPosInterval(toon, duration=1.0, pos=Point3(-10, 0, 0)), Func(toon.wrtReparentTo, render))
grabIval.append(toonIval)
if localAvatar.doId == toon.doId:
if not self.goingToReward and toon.hp > 0:
grabIval.append(Func(self.goToFinalBattle))
grabIval.append(Func(self.notify.debug, 'goingToFinalBattlemode'))
grabIval.append(Func(self.safeBossToFinalBattleMode))
return grabIval
def enterSquish(self, ts=0, callback=None, extraArgs=[]):
self.playingAnim = 'squish'
sound = loader.loadSfx('phase_9/audio/sfx/toon_decompress.ogg')
lerpTime = 0.1
node = self.getGeomNode().getChild(0)
origScale = node.getScale()
if hasattr(self, 'uniqueName'):
name = self.uniqueName('getSquished')
else:
name = 'getSquished'
self.track = Sequence(LerpScaleInterval(node,
lerpTime,
VBase3(2, 2, 0.025),
blendType='easeInOut'),
Wait(1.0),
Parallel(
Sequence(
Wait(0.4),
LerpScaleInterval(node,
lerpTime,
VBase3(1.4, 1.4, 1.4),
blendType='easeInOut'),
LerpScaleInterval(node,
lerpTime / 2.0,
VBase3(0.8, 0.8, 0.8),
blendType='easeInOut'),
LerpScaleInterval(
node,
lerpTime / 3.0,
origScale,
blendType='easeInOut')),
ActorInterval(self, 'happy', startTime=0.2),
SoundInterval(sound)),
name=name)
self.track.setDoneEvent(self.track.getName())
self.acceptOnce(self.track.getDoneEvent(), self.squishDone,
[callback, extraArgs])
self.track.delayDelete = DelayDelete.DelayDelete(self, name)
self.track.start(ts)
def doDeathTrack(self):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.deathSuit.reparentTo(self.suit.getParent())
self.deathSuit.setScale(self.suit.getScale())
self.deathSuit.setPos(render, self.suit.getPos(render))
self.deathSuit.setHpr(render, self.suit.getHpr(render))
self.suit.hide()
self.collNodePath.reparentTo(self.deathSuit)
gearPoint = Point3(0, 0, self.suit.height / 2.0 + 2.0)
smallGears = BattleParticles.createParticleEffect(file='gearExplosionSmall')
singleGear = BattleParticles.createParticleEffect('GearExplosion', numParticles=1)
smallGearExplosion = BattleParticles.createParticleEffect('GearExplosion', numParticles=10)
bigGearExplosion = BattleParticles.createParticleEffect('BigGearExplosion', numParticles=30)
smallGears.setPos(gearPoint)
singleGear.setPos(gearPoint)
smallGearExplosion.setPos(gearPoint)
bigGearExplosion.setPos(gearPoint)
smallGears.setDepthWrite(False)
singleGear.setDepthWrite(False)
smallGearExplosion.setDepthWrite(False)
bigGearExplosion.setDepthWrite(False)
suitTrack = Sequence(Func(self.collNodePath.stash), ActorInterval(self.deathSuit, 'lose', startFrame=80, endFrame=140), Func(removeDeathSuit, self.suit, self.deathSuit, name='remove-death-suit'))
explosionTrack = Sequence(Wait(1.5), MovieUtil.createKapowExplosionTrack(self.deathSuit, explosionPoint=gearPoint))
gears1Track = Sequence(ParticleInterval(smallGears, self.deathSuit, worldRelative=0, duration=4.3, cleanup=True), name='gears1Track')
gears2MTrack = Track((0.0, explosionTrack), (0.7, ParticleInterval(singleGear, self.deathSuit, worldRelative=0, duration=5.7, cleanup=True)), (5.2, ParticleInterval(smallGearExplosion, self.deathSuit, worldRelative=0, duration=1.2, cleanup=True)), (5.4, ParticleInterval(bigGearExplosion, self.deathSuit, worldRelative=0, duration=1.0, cleanup=True)), name='gears2MTrack')
def removeParticle(particle):
if particle and hasattr(particle, 'renderParent'):
particle.cleanup()
del particle
removeParticles = Sequence(Func(removeParticle, smallGears), Func(removeParticle, singleGear), Func(removeParticle, smallGearExplosion), Func(removeParticle, bigGearExplosion))
self.deathTrack = Sequence(Parallel(suitTrack, gears2MTrack, gears1Track, self._deathSoundIval), removeParticles)
self.deathTrack.start()
def doPixieDust(self, target):
sprayEffect = self.createParticle('pixieSpray')
dropEffect = self.createParticle('pixieDrop')
explodeEffect = self.createParticle('pixieExplode')
poofEffect = self.createParticle('pixiePoof')
wallEffect = self.createParticle('pixieWall')
def face90():
vec = Point3(target.getPos() - self.avatar.getPos())
vec.setZ(0)
temp = vec[0]
vec.setX(-vec[1])
vec.setY(temp)
targetPoint = Point3(self.avatar.getPos() + vec)
self.avatar.headsUp(render, targetPoint)
def doHeal():
if self.isLocal():
self.healAvatar(target, 'conked')
base.localAvatar.sendUpdate('gagRelease', [self.getID()])
delay = 2.5
track = Sequence()
mtrack = Parallel(
self.__getPartTrack(sprayEffect, 1.5, 0.5,
[sprayEffect, self.avatar, 0]),
self.__getPartTrack(dropEffect, 1.9, 2.0, [dropEffect, target, 0]),
self.__getPartTrack(explodeEffect, 2.7, 1.0,
[explodeEffect, self.avatar, 0]),
self.__getPartTrack(poofEffect, 3.4, 1.0, [poofEffect, target, 0]),
self.__getPartTrack(wallEffect, 4.05, 1.2,
[wallEffect, self.avatar, 0]),
self.getSoundTrack(0, self.avatar, 4.1),
Sequence(Func(face90), ActorInterval(self.avatar,
'sprinkle-dust')),
Sequence(Wait(delay), Func(doHeal)))
track.append(mtrack)
track.append(Func(self.reset))
track.start()
def makeDustCloud(pos, scale=(0.1, 0.9, 1), sound=None, color=(1, 1, 1, 1)):
from direct.actor.Actor import Actor
dust = Actor('phase_5/models/props/dust-mod.bam',
{'chan': 'phase_5/models/props/dust-chan.bam'})
dust.hide(ShadowCameraBitmask)
objBin = 110
for cloudNum in range(1, 12):
cloudName = '**/cloud' + str(cloudNum)
cloud = dust.find(cloudName)
cloud.setBin('fixed', objBin)
cloud.setLightOff(1)
cloud.setColorScale(color, 1)
objBin -= 10
dust.setBillboardPointEye()
dust.setScale(scale)
dust.reparentTo(render)
dust.setPos(pos)
if sound:
base.audio3d.attachSoundToObject(sound, dust)
sound.play()
dustTrack = Sequence(ActorInterval(dust, "chan"), Func(dust.cleanup))
dustTrack.start()
def getToonJumpTrack(av, destNode):
def getJumpDest(av=av, node=destNode):
dest = node.getPos(av.getParent())
dest += Vec3(*self.JumpOutOffsets[seatIndex])
return dest
def getJumpHpr(av=av, node=destNode):
hpr = node.getHpr(av.getParent())
hpr.setX(hpr.getX() + 180)
angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX())
hpr.setX(angle)
return hpr
toonJumpTrack = Parallel(
ActorInterval(av, 'jump'),
Sequence(
Wait(0.1),
Parallel(
ProjectileInterval(av,
endPos=getJumpDest,
duration=0.9))))
return toonJumpTrack
def start(self, avatar):
self.avatar = avatar
self.buildButton()
self.button.reparentTo(self.avatar.find('**/def_joint_left_hold'))
track = Sequence(
ActorInterval(self.avatar,
self.buttonAnim,
startFrame=0,
endFrame=self.chooseLocFrame,
playRate=self.playRate))
if self.avatar == base.localAvatar:
self.chargeUpSpot = ChargeUpSpot(self, self.avatar,
self.selectionRadius,
self.minDistance,
self.maxDistance,
self.shadowScale, self.maxCogs)
self.avatar.acceptOnce(self.chargeUpSpot.getChargedUpName(),
base.localAvatar.releaseGag)
self.avatar.acceptOnce(self.chargeUpSpot.getChargedCanceledName(),
self.handleStopCharging)
track.append(Func(self.chargeUpSpot.startSeeking))
track.start()
def enterFlyDown(self, ts = 0):
self.disableRay()
self.enableShadowRay()
if not self.propeller:
self.generatePropeller()
sfx = self.propellerSounds['in']
base.playSfx(sfx, node = self)
groundF = 28
dur = self.getDuration('land')
fr = self.getFrameRate('land')
if fr:
animTimeInAir = groundF / fr
else:
animTimeInAir = groundF
impactLength = dur - animTimeInAir
timeTillLanding = 6.5 - impactLength
waitTime = timeTillLanding - animTimeInAir
lastSpinFrame = 8
propDur = self.propeller.getDuration('chan')
fr = self.propeller.getFrameRate('chan')
spinTime = lastSpinFrame / fr
openTime = (lastSpinFrame + 1) / fr
if hasattr(self, 'uniqueName'):
name = self.uniqueName('enterFlyDown')
else:
name = 'enterFlyDown'
animTrack = Sequence(Func(self.pose, 'land', 0), Wait(waitTime), ActorInterval(self, 'land', duration=dur))
propTrack = Parallel(SoundInterval(sfx, duration=waitTime + dur, node=self), Sequence(ActorInterval(self.propeller, 'chan', constrainedLoop=1, duration=waitTime + spinTime, startTime=0.0, endTime=spinTime), ActorInterval(self.propeller, 'chan', duration=propDur - openTime, startTime=openTime)))
self.suitTrack = Parallel(animTrack, propTrack, name=self.taskName('flyDown'))
if not self.hasSpawned:
self.show()
fadeInTrack = Sequence(Func(self.setTransparency, 1), self.colorScaleInterval(1, colorScale=VBase4(1, 1, 1, 1), startColorScale=VBase4(1, 1, 1, 0)), Func(self.clearColorScale), Func(self.clearTransparency))
self.hasSpawned = True
self.suitTrack.append(fadeInTrack)
self.suitTrack.setDoneEvent(self.suitTrack.getName())
self.acceptOnce(self.suitTrack.getDoneEvent(), self.exitFlyDown)
self.suitTrack.delayDelete = DelayDelete.DelayDelete(self, name)
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 enterFallBack(self):
self.notify.debug('enterFallBack')
if self.isLocal:
base.playSfx(self.activity.sndOof)
duration = 1.0
animName = self.FallBackAnim
startFrame = 12
totalFrames = self.toon.getNumFrames(animName)
frames = totalFrames - 1 - startFrame
frameRate = self.toon.getFrameRate(animName)
newRate = frames / duration
playRate = newRate / frameRate
def resume(self=self):
self.fsm.request('normal')
self.fallBackIval = Sequence(
ActorInterval(self.toon,
animName,
startTime=startFrame / newRate,
endTime=totalFrames / newRate,
playRate=playRate), FunctionInterval(resume))
self.fallBackIval.start()
def changeDinerToDead(self, chairIndex):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.removeFoodModel(chairIndex)
indicator = self.dinerStatusIndicators.get(chairIndex)
if indicator:
indicator.request('Dead')
diner = self.diners[chairIndex]
deathSuit = diner
locator = self.tableGroup.find('**/chair_%d' % (chairIndex + 1))
deathSuit = diner.getLoseActor()
ival = Sequence(Func(self.notify.debug, 'before actorinterval sit-lose'), ActorInterval(diner, 'sit-lose'), Func(self.notify.debug, 'before deathSuit.setHpr'), Func(deathSuit.setHpr, diner.getHpr()), Func(self.notify.debug, 'before diner.hide'), Func(diner.hide), Func(self.notify.debug, 'before deathSuit.reparentTo'), Func(deathSuit.reparentTo, self.chairLocators[chairIndex]), Func(self.notify.debug, 'befor ActorInterval lose'), ActorInterval(deathSuit, 'lose', duration=MovieUtil.SUIT_LOSE_DURATION), Func(self.notify.debug, 'before remove deathsuit'), Func(removeDeathSuit, diner, deathSuit, name='remove-death-suit-%d-%d' % (chairIndex, self.index)), Func(self.notify.debug, 'diner.stash'), Func(diner.stash))
spinningSound = base.loader.loadSfx('phase_3.5/audio/sfx/Cog_Death.ogg')
deathSound = base.loader.loadSfx('phase_3.5/audio/sfx/ENC_cogfall_apart.ogg')
deathSoundTrack = Sequence(Wait(0.8), SoundInterval(spinningSound, duration=1.2, startTime=1.5, volume=0.2, node=deathSuit), SoundInterval(spinningSound, duration=3.0, startTime=0.6, volume=0.8, node=deathSuit), SoundInterval(deathSound, volume=0.32, node=deathSuit))
intervalName = 'dinerDie-%d-%d' % (self.index, chairIndex)
deathIval = Parallel(ival, deathSoundTrack)
deathIval.start()
self.activeIntervals[intervalName] = deathIval
def _getToonAnimationIval(self,
animName,
startFrame=0,
duration=1,
nextState=None):
totalFrames = self.toon.getNumFrames(animName)
frames = totalFrames - 1 - startFrame
frameRate = self.toon.getFrameRate(animName)
newRate = frames / duration
playRate = newRate / frameRate
ival = Sequence(
ActorInterval(self.toon,
animName,
startTime=startFrame / newRate,
endTime=totalFrames / newRate,
playRate=playRate))
if nextState is not None:
def done():
self.request(nextState)
ival.append(Func(done))
return ival
def getTossPieInterval(self, toon, x, y, z, h, p, r, power, beginFlyIval = Sequence()):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
pie = toon.getPieModel()
pie.setScale(0.9)
flyPie = pie.copyTo(NodePath('a'))
pieName = ToontownBattleGlobals.pieNames[toon.pieType]
pieType = BattleProps.globalPropPool.getPropType(pieName)
animPie = Sequence()
if pieType == 'actor':
animPie = ActorInterval(pie, pieName, startFrame=48)
sound = loader.loadSfx('phase_3.5/audio/sfx/AA_pie_throw_only.mp3')
t = power / 100.0
dist = 100 - 70 * t
time = 1 + 0.5 * t
proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time)
relVel = proj.startVel
def getVelocity(toon = toon, relVel = relVel):
return render.getRelativeVector(toon, relVel) * 0.6
toss = Track((0, Sequence(Func(toon.setPosHpr, x, y, z, h, p, r), Func(pie.reparentTo, toon.rightHand), Func(pie.setPosHpr, 0, 0, 0, 0, 0, 0), Parallel(ActorInterval(toon, 'throw', startFrame=48, partName='torso'), animPie), Func(toon.loop, 'neutral'))), (16.0 / 24.0, Func(pie.detachNode)))
fly = Track((14.0 / 24.0, SoundInterval(sound, node=toon)), (16.0 / 24.0, Sequence(Func(flyPie.reparentTo, render), Func(flyPie.setPosHpr, toon, 0.52, 0.97, 2.24, 0, -45, 0), beginFlyIval, ProjectileInterval(flyPie, startVel=getVelocity, duration=6), Func(flyPie.detachNode))))
return (toss, fly, flyPie)
def makeSplat(pos, color, scale, sound = None):
from direct.interval.IntervalGlobal import ActorInterval
from panda3d.core import AudioSound
splat = getSplat()
splat.setBillboardPointEye()
splat.setScale(scale)
splat.setColor(color)
splat.reparentTo(render)
splat.setPos(pos)
splat.setLightOff(1)
splat.setTransparency(TransparencyAttrib.MDual)
splat.hide(ShadowCameraBitmask|ReflectionCameraBitmask)
if sound:
if isinstance(sound, str):
sound = base.audio3d.loadSfx(sound)
if isinstance(sound, AudioSound):
base.audio3d.attachSoundToObject(sound, splat)
sound.play()
seq = Sequence(ActorInterval(splat, "chan"), Func(splat.cleanup), Func(splat.removeNode))
seq.start()
def addActors(ACTORS, parent):
for prop in ACTORS:
if prop[0] == 'custom':
model = Actor('custom/models/%s/%s.egg' % (prop[1], prop[2]),
prop[9])
else:
model = Actor(
'phase_%s/models/%s/%s.bam' % (prop[0], prop[1], prop[2]),
prop[9])
model.reparentTo(parent)
model.setBlend(frameBlend=True)
model.setPos(prop[3])
model.setHpr(prop[4])
model.setScale(prop[5])
if prop[7]:
model.setColorScale(prop[7])
if prop[8]:
texture = loader.loadTexture(prop[8])
model.setTexture(texture, 1)
actorTrack = Sequence()
for anim in prop[9]:
actorTrack.append(ActorInterval(model, anim))
actorTrack.loop()
def onSetAction_firstPerson(self, action):
track = Sequence()
vm = self.getViewModel()
fpsCam = self.getFPSCam()
if action in [self.StateFire, self.StateDblFire]:
CIGlobals.makeMuzzleFlash(self.fpMuzzleAttach,
(-0.03, 0.51, 32.45), (0, -90, 0), 7.5)
if action == self.StateIdle:
track.append(Func(vm.loop, "idle"))
elif action == self.StateDraw:
track.append(ActorInterval(vm, "draw", playRate=self.Speed))
elif action == self.StatePump:
track.append(Func(self.pumpSound.play))
track.append(Func(self.__emitShell))
track.append(ActorInterval(vm, "pump", playRate=self.Speed))
elif action == self.StateFire:
fpsCam.addViewPunch(
Vec3(random.uniform(-2, 2), random.uniform(2, 1), 0))
track.append(Func(self.fireSound.play))
track.append(ActorInterval(vm, "fire", playRate=self.Speed))
elif action == self.StateDblFire:
fpsCam.addViewPunch(Vec3(0, random.uniform(-5, 5), 0))
track.append(Func(self.dblFireSound.play))
track.append(ActorInterval(vm, "altfire", playRate=self.Speed))
elif action == self.StateReload:
sound = random.choice(self.reloadSounds)
track.append(Func(sound.play))
track.append(ActorInterval(vm, "reload2", playRate=self.Speed))
elif action == self.StateBeginReload:
track.append(ActorInterval(vm, "reload1", playRate=self.Speed))
elif action == self.StateEndReload:
track.append(ActorInterval(vm, "reload3", playRate=self.Speed))
fpsCam.setVMAnimTrack(track)
def showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + ` avId `)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 50),
gravMult=1.0)
oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 40),
gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
avIndex = self.avIdList.index(avId)
endPos = CTGG.ToonStartingPositions[avIndex]
def flyFunc(t,
trajectory,
startPos=startPos,
endPos=endPos,
dur=flyDur,
moveNode=parentNode,
flyNode=toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc,
fromData=0.0,
toData=flyDur,
duration=flyDur,
extraArgs=[trajectory]),
name=toon.uniqueName('hitBySuit-fly'))
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(geomNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(rotNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx,
self.sndTable['hitBySuit'][i]),
Wait(flyDur * (2.0 / 3.0)),
SoundInterval(self.sndTable['falling'][i],
duration=flyDur * (1.0 / 3.0)),
name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.stopGameWalk()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self=self,
avId=avId,
oldGeomNodeZ=oldGeomNodeZ,
dropShadow=dropShadow,
parentNode=parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'gameWalk'):
toon = base.localAvatar
toon.setSpeed(0, 0)
self.startGameWalk()
dropShadow.removeNode()
del dropShadow
toon = self.getAvatar(avId)
if toon:
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
if toon:
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
if toon:
toon.startSmooth()
preFunc()
slipBack = Parallel(
Sequence(ActorInterval(toon, 'slip-backward', endFrame=24),
ActorInterval(toon, 'slip-backward', startFrame=24)))
if toon.doId == self.localAvId:
slipBack.append(SoundInterval(self.sndOof))
hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack,
soundTrack),
slipBack,
Func(postFunc),
name=toon.uniqueName('hitBySuit'))
self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration())
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
return
def makeToonReleaseInterval(self, toon):
temp1 = self.waterPitcherNode.attachNewNode('temp1')
temp1.setPos(self.toonPitcherPosition)
temp2 = self.waterPitcherNode.attachNewNode('temp2')
temp2.setPos(0, -10, -self.waterPitcherNode.getZ())
startPos = temp1.getPos(render)
endPos = temp2.getPos(render)
temp1.removeNode()
temp2.removeNode()
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -10, 0))
if self.gotHitByBoss:
self.notify.debug('creating zap interval instead')
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)))
else:
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), ProjectileInterval(toon, duration=0.9, startPos=startPos, endPos=endPos))))
return grabIval
def makeToonGrabInterval(self, toon):
toon.pose('leverNeutral', 0)
toon.update()
rightHandPos = toon.rightHand.getPos(toon)
self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0)
destZScale = rightHandPos[2] / self.handPos[2]
grabIval = Sequence(Func(toon.wrtReparentTo, self.waterPitcherNode), Func(toon.loop, 'neutral'), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), Parallel(ProjectileInterval(toon, duration=0.9, startPos=toon.getPos(self.waterPitcherNode), endPos=self.toonPitcherPosition), LerpHprInterval(toon, 0.9, Point3(0, 0, 0)), LerpScaleInterval(self.waterPitcherModel, 0.9, Point3(1, 1, destZScale))))), Func(toon.setPos, self.toonPitcherPosition), Func(toon.loop, 'leverNeutral'))
return grabIval
def enterCatch(self):
self.ival = Parallel(
Sequence(Wait(0.2), Func(self.__tryToCatchOrGrab)),
Sequence(ActorInterval(self.vModel, "catch"),
Func(self.__maybeHold)))
self.ival.start()
