def loadBarrel(self): self.barrel = loader.loadModel('phase_4/models/cogHQ/gagTank') self.barrel.reparentTo(self) self.barrel.setH(self, 180) self.barrel.setScale(self.BARREL_SCALE) self.barrel.hide() dustCloud = DustCloud(fBillboard=0) dustCloud.setBillboardAxis(2.0) dustCloud.setZ(3) dustCloud.setScale(1.2) dustCloud.createTrack() Sequence(Func(dustCloud.reparentTo, self.barrel), Parallel(dustCloud.track, Func(self.barrel.show)), Func(dustCloud.destroy)).start()
def showToonThrowingGag(self, heading, pos): gag = self.equippedGag if gag is None: return self.removeGag() tossTrack, flyTrack, object = self.getThrowInterval( gag, pos[0], pos[1], pos[2], heading, 0, 0) def matchRunningAnim(toon=self.toon): toon.playingAnim = None toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed) newTossTrack = Sequence(tossTrack, Func(matchRunningAnim)) throwTrack = Parallel(newTossTrack, flyTrack) throwTrack.start(0) return object
def turnAround(self, nextState, shouldMoveRight): if self.velocity[0] < 0 and shouldMoveRight: self.velocity[0] = -self.velocity[0] elif self.velocity[0] > 0 and not shouldMoveRight: self.velocity[0] = -self.velocity[0] self.movingRight = self.velocity[0] > 0 if self.fishMoveSequence: self.fishMoveSequence.pause() self.fishMoveSequence.clearToInitial() animationToTurn = 'turn' if self.movingRight: animationToTurn = 'turnOpposite' durationOfFishTurn = self.myData['durationOfFishTurn'] self.fishMoveSequence = Parallel(Sequence(Func(self.actor.changeAnimationTo, animationToTurn, False), Wait(durationOfFishTurn), Func(self.fsm.request, nextState)), Sequence(Wait(durationOfFishTurn * 0.33), Func(self.setXVelocity, 0.0), Wait(durationOfFishTurn * 0.66), Func(self.setXVelocity, self.velocity[0])), name='%s_turnAroundInterval' % self.getName()) self.velocity[0] = -self.velocity[0] self.fishMoveSequence.start()
def startMovie(self): self.movie = Sequence() for index in xrange(self.numPlayers): track = self.createOnePlayerSequence(index, 1.25) self.movie.append(track) self.movie.append(Wait(0.75)) self.movie.append(Func(self.resultLabel.show)) soundAndWait = Parallel() soundAndWait.append(Wait(2.0)) if self.localAvatarWon: soundAndWait.append(SoundInterval(self.winVoteSfx)) elif self.localAvatarLost: soundAndWait.append(SoundInterval(self.loseVoteSfx, duration=0.43)) self.movie.append(soundAndWait) self.movie.start()
def showSplat(self): if self.kaboomTrack and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.splat.reparentTo(render) self.splat.setPos(self.suit.getPos()) self.splat.setZ(3) self.kaboomTrack = Parallel( SoundInterval(self.pieHitSound, volume=1.0), Sequence( Func(self.splat.showThrough), LerpScaleInterval(self.splat, duration=0.5, scale=1.75, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Func(self.splat.hide))) self.kaboomTrack.start()
def enterWaitReward(self): self.scoreBoard.showBoardFinal() if self.curHoleDoId != 0: av = base.cr.doId2do.get(self.curHoleDoId) av.cleanupPowerBar() def doneWithRewardMovie(): if self.exit == False: self.notify.debug('doneWithRewardMovie') self.sendUpdate('setDoneReward', []) self._destroyDelayDelete() self.exit = True self.golfRewardDialog = GolfRewardDialog.GolfRewardDialog(self.avIdList, self.trophiesList, self.rankingsList, self.holeBestList, self.courseBestList, self.cupList, self.localAvId, self.tieBreakWinner, self.aimTimesList) self.rewardIval = Sequence(Parallel(Wait(5), self.golfRewardDialog.getMovie()), Func(doneWithRewardMovie)) self.rewardIval.start()
def enterLeftDoorOpening(self, ts=0): if self.leftTrack: self.leftTrack.finish() self.leftTrack = None self.leftTrack = Sequence( Wait(0.5), Parallel( Func(self.toggleDoorHole, 'left', True), LerpQuatInterval(self.leftDoor, duration=0.7, quat=(self.getLeftDoorOpenH(), 0, 0), startHpr=(self.getLeftDoorClosedH(), 0, 0), blendType='easeInOut'), SoundInterval(self.doorOpenSound, node=self.leftDoor))) self.leftTrack.start() return
def doCameraNPCInteraction(self): currCamPos = camera.getPos() currCamHpr = camera.getHpr() camera.setX(camera.getX() + 5) camera.setY(camera.getY() + 5) camera.headsUp(self) newCamPos = camera.getPos() newCamHpr = camera.getHpr() camera.setPos(currCamPos) camera.setHpr(currCamHpr) self.cameraTrack = Parallel( LerpPosInterval(camera, duration = 1.0, pos = newCamPos, startPos = currCamPos, blendType = 'easeOut'), LerpQuatInterval(camera, duration = 1.0, quat = newCamHpr, startHpr = currCamHpr, blendType = 'easeOut') ) self.cameraTrack.start()
def move_camp_unit(self, sens): if self.nb_saves == 0 or self.nb_saves == 1: return if sens == 2: #capture depuis le click souris if self.app.lst_arrows[2]["status"] == 2: sens = 0 elif self.app.lst_arrows[3]["status"] == 2: sens = 1 else: return pos_texts = [(0.3, 0, 0.2), (0, 0, 0), (0.3, 0, -0.5), (0.4, 0, -0.6), (0.5, 0, -0.68)] scale_texts = [0.08, 0.1, 0.08, 0.07, 0.05] if sens == 0 and self.lst_menus[2] == (self.nb_saves - 1): return elif sens == 1 and self.lst_menus[2] == 0: return if sens == 0: if self.lst_menus[2] == 0: self.app.lst_arrows[3]["node"].show() if self.lst_menus[2] == (self.nb_saves - 2): self.app.lst_arrows[2]["node"].hide() if self.lst_menus[2] > 0: self.gui_saves[self.lst_menus[2] - 1][4].hide() if self.lst_menus[2] + 4 < self.nb_saves: self.gui_saves[self.lst_menus[2] + 4][4].show() self.arc_aux_menu.play("down") self.lst_menus[2] += 1 elif sens == 1: if self.lst_menus[2] == 1: self.app.lst_arrows[3]["node"].hide() if self.lst_menus[2] == (self.nb_saves - 1): self.app.lst_arrows[2]["node"].show() if self.lst_menus[2] > 1: self.gui_saves[self.lst_menus[2] - 2][4].show() if self.lst_menus[2] + 3 < self.nb_saves: self.gui_saves[self.lst_menus[2] + 3][4].hide() self.arc_aux_menu.play("up") self.lst_menus[2] -= 1 self.lst_gui["camp_frame"][10]["text"] = self.gui_saves[ self.lst_menus[2]][2] self.lst_gui["camp_frame"][11]["text"] = self.gui_saves[ self.lst_menus[2]][1] movePara = Parallel(name="texts_move") start = (1 if self.lst_menus[2] == 0 else 0) end = (self.nb_saves - self.lst_menus[2] + 1 if (self.nb_saves - self.lst_menus[2]) < 5 else 5) for it in range(start, end): movePara.append(self.gui_saves[self.lst_menus[2] - 1 + start + (it - start)][4].posInterval( 0.2, Point3(pos_texts[it]))) movePara.append(self.gui_saves[self.lst_menus[2] - 1 + start + (it - start)][4].scaleInterval( 0.2, scale_texts[it])) movePara.start()
def showSuitsFalling(self, suits, ts, name, callback): if self.bossCog == None: return else: suitTrack = Parallel() delay = 0 for suit in suits: suit.setState('Battle') if suit.dna.dept == 'l': suit.reparentTo(self.bossCog) suit.setPos(0, 0, 0) if suit in self.joiningSuits: i = len(self.pendingSuits) + self.joiningSuits.index(suit) destPos, h = self.suitPendingPoints[i] destHpr = VBase3(h, 0, 0) else: destPos, destHpr = self.getActorPosHpr(suit, self.suits) startPos = destPos + Point3( 0, 0, SuitTimings.fromSky * ToontownGlobals.SuitWalkSpeed) self.notify.debug('startPos for %s = %s' % (suit, startPos)) suit.reparentTo(self) suit.setPos(startPos) suit.headsUp(self) moveIval = Sequence() chairInfo = self.bossCog.claimOneChair() if chairInfo: moveIval = self.createDinerMoveIval( suit, destPos, chairInfo) suitTrack.append( Track((delay, Sequence(moveIval, Func(suit.loop, 'neutral'))))) delay += 1 if self.hasLocalToon(): camera.reparentTo(self) self.notify.debug('self.battleSide =%s' % self.battleSide) camHeading = -20 camX = -4 if self.battleSide == 0: camHeading = 20 camX = 4 camera.setPosHpr(camX, -15, 7, camHeading, 0, 0) done = Func(callback) track = Sequence(suitTrack, done, name=name) track.start(ts) self.storeInterval(track, name) return
def startAction(self, action): cur_action = self.cur_action rotation = self.actions[cur_action].rotation self.cur_action = action paction = self.actions[action] if cur_action != "stand": diff = self.joint.getPos(render) - paction.diff else: diff = self.actor.getPos() if self.print_action: print paction.name, interval = self.actor.actorInterval(paction.name) func = Func(self.reposition, diff, rotation) self.sequence = Parallel(Sequence(Wait(0.001), func), interval) self.sequence.start()
def showGrab(self): self.nodePath.hide() self.collNodePath.hide() # disable collisions self.collNode.setIntoCollideMask(BitMask32(0)) if self.penalty: self.track = Parallel( SoundInterval(self.penaltyGrabSound), Sequence( Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration=0.5, scale=Point3(10, 10, 10), blendType='easeOut'), Func(self.kaboom.hide), )) self.track.start()
def release(self): if self.isLocal(): self.startTimeout() self.resetCrashEffect() LocationGag.release(self) self.build() self.isDropping = True actorTrack = LocationGag.getActorTrack(self) self.fallSoundInterval = LocationGag.getSoundTrack(self) if actorTrack: actorTrack.append(Func(self.startDrop)) actorTrack.start() self.fallSoundInterval.append( Parallel(SoundInterval(self.fallSfx, node=self.avatar))) self.fallSoundInterval.start() if self.isLocal(): base.localAvatar.sendUpdate('usedGag', [self.id])
def getAvatarEnterTrack(self, av): track = Sequence(name = av.uniqueName('avatarEnterDoorTrack')) track.append(Func(av.setAnimState, 'walkBack')) track.append( ParallelEndTogether( LerpPosInterval( av, duration = 0.5, blendType = 'easeInOut', pos = self.enterWalkBackPos, startPos = av.getPos(render) ), LerpQuatInterval( av, duration = 0.5, hpr = self.doorNode.getHpr(render), startHpr = av.getHpr(render) ) ) ) track.append(Func(av.setPlayRate, 1.0, 'walk')) track.append(Func(av.loop, 'neutral')) track.append(Wait(1.0)) track.append(Func(av.loop, 'walk')) parallel = Parallel() parallel.append( LerpPosInterval( av, duration = 1.0, blendType = 'easeInOut', pos = self.enterWalkInPos, startPos = self.enterWalkBackPos ) ) if base.localAvatar.doId == av.doId: parallel.append(LerpPosHprInterval(nodePath = camera, other = av, duration = 1.0, pos = (0, -8, av.getHeight()), hpr = (0, 0, 0), blendType = 'easeInOut')) parallel.append(Sequence(Wait(0.5), Func(self.sendGoingIn), Wait(1.0))) track.append(parallel) if base.localAvatar.doId == av.doId: track.append(Func(self.sendWentInDoor)) track.setDoneEvent(track.getName()) track.delayDelete = DelayDelete.DelayDelete(av, track.getName()) self.acceptOnce(track.getDoneEvent(), self.__avatarTrackDone, [track]) return track
def __shrinkLoadingBar(self): if self.__isValidDownloadBar(): ivalDuration = 0.5 barPosIval = LerpPosInterval(self.bar, ivalDuration, (-0.81, 0, -0.96)) barScaleIval = LerpScaleInterval(self.bar, ivalDuration, (0.25, 0.25, 0.25)) def posText(pos): self.bar['text_pos'] = (0, pos) def scaleText(scale): self.bar['text_scale'] = (scale, scale) textScaleIval = LerpFunc(scaleText, fromData=0.08, toData=0.16, duration=ivalDuration) textPosIval = LerpFunc(posText, fromData=-0.035, toData=-0.05, duration=ivalDuration) shrinkIval = Parallel(barPosIval, barScaleIval, textPosIval, textScaleIval, Func(self.loadingText.hide)) self.hideBlockerIval = Sequence(shrinkIval, Wait(0.5), Func(self.__hideBlocker), Func(self.__resetLoadingBar), Func(self.destroy)) self.hideBlockerIval.start()
def doHit(self): self.cleanupHit() if not self.headActor: return self.hitInterval = Sequence( Parallel( Sequence( Func(self.headActor.setColorScale, 1, 1, 1, 1), self.headActor.colorScaleInterval(0.1, colorScale=VBase4(1, 0, 0, 1)), self.headActor.colorScaleInterval(0.3, colorScale=VBase4(1, 1, 1, 1)) ), ActorInterval(self.headActor, 'turn2Fb') ), Func(self.headActor.loop, 'Ff_neutral') ) self.hitInterval.start()
def onShipDamaged(self, wasGrapeshot = False): if wasGrapeshot: shakeDelta = 0.050000000000000003 randomX = random.random() * 2 * shakeDelta - shakeDelta randomZ = random.random() * 2 * shakeDelta - shakeDelta if self.shakeSequence.isPlaying(): self.shakeSequence.finish() self.shakeSequence = Parallel(Sequence(LerpColorScaleInterval(self, duration = 0.5, colorScale = (1.0, 0.20000000000000001, 0.20000000000000001, 1.0)), LerpColorScaleInterval(self, duration = RepairGlobals.Common.guiShakeCooldownTime / 2.0, colorScale = (1.0, 1.0, 1.0, 1.0))), Sequence(LerpPosInterval(self, duration = 0.10000000000000001, pos = self.getPos() - (randomX, 0.0, randomZ)), LerpPosInterval(self, duration = 0.20000000000000001, pos = self.getPos() + (randomX, 0.0, randomZ)), LerpPosInterval(self, duration = 0.10000000000000001, pos = self.getPos()), Wait(RepairGlobals.Common.guiShakeCooldownTime)), name = 'RepairGameGUI.shakeSequence') self.shakeSequence.start() else: shakeDelta = 0.025000000000000001 randomX = random.random() * 2 * shakeDelta - shakeDelta randomZ = random.random() * 2 * shakeDelta - shakeDelta if not self.shakeSequence.isPlaying(): self.shakeSequence = Sequence(LerpPosInterval(self, duration = 0.10000000000000001, pos = self.getPos() - (randomX, 0.0, randomZ)), LerpPosInterval(self, duration = 0.20000000000000001, pos = self.getPos() + (randomX, 0.0, randomZ)), LerpPosInterval(self, duration = 0.10000000000000001, pos = self.getPos()), Wait(RepairGlobals.Common.guiShakeCooldownTime), name = 'RepairGameGUI.shakeSequence') self.shakeSequence.start()
def enterBiting(self): self.fish.startBiteBubbleEffect() if self.fish.myData['size'] == 'small': biteSFX = self.fish.fishManager.gameObject.sfx['biteSmall'] elif self.fish.myData['size'] == 'medium': biteSFX = self.fish.fishManager.gameObject.sfx['biteSmall'] elif self.fish.myData['size'] == 'large': biteSFX = self.fish.fishManager.gameObject.sfx['biteLarge'] elif self.fish.myData['size'] == 'super': biteSFX = self.fish.fishManager.gameObject.sfx['biteLarge'] if self.fish.getX() < self.fish.fishManager.gameObject.lure.getX(): self.fish.actor.changeAnimationTo('bite', False) biteOffset = self.fish.mouthJoint.getPos( ) * -1.0 * self.fish.actor.getSx() else: self.fish.actor.changeAnimationTo('biteOpposite', False) biteOffset = self.fish.mouthJoint.getPos( ) * -1.0 * self.fish.actor.getSx() self.fish.fishManager.activeFish = self.fish if self.fish.fishMoveSequence: self.fish.fishMoveSequence.pause() biteDuration = 1.083 self.fish.fishManager.gameObject.lureAngle = 0 self.fish.wrtReparentTo(self.fish.fishManager.gameObject.lure) self.fish.fishStatusIconNodePath.setScale(1.0) (self.fish.fishStatusIconNodePath.show(), ) self.fish.fishStatusIconTextNode.setText('?') self.fish.fishStatusIconTextNode.setTextColor(1.0, 1.0, 0.0, 1.0) self.fish.fishManager.gameObject.sfx['biteAlert'].play() self.fish.fishManager.gameObject.scareFish = False self.fish.fishMoveSequence = Sequence(Parallel( Sequence( Wait(biteDuration * FishingGlobals.biteWindowStartPercentage), Func(self.checkForBite), Func(self.fish.fishStatusIconNodePath.show), Func(self.fish.fishStatusIconTextNode.setText, '!'), Func(self.fish.fishStatusIconTextNode.setTextColor, 0.0, 1.0, 0.0, 1.0), Func(base.playSfx, biteSFX), Wait(biteDuration * FishingGlobals.biteWindowFinishPercentage), Func(self.fish.fishManager.gameObject.checkForHooked)), self.fish.posInterval(biteDuration / 2.0, biteOffset)), name='%s_MoveSequence' % self.fish.getName()) self.fish.fishMoveSequence.start()
def showKaboom(self): if self.kaboomTrack and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.kaboom.reparentTo(render) self.kaboom.setPos(self.suit.getPos()) self.kaboom.setZ(3) self.kaboomTrack = Parallel( SoundInterval(self.kaboomSound, volume=0.5), Sequence( Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration=0.5, scale=Point3(10, 10, 10), startScale=Point3(1, 1, 1), blendType='easeOut'), Func(self.kaboom.hide))) self.kaboomTrack.start()
def _afterShootTrackDone(self): self.track = None self.track = Parallel( Sequence( LerpQuatInterval(self.cannon.find('**/cannon'), duration = 3, quat = (60, 0, 0), startHpr = Vec3(-60, 0, 0), blendType = 'easeInOut'), LerpQuatInterval(self.cannon.find('**/cannon'), duration = 3, quat = (-60, 0, 0), startHpr = Vec3(60, 0, 0), blendType = 'easeInOut'), ), Sequence( LerpQuatInterval(self.cannon.find('**/square_drop_shadow'), duration = 3, quat = (60, 0, 0), startHpr = Vec3(-60, 0, 0), blendType = 'easeInOut'), LerpQuatInterval(self.cannon.find('**/square_drop_shadow'), duration = 3, quat = (-60, 0, 0), startHpr = Vec3(60, 0, 0), blendType = 'easeInOut'), ) ) self.track.loop()
def serveFood(self, food, chairIndex): self.removeFoodModel(chairIndex) serviceLoc = self.serviceLocs.get(chairIndex) if not food or food.isEmpty(): foodModel = loader.loadModel('phase_12/models/bossbotHQ/canoffood') foodModel.setScale(ToontownGlobals.BossbotFoodModelScale) foodModel.reparentTo(serviceLoc) else: food.wrtReparentTo(serviceLoc) tray = food.find('**/tray') if not tray.isEmpty(): tray.hide() ivalDuration = 1.5 foodMoveIval = Parallel(SoundInterval(self.serveFoodSfx, node=food), ProjectileInterval(food, duration=ivalDuration, startPos=food.getPos(serviceLoc), endPos=serviceLoc.getPos(serviceLoc)), LerpHprInterval(food, ivalDuration, Point3(0, -360, 0))) intervalName = 'serveFood-%d-%d' % (self.index, chairIndex) foodMoveIval.start() self.activeIntervals[intervalName] = foodMoveIval
def onSetAction(self, action): self.model.show() self.avatar.doingActivity = False if action == self.StateThrow: self.avatar.doingActivity = True time = 0.0#3.0 * 0.667 sf = self.ThrowObjectFrame#0 self.setAnimTrack( Parallel(self.getAnimationTrack('throw-object', startFrame=sf, playRate=(self.PlayRate * self.ReleasePlayRateMultiplier), fullBody = False), Sequence(Wait(time), Func(self.model.hide))), startNow = True)
def enterAnim(self): if self.gameObject.gameBoard.pieceNotDropped: self.gameObject.gameBoard.pieceNotDropped = False base.playSfx(self.Sfxs['NoDrop']) if len(self.gameObject.animationList) > 0: if self.gameObject.gameBoard.pieceDropped: self.gameObject.gameBoard.pieceDropped = False self.gameObject.animationList.append(Sequence(Wait(0.29999999999999999), Func(self.playDrop))) if self.gameObject.gameBoard.delayDropped: self.gameObject.gameBoard.delayDropped = False self.gameObject.animationList.append(Sequence(Wait(0.80000000000000004), Func(self.playSoftDrop))) if self.gameObject.gameBoard.pieceFlipped: self.gameObject.gameBoard.pieceFlipped = False base.playSfx(self.Sfxs['Flip']) if self.gameObject.gameBoard.experementMatched: self.gameObject.gameBoard.experementMatched = False base.playSfx(self.Sfxs['Fill']) if self.gameObject.gameBoard.experementFailed: self.gameObject.gameBoard.experementFailed = False base.playSfx(self.Sfxs['Wrong']) if self.gameObject.soulMade: self.gameObject.soulMade = False self.gameObject.animationList.append(Sequence(Wait(0.10000000000000001), Func(self.playSoulMade))) if self.gameObject.soulMatch: self.gameObject.soulMatch = False self.gameObject.animationList.append(Sequence(Wait(0.10000000000000001), Func(self.playSoulMatch))) if self.matchMade: self.matchMade = False self.gameObject.animationList.append(Sequence(Wait(0.10000000000000001), Func(self.playMatch))) if self.ingredientMade: self.ingredientMade = False self.gameObject.animationList.append(Sequence(Wait(0.10000000000000001), Func(self.playFill))) self.animSeq = Sequence(Parallel(*self.gameObject.animationList), Func(self.request, 'Eval')) self.animSeq.start() else: self.demand('Eval')
def dropBoard(self): board = self.currentBoard boardIndex = self.currentBoardIndex self.dropBoardSequence = Sequence( Parallel( Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5), Func(self.boardDestroyedLabel.stash)), Sequence( Wait(0.5), Func(self.boardDestroyed.play), Func(self.sawingLine.reset), LerpPosInterval(board, duration=self.config.splitBoardAnimTime, pos=Point3(0.0, 0.0, -2.0)), Func(board.stash), Wait(0.5), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex))), name='RepairSawGame.dropBoardSequence') self.dropBoardSequence.start()
def fireWater(self, origin, target): color = VBase4(0.75, 0.75, 1, 0.8) dScaleUp = 0.1 dHold = 0.3 dScaleDown = 0.1 horizScale = 0.1 vertScale = 0.1 sprayTrack = self.getSprayTrack(color, origin, target, dScaleUp, dHold, dScaleDown, horizScale, vertScale) duration = self.squirtSfx.length() if sprayTrack.getDuration() < duration: duration = sprayTrack.getDuration() soundTrack = SoundInterval(self.squirtSfx, node=self.waterPitcherModel, duration=duration) self.fireTrack = Parallel(sprayTrack, soundTrack) self.fireTrack.start()
def generateToonJumpTrack(self, av, seatIndex): av.pose('sit', 47) hipOffset = av.getHipsParts()[2].getPos(av) 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 getToonSitTrack(av): toonSitTrack = Sequence(ActorInterval(av, 'sit-start'), Func(av.loop, 'sit')) return toonSitTrack toonJumpTrack = getToonJumpTrack(av, seatIndex) toonSitTrack = getToonSitTrack(av) jumpTrack = Sequence(Parallel(toonJumpTrack, Sequence(Wait(1), toonSitTrack))) return jumpTrack
def doSplat(self): if self.splatTrack and self.splatTrack.isPlaying(): self.splatTrack.finish() self.splat.reparentTo(render) self.splat.setPos(self.object, 0, 0, 3.0) self.splat.setY(self.splat.getY() - 1.0) self._splatSfxIval.node = self.splat self.splatTrack = Parallel( self._splatSfxIval, Sequence( Func(self.splat.showThrough), LerpScaleInterval(self.splat, duration=0.5, scale=6, startScale=1, blendType='easeOut'), Func(self.splat.hide))) self.splatTrack.start()
def createOnePlayerSequence(self, index, duration): numVotes = self.votes[index] direction = self.directions[index] def ticketTicker(t, label = self.entryList[index][direction + 1], startVotes = 0, endVotes = numVotes): label['text'] = str(int(t * endVotes + startVotes)) track = Parallel() startVotes = 0 for prev in range(index): if self.directions[prev] == direction: startVotes += self.votes[prev] def totalTicker(t, label = self.totalVotesLabels[direction], startVotes = startVotes, additionalVotes = numVotes): label['text'] = str(int(t * additionalVotes + startVotes)) track.append(LerpFunc(totalTicker, duration=duration, name='countTotal %d' % index)) if self.avVotesLabel.has_key(index): def avVotesTicker(t, label = self.avVotesLabel[index], startVotes = 0, endVotes = numVotes, direction = direction): oldValue = label['text'] newValue = int(t * endVotes + startVotes) label['text'] = str(newValue) if not oldValue == label['text']: if newValue: if direction == 0: self.upArrowSfx[self.curArrowSfxIndex].play() else: self.downArrowSfx[self.curArrowSfxIndex].play() self.curArrowSfxIndex += 1 if self.curArrowSfxIndex >= len(self.upArrowSfx): self.curArrowSfxIndex = 0 label = self.avVotesLabel[index] track.append(Func(self.avVotesLabel[index].show, name='showName %d' % index)) if self.avArrows.has_key(index): track.append(Func(self.avArrows[index].show, name='showArrow %d' % index)) if direction == 0 and numVotes: pass elif direction == 1 and numVotes: pass else: track.append(SoundInterval(self.noVoteSfx)) track.append(LerpFunc(avVotesTicker, duration=duration, name='countAvVotes %d' % index)) return track
def draw(self): if self.isClickable(): foreground, background = self.whisperColor[self.clickState] else: foreground, background = self.whisperColor[PGButton.SInactive] self.chatBalloon = ChatBalloon(NametagGlobals.chatBalloon2dModel, NametagGlobals.chatBalloon2dWidth, NametagGlobals.chatBalloon2dHeight, self.textNode, foreground=foreground, background=background) self.chatBalloon.reparentTo(self.contents) # Calculate the center of the TextNode: left, right, bottom, top = self.textNode.getFrameActual() center = self.contents.getRelativePoint(self.chatBalloon.textNodePath, ((left + right) / 2.0, 0, (bottom + top) / 2.0)) # Translate the chat balloon along the inverse: self.chatBalloon.setPos(self.chatBalloon, -center) # Draw the quit button: self.quitButton = WhisperQuitButton(self) quitButtonNodePath = self.contents.attachNewNode(self.quitButton) # Move the quit button to the top right of the TextNode: quitButtonNodePath.setPos( self.contents.getRelativePoint(self.chatBalloon.textNodePath, (right, 0, top))) # Apply the quit button shift: quitButtonNodePath.setPos(quitButtonNodePath, self.QUIT_BUTTON_SHIFT) # Allow the quit button to close this whisper: self.quitButton.setClickEvent(self.quitEvent) Parallel( LerpColorScaleInterval(self.contents, .2, VBase4(1, 1, 1, 1), VBase4(1, 1, 1, 0)), Sequence( LerpScaleInterval(self.contents, .2, (self.CONTENTS_SCALE + 0.01), (0)), LerpScaleInterval(self.contents, .09, (self.CONTENTS_SCALE)))).start()
def doLipstick(self, target): dScale = 0.5 tLips = 2.5 animDuration = base.localAvatar.getDuration(self.avAnim) tThrow = 115.0 / base.localAvatar.getFrameRate(self.avAnim) def doHeal(): if self.isLocal(): self.setHealAmount() self.healAvatar(target, 'conked') base.localAvatar.sendUpdate('gagRelease', [self.getID()]) else: Func(target.play, 'conked').start() self.placeProp(self.handJoint, self.gag, Point3(-0.27, -0.24, -0.95), Point3(-118, -10.6, -25.9)) stickScaleUp = self.getScaleTrack([self.gag], dScale, GagGlobals.PNT3NEAR0, GagGlobals.PNT3NORMAL) stickScaleDn = self.getScaleTrack([self.gag], dScale, GagGlobals.PNT3NORMAL, GagGlobals.PNT3NEAR0) stickTrack = Sequence(stickScaleUp, Wait(animDuration - 2.0 * dScale), stickScaleDn) lipsTrack = Sequence( Wait(tLips), Func(self.avatar.pose, self.avAnim, 57), Func(self.avatar.update, 0), Func(self.placeProp, render, self.lips, self.gag.getPos(render)), Func(self.lips.setBillboardPointWorld), LerpScaleInterval(self.lips, dScale, Point3(3, 3, 3), startScale=GagGlobals.PNT3NEAR0), Wait(tThrow - tLips - dScale), LerpPosInterval(self.lips, dScale, Point3(target.getPos()), startPos=self.gag.getPos(render)), Sequence(Func(doHeal)), Func(self.cleanupLips)) delay = tThrow + dScale mainTrack = Parallel(stickTrack, lipsTrack, self.getSoundTrack(delay, self.avatar, 2), ActorInterval(self.avatar, self.avAnim)) mainTrack.start()