def onActivate(self, entity, suit):
ActivateTrapGag.onActivate(self, entity, suit)
x, y, z = entity.getPos(render)
sinkPos01 = Point3(x, y, z - 3.1)
sinkPos02 = Point3(x, y, z - 9.1)
dropPos = Point3(x, y, z + 15)
landPos = Point3(x, y, z)
suit.d_disableMovement()
suit.setPos(x, y, z)
entTrack = Sequence(
Wait(2.4), LerpScaleInterval(entity, 0.8, GagGlobals.PNT3NEAR0))
suitTrack = Sequence(
Wait(0.9), LerpPosInterval(suit, 0.9, sinkPos01),
LerpPosInterval(suit, 0.4, sinkPos02), Func(suit.setPos, dropPos),
Func(suit.hide), Wait(1.1), Func(suit.show),
Func(suit.setPos, dropPos),
Parallel(LerpPosInterval(suit, 0.3, landPos),
Func(suit.play, 'slip-forward')),
Func(self.damageSuit, suit), Func(suit.d_enableMovement))
animTrack = Sequence(ActorInterval(suit, 'flail'),
ActorInterval(suit, 'flail', startTime=1.1),
Wait(0.7),
ActorInterval(suit, 'slip-forward', duration=2.1))
soundTrack = Sequence(Wait(0.7), SoundInterval(self.hitSfx, node=suit),
Wait(0.1),
SoundInterval(self.activateSfx, node=suit))
Parallel(entTrack, suitTrack, animTrack, soundTrack).start()
def enterScrollBy(self):
BLUE_START_POS = Point3(-20, 0, 4)
BLUE_END_POS = Point3(20, 0, 4)
BLUE_HPR = Vec3(0, 0, 0)
RED_START_POS = Point3(20, 0, 4)
RED_END_POS = Point3(-20, 0, 4)
RED_HPR = Vec3(180, 0, 0)
self.playMinigameMusic()
self.scrollBySeq = Sequence(Func(camera.setHpr, BLUE_HPR),
LerpPosInterval(camera,
duration=5.0,
pos=BLUE_END_POS,
startPos=BLUE_START_POS,
blendType='easeOut'),
Func(base.transitions.fadeOut, 0.4),
Wait(0.5),
Func(base.transitions.fadeIn, 0.4),
Func(camera.setHpr, RED_HPR),
LerpPosInterval(camera,
duration=5.0,
pos=RED_END_POS,
startPos=RED_START_POS,
blendType='easeOut'),
name="SCROLLBYSEQ")
self.scrollBySeq.setDoneEvent(self.scrollBySeq.getName())
self.acceptOnce(self.scrollBySeq.getDoneEvent(),
self.__handleScrollByDone)
self.scrollBySeq.start()
def setEntityState(self, state):
DistributedEntity.setEntityState(self, state)
if state == self.StateDown:
self.clearSequence()
self.setPos(self.cEntity.getOrigin())
self.playSound("stomp")
base.emitShake(self, 0.5)
elif state == self.StateUp:
self.stopSound("raise")
self.clearSequence()
self.setPos(self.cEntity.getOrigin() + self.getUpPosition())
elif state == self.StateStomp:
self.setSequence(
LerpPosInterval(
self, self.height / self.stompSpeed,
self.cEntity.getOrigin(),
self.cEntity.getOrigin() + self.getUpPosition()))
elif state == self.StateRaise:
self.loopSound("raise")
self.setSequence(
LerpPosInterval(
self, self.height / self.raiseSpeed,
self.cEntity.getOrigin() + self.getUpPosition(),
self.cEntity.getOrigin()))
def onActivate(self, entity, suit):
ActivateTrapGag.onActivate(self, entity, suit)
x, y, z = entity.getPos(render)
sinkPos = Point3(x, y, z - 9.1)
dropPos = Point3(x, y, z + 15)
landPos = Point3(x, y, z)
suit.d_disableMovement()
suit.setPos(x, y, z)
entTrack = Sequence(Wait(0.4), Func(entity.setColor, Vec4(0, 0, 0, 1)), Wait(0.4), LerpScaleInterval(entity, 0.8, GagGlobals.PNT3NEAR0))
suitTrack = Sequence(
self.getSplicedLerpAnimsTrack(suit, 'flail', 0.7, 0.25),
Wait(0.2),
LerpPosInterval(suit, 0.4, sinkPos),
Func(suit.setPos, dropPos),
Func(suit.hide),
ActorInterval(suit, 'neutral', duration=0.5),
Wait(0.75),
Func(suit.show),
Parallel(LerpPosInterval(suit, 0.3, landPos), Func(suit.play, 'slip-forward')),
SoundInterval(self.activateSfx, node = suit),
Func(self.damageSuit, suit),
Func(suit.d_enableMovement)
)
soundTrack = Sequence(SoundInterval(self.hitSfx, node = suit), Wait(0.8))
Parallel(entTrack, suitTrack, soundTrack).start()
def announceGenerate(self):
DistributedElevatorExt.DistributedElevatorExt.announceGenerate(self)
angle = self.startingHpr[0]
angle -= 90
radAngle = deg2Rad(angle)
unitVec = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
unitVec *= 11.25
self.endPos = self.startingPos + unitVec
self.endPos.setZ(0.5)
dist = Vec3(self.endPos - self.enteringPos).length()
wheelAngle = dist / (6.72 * math.pi) * 360
self.kartEnterAnimateInterval = Parallel(
LerpHprInterval(
self.wheels[0], 5.0,
Vec3(self.wheels[0].getH(), wheelAngle,
self.wheels[0].getR())),
LerpHprInterval(
self.wheels[1], 5.0,
Vec3(self.wheels[1].getH(), wheelAngle,
self.wheels[1].getR())),
LerpHprInterval(
self.wheels[2], 5.0,
Vec3(self.wheels[2].getH(), wheelAngle,
self.wheels[2].getR())),
LerpHprInterval(
self.wheels[3], 5.0,
Vec3(self.wheels[3].getH(), wheelAngle,
self.wheels[3].getR())),
name='SwagKartAnimate')
trolleyExitTrack1 = Parallel(
Sequence(
Wait(1.25),
Func(self.mole.doMolePop, 0, 0.75, 5, 0.75,
MoleFieldBase.HILL_MOLE)),
Sequence(
LerpPosInterval(self.golfKart, 2.5, self.endPos),
Func(self.mole.setHillType, MoleFieldBase.HILL_WHACKED),
Func(self.soundBomb.play), Func(self.soundBomb2.play),
Func(self.soundUp.play),
Parallel(
ProjectileInterval(self.golfKart,
startPos=self.endPos,
endPos=self.flyToPos,
duration=2,
gravityMult=2.5),
self.golfKart.hprInterval(
2, (self.golfKart.getH(), self.golfKart.getP() + 720,
0)))),
self.kartEnterAnimateInterval,
name='SwagKartExitTrack')
self.trolleyExitTrack = Sequence(trolleyExitTrack1)
self.trolleyEnterTrack = Sequence(
Func(self.golfKart.setP, 0),
LerpPosInterval(self.golfKart,
5.0,
self.startingPos,
startPos=self.enteringPos))
self.closeDoors = Sequence(self.trolleyExitTrack,
Func(self.onDoorCloseFinish))
self.openDoors = Sequence(self.trolleyEnterTrack)
def __init__(self, index, motionPath=None):
radius = Globals.Gameplay.FlyingMinionCollisionRadius
offset = Globals.Gameplay.FlyingMinionCollisionHeightOffset
collSolid = CollisionSphere(0, 0, offset, radius)
CogdoFlyingMinion.__init__(self, index, collSolid, motionPath)
self.attachPropeller()
self.propTrack = Sequence(
ActorInterval(self.prop, 'propeller', startFrame=0, endFrame=14))
dur = Globals.Gameplay.FlyingMinionFloatTime
offset = Globals.Gameplay.FlyingMinionFloatOffset
suitPos = self.suit.getPos()
upperPos = suitPos + Point3(0.0, 0.0, offset / 2.0)
lowerPos = suitPos + Point3(0.0, 0.0, -offset / 2.0)
self.floatSequence = Sequence(LerpPosInterval(self.suit,
dur / 4.0,
startPos=suitPos,
pos=upperPos,
blendType='easeInOut'),
LerpPosInterval(self.suit,
dur / 2.0,
startPos=upperPos,
pos=lowerPos,
blendType='easeInOut'),
LerpPosInterval(self.suit,
dur / 4.0,
startPos=lowerPos,
pos=suitPos,
blendType='easeInOut'),
name='%s.floatSequence%i' %
(self.__class__.__name__, self.index))
def openRestockDoors(self):
lDoorOpen = -3.9
rDoorOpen = 3.5
closed = 0.0
leftDoor = self.gagDoor.find('**/left_door')
rightDoor = self.gagDoor.find('**/right_door')
# Delete the invisible one-piece wall blocking the doorway.
# John, fix this!
self.gagDoor.find('**/door_collisions').removeNode()
ival = Parallel(LerpPosInterval(leftDoor, 2.0, (lDoorOpen, 0, 0),
(closed, 0, 0), blendType = 'easeOut'),
LerpPosInterval(rightDoor, 2.0, (rDoorOpen, 0, 0),
(closed, 0, 0), blendType = 'easeOut'))
ival.start()
loadout = base.localAvatar.backpack.getLoadout()
sendLoadout = []
for gag in loadout:
sendLoadout.append(gag.getID())
base.localAvatar.sendUpdate('requestSetLoadout', [sendLoadout])
def doActivity(self):
pr = 5.0
jump = ActorInterval(self.avatar,
'land',
startFrame=50,
endFrame=20,
playRate=pr * 2)
jumpDur = jump.getDuration()
curr = self.avatar.getPos(render)
return Sequence(
ActorInterval(self.avatar,
'land',
startFrame=60,
endFrame=50,
playRate=pr),
Parallel(
Sequence(
LerpPosInterval(self.avatar, jumpDur / 2, curr + (0, 0, 1),
curr),
LerpPosInterval(self.avatar, jumpDur / 2, curr,
curr + (0, 0, 1))), jump),
ActorInterval(self.avatar,
'land',
startFrame=20,
endFrame=60,
playRate=pr))
def enterTakeOver(self, ts = 0):
if not self.door:
return
self.stopSmooth()
self.hasSpawned = False
self.reparentTo(self.door.doorNode)
self.setHpr(0, 0, 0)
self.takeOverTrack = Parallel(
Sequence(
Func(self.animFSM.request, 'flyDown', [ts]),
Wait(6.834),
Func(self.setAnimState, 'neutral'),
Wait(0.5),
Func(self.setAnimState, 'walk'),
LerpPosInterval(self, duration = 2.0, pos = DistributedTakeOverSuit.AtDoorPos,
startPos = DistributedTakeOverSuit.StartPosFromDoor),
Func(self.setAnimState, 'neutral'),
Wait(0.3),
Func(self.setAnimState, 'walk'),
LerpPosInterval(self, duration = 0.5, pos = self.door.enterDoorWalkBackNode.getPos(),
startPos = DistributedTakeOverSuit.AtDoorPos),
Func(self.setAnimState, 'neutral'),
Wait(1.0),
Func(self.setAnimState, 'walk'),
LerpPosInterval(self, duration = 1.0, pos = self.door.enterDoorWalkInNode.getPos(),
startPos = self.door.enterDoorWalkBackNode.getPos())),
LerpPosInterval(self,
duration = 4.375,
pos = DistributedTakeOverSuit.StartPosFromDoor,
startPos = DistributedTakeOverSuit.StartPosFromDoor + (0, 0, 6.5 * 4.8))
)
self.takeOverTrack.start(ts)
def setEntityState(self, state):
DistributedEntityAI.setEntityState(self, state)
if state == self.StateDown:
self.stomped = False
self.clearSequence()
self.setPos(self.cEntity.getOrigin())
self.dispatchOutput("OnStomp")
elif state == self.StateUp:
self.clearSequence()
self.setPos(self.cEntity.getOrigin() + self.getUpPosition())
self.dispatchOutput("OnRaise")
elif state == self.StateStomp:
self.damaged = []
self.setSequence(
LerpPosInterval(
self, self.height / self.stompSpeed,
self.cEntity.getOrigin(),
self.cEntity.getOrigin() + self.getUpPosition()))
elif state == self.StateRaise:
self.setSequence(
LerpPosInterval(
self, self.height / self.raiseSpeed,
self.cEntity.getOrigin() + self.getUpPosition(),
self.cEntity.getOrigin()))
def doMolePop(self, startTime, timeToMoveUp, timeToStayUp, timeToMoveDown,
moleType):
if self.hillType == MoleFieldBase.HILL_WHACKED or self.hillType == MoleFieldBase.HILL_COGWHACKED:
return None
if self.popIval:
self.popIval.pause()
if self.downIval:
self.downIval.pause()
self.downIval = None
moleColor = None
self.switchUp()
self.popupNum += 1
if self.hillType == MoleFieldBase.HILL_BOMB:
self.popIval = Sequence(
Func(self.setHillType, moleType),
Func(self.moleColNodePath.unstash),
LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)),
Wait(timeToStayUp),
LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)),
Func(self.stashMoleCollision), Func(self.switchDown))
else:
self.popIval = Sequence(
Func(self.setHillType, moleType),
LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)),
Func(self.moleColNodePath.unstash), Wait(timeToStayUp),
Func(self.stashMoleCollision),
LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)),
Func(self.switchDown))
self.popIval.start()
def _jump_and_explode(self, task):
"""Jump to the Adjutant and self-explode."""
if self.current_part is None:
return task.done
for char in base.world.enemy.active_units.values(): # noqa: F821
if type(char
) == Kamikaze and char.id != self.id and char.is_jumping:
return task.again
self.is_jumping = True
self._stop_tasks("_float_move")
self._move_int.pause()
Sequence(
LerpPosInterval(self.node,
2.5, (self._y_pos, -0.5, 0),
blendType="easeInOut"),
Func(self._ignite_the_wick),
LerpPosInterval(
self.node,
4.5,
(-0.45 if self._y_pos < 0 else 0.45, -0.8, 0),
blendType="easeInOut",
),
Func(self._jump_snd.play),
MopathInterval(self._jump_path,
self.model,
duration=0.8,
name=self.id + "_jump"),
Func(self._die, True),
).start()
return task.done
def _drop_brake(self, brake):
"""Drop braking shoes to slow down the locomotive.
Args:
brake (panda3d.core.NodePath): Brake model to drop.
"""
brake.wrtReparentTo(base.train.model) # noqa: F821
if not base.train.r_brake: # noqa: F821
pos = 0.058
base.train.r_brake = True # noqa: F821
side = "r"
else:
base.train.l_brake = True # noqa: F821
pos = -0.058
side = "l"
Sequence(
Parallel(
LerpPosInterval(brake, 0.5, (pos, 0.7, 0.025)),
LerpHprInterval(brake, 0.5, (0, 0, 0)),
),
LerpPosInterval(brake, 0.35, (pos, 0.38, 0.025)),
Func(base.train.brake, side, brake), # noqa: F821
).start()
def __get_reset_interval(self):
interval1 = LerpPosInterval(self.cam.pivot,
.5,
self.home_pos,
blendType="easeInOut")
if self.cam.lens_type == "persp":
interval2 = LerpQuatInterval(self.cam.target,
.5,
self.home_quat,
blendType="easeInOut")
interval3 = LerpPosInterval(self.cam.origin,
.5,
Point3(0., self.home_zoom, 0.),
blendType="easeInOut")
lerp_interval = Parallel(interval1, interval2, interval3)
else:
interval2 = LerpQuatScaleInterval(self.cam.target,
.5,
self.home_quat,
self.home_zoom,
blendType="easeInOut")
lerp_interval = Parallel(interval1, interval2)
return lerp_interval
def enterShoot(self):
self.shoot.play()
if self.weaponName == "pistol":
self.track = ActorInterval(self.v_model, 'pshoot', playRate = 2, name = 'shootTrack')
elif self.weaponName == "shotgun":
self.track = Parallel(
Sequence(
LerpQuatInterval(self.v_model, duration = 0.05, quat = (0, 3, 0), startHpr = (0, 0, 0)),
LerpQuatInterval(self.v_model, duration = 0.1, quat = (0, 0, 0), startHpr = (0, 3, 0))
),
Sequence(
LerpPosInterval(self.v_model, duration = 0.05, pos = (0, -0.3, 0), startPos = (0, 0, 0)),
LerpPosInterval(self.v_model, duration = 0.1, pos = (0, 0, 0), startPos = (0, -0.3, 0)),
Wait(0.1)
),
)
elif self.weaponName == "sniper":
self.track = Parallel(
Sequence(
LerpQuatInterval(self.v_model, duration = 0.05, quat = (0, 3, 0), startHpr = (0, 0, 0)),
LerpQuatInterval(self.v_model, duration = 0.1, quat = (0, 0, 0), startHpr = (0, 3, 0))
),
Sequence(
LerpPosInterval(self.v_model, duration = 0.05, pos = (0, -0.3, 0), startPos = (0, 0, 0)),
LerpPosInterval(self.v_model, duration = 0.1, pos = (0, 0, 0), startPos = (0, -0.3, 0)),
Wait(0.1)
),
)
self.track.setDoneEvent('shootTrack')
self.acceptOnce(self.track.getDoneEvent(), self.aliveFSM.request, ['idle'])
self.track.start()
self.ammo -= 1
self.gui.adjustAmmoGui()
self.mg.makeSmokeEffect(self.weapon.find('**/joint_nozzle').getPos(render))
self.traverse()
def enterShowScores(self):
self.notify.debug('enterShowScores')
lerpTrack = Parallel()
lerpDur = 0.5
lerpTrack.append(Parallel(LerpPosInterval(self.goalBar, lerpDur, Point3(0, 0, -.6), blendType='easeInOut'), LerpScaleInterval(self.goalBar, lerpDur, Vec3(self.goalBar.getScale()) * 2.0, blendType='easeInOut')))
tY = 0.6
bY = -.05
lX = -.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY),
(rX, tY),
(lX, bY),
(rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(MazeGameGlobals.SHOWSCORES_DURATION), Func(self.gameOver)))
self.showScoreTrack.start()
#For the Alpha Blueprint ARG
if base.config.GetBool('want-blueprint4-ARG', False):
MinigameGlobals.generateDebugARGPhrase()
def enterShowScores(self):
self.notify.debug('enterShowScores')
lerpTrack = Parallel()
lerpDur = 0.5
lerpTrack.append(Parallel(LerpPosInterval(self.goalBar, lerpDur, Point3(0, 0, -0.6), blendType='easeInOut'), LerpScaleInterval(self.goalBar, lerpDur, Vec3(self.goalBar.getScale()) * 2.0, blendType='easeInOut')))
tY = 0.6
bY = -0.05
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY),),
(
(
lX, bY), (rX, bY)),
(
(
cX, tY), (lX, bY), (rX, bY)),
(
(
lX, tY),
(
rX, tY),
(
lX, bY),
(
rX, bY)))
scorePanelLocs = scorePanelLocs[(self.numPlayers - 1)]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(Parallel(LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType='easeInOut'), LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType='easeInOut')))
self.showScoreTrack = Parallel(lerpTrack, Sequence(Wait(MazeGameGlobals.SHOWSCORES_DURATION), Func(self.gameOver)))
self.showScoreTrack.start()
def getVictoryRunTrack(self):
origPosTrack = Sequence()
delayDeletes = []
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
delayDeletes.append(
DelayDelete.DelayDelete(toon, 'getVictoryRunTrack'))
toon.stopSmooth()
toon.setParent(CIGlobals.SPHidden)
origPosTrack.append(
Func(toon.setPosHpr, self.elevatorNodePath,
apply(Point3, ElevatorPoints[i]), Point3(180, 0, 0)))
origPosTrack.append(Func(toon.setParent, CIGlobals.SPRender))
i += 1
openDoors = getOpenInterval(self, self.leftDoor, self.rightDoor,
self.openSfx, None)
toonDoorPosHpr = self.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber(
self.block)
useFarExitPoints = toonDoorPosHpr.getPos(render).getZ() > 1.0
runOutAll = Parallel()
i = 0
for victor in self.victorList:
if victor != 0 and victor in self.cr.doId2do:
toon = self.cr.doId2do[victor]
p0 = Point3(0, 0, 0)
p1 = Point3(ElevatorPoints[i][0], ElevatorPoints[i][1] - 5.0,
ElevatorPoints[i][2])
if useFarExitPoints:
p2 = Point3(ElevatorOutPointsFar[i][0],
ElevatorOutPointsFar[i][1],
ElevatorOutPointsFar[i][2])
else:
p2 = Point3(ElevatorOutPoints[i][0],
ElevatorOutPoints[i][1],
ElevatorOutPoints[i][2])
runOutSingle = Sequence(
Func(toon.animFSM.request, 'run'),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
p1,
other=self.elevatorNodePath),
Func(toon.headsUp, self.elevatorNodePath, p2),
LerpPosInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.5,
p2,
other=self.elevatorNodePath),
LerpHprInterval(toon,
TOON_VICTORY_EXIT_TIME * 0.25,
Point3(0, 0, 0),
other=self.elevatorNodePath),
Func(toon.animFSM.request, 'neutral'),
Func(toon.startSmooth))
runOutAll.append(runOutSingle)
i += 1
victoryRunTrack = Sequence(origPosTrack, openDoors, runOutAll)
return (victoryRunTrack, delayDeletes)
def initIntervals(self):
dur = Globals.LegalEagle.LiftOffTime
nestPos = self.nest.getPos(render)
airPos = nestPos + Vec3(0.0, 0.0, Globals.LegalEagle.LiftOffHeight)
self.takeOffSeq = Sequence(Parallel(Sequence(Wait(dur * 0.59999999999999998), LerpPosInterval(self.suit, dur * 0.40000000000000002, startPos = nestPos, pos = airPos, blendType = 'easeInOut'))), Wait(1.5), Func(self.request, 'next'), name = '%s.takeOffSeq-%i' % (self.__class__.__name__, self.index))
self.landOnNestPosLerp = LerpPosInterval(self.suit, 1.0, startPos = airPos, pos = nestPos, blendType = 'easeInOut')
self.landingSeq = Sequence(Func(self.updateLandOnNestPosLerp), Parallel(self.landOnNestPosLerp), Func(self.request, 'next'), name = '%s.landingSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.ChargeUpTime
self.chargeUpPosLerp = LerpFunc(self.moveAlongChargeUpMopathFunc, fromData = 0.0, toData = self.chargeUpMotionPath.getMaxT(), duration = dur, blendType = 'easeInOut')
self.chargeUpAttackSeq = Sequence(Func(self.updateChargeUpPosLerp), self.chargeUpPosLerp, Func(self.request, 'next'), name = '%s.chargeUpAttackSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToNestTime
self.retreatToNestPosLerp = LerpPosInterval(self.suit, dur, startPos = Vec3(0, 0, 0), pos = airPos, blendType = 'easeInOut')
self.retreatToNestSeq = Sequence(Func(self.updateRetreatToNestPosLerp), self.retreatToNestPosLerp, Func(self.request, 'next'), name = '%s.retreatToNestSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToSkyTime
self.retreatToSkyPosLerp = LerpFunc(self.moveAlongRetreatMopathFunc, fromData = 0.0, toData = self.retreatToSkyMotionPath.getMaxT(), duration = dur, blendType = 'easeOut')
self.retreatToSkySeq = Sequence(Func(self.updateRetreatToSkyPosLerp), self.retreatToSkyPosLerp, Func(self.request, 'next'), name = '%s.retreatToSkySeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.PreAttackTime
self.preAttackLerpXY = LerpFunc(self.updateAttackXY, fromData = 0.0, toData = 1.0, duration = dur)
self.preAttackLerpZ = LerpFunc(self.updateAttackZ, fromData = 0.0, toData = 1.0, duration = dur, blendType = 'easeOut')
dur = Globals.LegalEagle.PostAttackTime
self.postAttackPosLerp = LerpPosInterval(self.suit, dur, startPos = Vec3(0, 0, 0), pos = Vec3(0, 0, 0))
self.attackSeq = Sequence(Parallel(self.preAttackLerpXY, self.preAttackLerpZ), Func(self.updatePostAttackPosLerp), self.postAttackPosLerp, Func(self.request, 'next'), name = '%s.attackSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.CooldownTime
self.cooldownSeq = Sequence(Wait(dur), Func(self.request, 'next'), name = '%s.cooldownSeq-%i' % (self.__class__.__name__, self.index))
self.propTrack = Sequence(ActorInterval(self.prop, 'propeller', startFrame = 0, endFrame = 14))
self.hoverOverNestSeq = Sequence(ActorInterval(self.suit, 'landing', startFrame = 10, endFrame = 20, playRate = 0.5), ActorInterval(self.suit, 'landing', startFrame = 20, endFrame = 10, playRate = 0.5))
def enterSwim(self, ts=0, callback=None, extraArgs=[]):
self.playingAnim = 'swim'
self.loop("swim")
self.resetTorsoRotation()
toon = self.getGeomNode()
toon.setP(-89.0)
if self.shadow:
self.shadow.hide()
self.swimBobTrack = Sequence(
LerpPosInterval(toon,
duration=1,
pos=(0, -3, 3),
startPos=(0, -3, 4),
blendType='easeInOut'),
LerpPosInterval(toon,
duration=1,
pos=(0, -3, 4),
startPos=(0, -3, 3),
blendType='easeInOut'))
self.swimBobTrack.loop()
self.nametag3d.setZ(5.0)
def __getCogTrack():
def handleHit():
if self.isLocal():
cog.sendUpdate('hitByGag', [self.getID()])
startPos = cog.getPos(render)
cogFloat = Point3(0, 0, 14)
cogEndPos = Point3(startPos[0] + cogFloat[0], startPos[1] + cogFloat[1], startPos[2] + cogFloat[2])
suitType = cog.suitPlan.getSuitType()
if suitType == 'A':
startFlailFrame = 16
endFlailFrame = 16
else:
startFlailFrame = 15
endFlailFrame = 15
track = Sequence()
track.append(Func(cog.d_disableMovement))
track.append(Wait(0.5))
slipIval = Sequence(ActorInterval(cog, 'slip-backward', playRate=0.5, startFrame=0, endFrame=startFlailFrame - 1), Func(cog.pingpong, 'slip-backward', fromFrame=startFlailFrame, toFrame=endFlailFrame), Wait(0.5), Parallel(ActorInterval(cog, 'slip-backward', playRate=1.0, startFrame=endFlailFrame), Func(cog.startRay), Func(handleHit)))
slipUp = LerpPosInterval(cog, 1.1, cogEndPos, startPos=startPos, fluid=1)
slipDn = LerpPosInterval(cog, 0.6, startPos, startPos=cogEndPos, fluid=1)
geyserMotion = Sequence(slipUp, slipDn)
track.append(Parallel(slipIval, geyserMotion))
if cog.getHealth() - self.getDamage() <= 0:
track.append(Func(cog.d_enableMovement))
return track
def _initIntervals(self):
self.bgIntroLerp = LerpPosInterval(self.staticElements['bg'], duration = 1.0, pos = self.staticElements['bg'].getPos(), startPos = (0.0, 0.0, 2.0))
self.pickerIntroLerp = LerpPosInterval(self.repairGamePicker, duration = 1.0, pos = self.repairGamePicker.getPos(), startPos = (0.0, 0.0, -1.0))
self.introSequence = Sequence(Func(self.repairGamePicker.setEnabled, False), Parallel(Sequence(Wait(0.25), Func(self.guiDownSound.play)), self.bgIntroLerp, self.pickerIntroLerp), Func(self.repairGamePicker.setEnabled, True), Func(self.repairGame.gameFSM.request, 'Idle'), name = 'RepairGame.introSequence')
self.pickerOutroLerp = LerpPosInterval(self.repairGamePicker, duration = 1.0, startPos = self.repairGamePicker.getPos(), pos = (0.0, 0.0, -1.0))
self.bgOutroLerp = LerpPosInterval(self.staticElements['bg'], duration = 1.0, startPos = self.repairGamePicker.getPos(), pos = (0.0, 0.0, 2.0))
self.outroSequence = Sequence(Func(self.repairGamePicker.stashTab), Func(self.closeButton.stash), Parallel(Func(self.guiUpSound.play), Func(self.setPickerOutroStartPos), Func(self.setBGOutroStartPos), self.pickerOutroLerp, self.bgOutroLerp), Func(self.repairGame.cleanup), name = 'RepairGame.outroSequence')
self.cycleCompleteSequence = Sequence(Func(self.showCycleCompleteMessage), Func(self.repairGamePicker.stashTab), Wait(self.getCycleCompleteWaitTime()), Func(self.completeSound.play), Func(self.hideCycleCompleteMessage), LerpPosInterval(self.repairGamePicker, duration = 0.5, pos = self.repairGamePicker.getPos() - (0, 0, 1.0)), Func(self.repairGame.resetMincroGameProgress), LerpPosInterval(self.repairGamePicker, duration = 0.5, pos = self.repairGamePicker.getPos()), Func(self.repairGame.gameFSM.request, 'Idle'), name = 'RepairGame.cycleCompleteSequence')
self.shakeSequence = Sequence(name = 'RepairGameGUI.shakeSequence')
def announceGenerate(self):
"""Setup other fields dependent on the required fields."""
DistributedElevatorExt.DistributedElevatorExt.announceGenerate(self)
angle = self.startingHpr[0]
angle -= 90
radAngle = deg2Rad(angle)
unitVec = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
unitVec *= 45.0
self.endPos = self.startingPos + unitVec
self.endPos.setZ(0.5)
dist = Vec3(self.endPos - self.enteringPos).length()
wheelAngle = (dist / (4.8 * 1.4 * math.pi)) * 360
self.kartEnterAnimateInterval = Parallel(
# start a lerp HPR for each wheel
LerpHprInterval(
self.wheels[0], 5.0,
Vec3(self.wheels[0].getH(), wheelAngle,
self.wheels[0].getR())),
LerpHprInterval(
self.wheels[1], 5.0,
Vec3(self.wheels[1].getH(), wheelAngle,
self.wheels[1].getR())),
LerpHprInterval(
self.wheels[2], 5.0,
Vec3(self.wheels[2].getH(), wheelAngle,
self.wheels[2].getR())),
LerpHprInterval(
self.wheels[3], 5.0,
Vec3(self.wheels[3].getH(), wheelAngle,
self.wheels[3].getR())),
name="CogKartAnimate")
trolleyExitTrack1 = Parallel(LerpPosInterval(self.golfKart, 5.0,
self.endPos),
self.kartEnterAnimateInterval,
name="CogKartExitTrack")
self.trolleyExitTrack = Sequence(
trolleyExitTrack1,
# Func(self.hideSittingToons), # we may not need this
)
self.trolleyEnterTrack = Sequence(
LerpPosInterval(self.golfKart,
5.0,
self.startingPos,
startPos=self.enteringPos))
self.closeDoors = Sequence(self.trolleyExitTrack,
Func(self.onDoorCloseFinish))
self.openDoors = Sequence(self.trolleyEnterTrack)
def fillSlot(self, index, avId):
toon = self.cr.doId2do.get(avId)
toon.stopSmooth()
if toon:
toon.wrtReparentTo(self.trolleyCar)
if index <= 3:
slotPos = Point3(-5, -4.5 + index * 3, 1.4)
sitStartDuration = toon.getDuration('start-sit')
toon.headsUp(slotPos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon, 0.75,
Point3(-5, -4.5 + index * 3, 1.4)),
LerpHprInterval(toon, 0.25, Point3(90, 0, 0)),
Parallel(
ActorInterval(toon, 'start-sit'),
Sequence(
Wait(sitStartDuration * 0.25),
LerpPosInterval(
toon, sitStartDuration * 0.25,
Point3(-3.9, -4.5 + index * 3, 3.0)))),
Func(toon.loop, 'sit'))
else:
slotPos = self.STAND_POSITIONS[index]
toon.headsUp(slotPos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
duration=1.0,
pos=slotPos,
startPos=toon.getPos()),
Func(toon.setAnimState, 'neutral'),
Func(toon.setHpr, 90, 0, 0))
track.start()
if avId == base.localAvatar.doId:
self.localAvOnTrolley = True
base.localAvatar.stopSmartCamera()
base.camera.wrtReparentTo(self.trolleyCar)
camTrack = Sequence(
Parallel(
LerpPosInterval(base.camera,
duration=1.5,
pos=self.CAM_POS,
startPos=base.camera.getPos(),
blendType='easeOut'),
LerpQuatInterval(base.camera,
duration=1.5,
hpr=self.CAM_HPR,
startHpr=base.camera.getHpr(),
blendType='easeOut')),
Func(self.enableExitButton))
camTrack.start()
def doMolePop(self, startTime, timeToMoveUp, timeToStayUp, timeToMoveDown,
moleType):
"""Show a mole popping up.
startTime = will be based from startupTime
timeToMoveUp = number of seconds it takes to go up
timeToStayUp = how long will the mole stay up
timeToMoveDown = how long it will take for the mole to move down
"""
if self.hillType == MoleFieldBase.HILL_WHACKED or self.hillType == MoleFieldBase.HILL_COGWHACKED:
return
if self.popIval:
self.popIval.pause()
if self.downIval:
self.downIval.pause()
self.downIval = None
moleColor = None
#if moleType == MoleFieldBase.HILL_BOMB:
# moleColor = Vec4(1,0,0,1)
# self.moleColNodePath.setScale(5.0)
#else:
# moleColor = Vec4(1,1,1,1)
# self.moleColNodePath.setScale(1.0)
self.switchUp()
self.popupNum += 1
if self.hillType == MoleFieldBase.HILL_BOMB:
self.popIval = Sequence(
#Func(self.mole.setColorScale, moleColor),
Func(self.setHillType, moleType),
Func(self.moleColNodePath.unstash),
LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)),
Wait(timeToStayUp),
LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)),
Func(self.stashMoleCollision),
Func(self.switchDown),
)
else:
self.popIval = Sequence(
#Func(self.mole.setColorScale, moleColor),
Func(self.setHillType, moleType),
LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)),
Func(self.moleColNodePath.unstash),
Wait(timeToStayUp),
Func(self.stashMoleCollision),
LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)),
Func(self.switchDown),
)
self.popIval.start()
def activate(self):
if self.pressIval:
self.pressIval.finish()
self.pressIval = None
posDelta = (self.maxs - self.mins)
posDelta.componentwiseMult(Vec3.forward() * 0.9)
duration = posDelta.length() / self.speed
startPos = self.origin
endPos = self.origin + posDelta
self.pressIval = Sequence(Func(self.pressSound.play), LerpPosInterval(self, duration, endPos, startPos))
if self.wait != -1:
self.pressIval.append(Wait(self.wait))
self.pressIval.append(LerpPosInterval(self, duration, startPos, endPos))
self.pressIval.start()
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.59999999999999998
bY = -0.050000000000000003
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY), ), ((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)), ((lX, tY), (rX, tY),
(lX, bY), (rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
lerpTrack.append(
Parallel(
LerpPosInterval(panel,
lerpDur,
Point3(pos[0], 0, pos[1]),
blendType='easeInOut'),
LerpScaleInterval(panel,
lerpDur,
Vec3(panel.getScale()) * 2.0,
blendType='easeInOut')))
self.showScoreTrack = Parallel(
lerpTrack,
Sequence(Wait(IceGameGlobals.ShowScoresDuration),
Func(self.gameOver)))
self.showScoreTrack.start()
def enterEagleFall(self, startIndex, endIndex, ts=0.0):
self.moveIval = LerpPosInterval(self,
duration=4.0,
pos=self.getPos(render) - (0, 0, 75),
startPos=self.getPos(render),
blendType='easeIn')
self.moveIval.start(ts)
def updateToonPositions(self, offset):
if self.activityFSM.state != 'Active':
return
if self.isLocalToonPlaying:
camera.lookAt(self.root, offset, 0.0,
PartyGlobals.TugOfWarCameraLookAtHeightOffset)
for toonId in self.getToonIdsAsList():
if hasattr(self, 'fallenToons') and toonId not in self.fallenToons:
toon = self.getAvatar(toonId)
if toon is not None:
origPos = self.toonIdsToStartPositions[toonId]
curPos = toon.getPos(self.root)
newPos = Point3(origPos[0] + offset, curPos[1], curPos[2])
if self.toonIdsToAnimIntervals[toonId] != None:
if self.toonIdsToAnimIntervals[toonId].isPlaying():
self.toonIdsToAnimIntervals[toonId].finish()
self.checkIfFallen(toonId)
if toonId not in self.fallenToons:
self.toonIdsToAnimIntervals[toonId] = Sequence(
LerpPosInterval(toon,
duration=PartyGlobals.
TugOfWarKeyPressReportRate,
pos=newPos,
other=self.root),
Func(self.checkIfFallen, toonId))
self.toonIdsToAnimIntervals[toonId].start()
return
def getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow, dropTime, targetShadowScale, startScale=0)
shadowAlphaIval = LerpColorScaleInterval(shadow, hangTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop, dropTime, Point3(0, 0, 0), startPos=startPos, blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16, 1 - random.random() / 16, 1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(LerpScaleInterval(self.drop, 0.25, Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2, 1.0 - scaleChange), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.25, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), Func(self.disableCollisionDamage), LerpScaleInterval(self.drop, 0.2, Vec3(1.0 + scaleChange / 8, 1.0 + scaleChange / 8, 1.0 - scaleChange / 8), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.2, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.15, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 16, 1.0 - scaleChange / 16), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.15, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.1, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 8, 1.0 - scaleChange / 16), blendType='easeInOut'), LerpColorScaleInterval(self.drop, Globals.DropFadeTime, Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(Func(self.reparentTo, render), Parallel(Sequence(WaitInterval(hangTime), dropIval), shadowIval), Parallel(Func(self.game.dropHit, self, id), dropSoundIval, dropShakeSeq), Func(self.game.cleanupDrop, id), name='drop%s' % id)
self.ival = ival
return ival
