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