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 lose(self, wait=5.0, duration=2.0): if self.lost: return def adjustMusicVol(vol): self.musicManager.setVolume(vol) def adjustSfxVol(vol): self.sfxManagerList[0].setVolume(vol) from direct.gui.DirectGui import OnscreenText, DGG from direct.interval.IntervalGlobal import Parallel, Sequence, Wait, LerpFunc, Func fadeIval = base.transitions.getFadeOutIval(duration) diedText = OnscreenText(text="You failed to save Flippy!\nYou lose!", fg=(1, 1, 1, 1)) diedText.reparentTo(aspect2d, DGG.FADE_SORT_INDEX + 1) diedText.setAlphaScale(0) textFadeIval = diedText.colorScaleInterval(duration, (1, 1, 1, 1), (1, 1, 1, 0)) Sequence( Wait(wait), Parallel( fadeIval, textFadeIval, LerpFunc(adjustMusicVol, duration, self.musicManager.getVolume(), 0.0), LerpFunc(adjustSfxVol, duration, self.sfxManagerList[0].getVolume(), 0.0)), Func(self.leaveGame)).start() self.lost = True
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() track.append( Func(self.entryList[index][0].show, name='showName %d' % index)) track.append( LerpFunc(ticketTicker, duration=duration, name='countVotes %d' % index)) startVotes = 0 for prev in xrange(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)) return track
def __init__(self, type, index, model, collSolid, motionPath = None, motionPattern = None, blendMotion = True, instanceModel = True): self.type = type self.index = index name = 'CogdoFlyingObstacle-%s-%i' % (self.type, self.index) if instanceModel: self.model = NodePath(name) model.instanceTo(self.model) else: self.model = model self.model.setName(name) self.currentT = 0.0 self.direction = 1.0 self.collNode = None self._initCollisions(name, collSolid) self.motionPath = motionPath self.motionPattern = motionPattern self.motionSequence = None if blendMotion: blendType = 'easeInOut' else: blendType = 'noBlend' if motionPath is not None: def moveObstacle(value): self.motionPath.goTo(self.model, value) self.motionPath = Mopath.Mopath(name='obstacle-%i' % self.index) self.motionPath.loadNodePath(motionPath) dur = self.motionPath.getMaxT() self.motionSequence = Sequence(name='%s.obstacle-%i-motionSequence' % (self.__class__.__name__, self.index)) movePart1 = LerpFunc(moveObstacle, fromData=0.0, toData=self.motionPath.getMaxT(), duration=dur, blendType=blendType) self.motionSequence.append(movePart1) if self.motionPattern == CogdoFlyingObstacle.MotionTypes.BackForth: movePart2 = LerpFunc(moveObstacle, fromData=self.motionPath.getMaxT(), toData=0.0, duration=dur, blendType=blendType) self.motionSequence.append(movePart2)
def createOnePlayerSequence(self, index, duration): """ create a sequence for one player """ 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() #track.append(Func(self.entryList[index][0].show, name='showName %d' % index)) #track.append(LerpFunc(ticketTicker,duration=duration, name='countVotes %d'% index)) # lets figure out the total before 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 index in self.avVotesLabel: 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 index in self.avArrows: track.append(Func(self.avArrows[index].show, name='showArrow %d' % index)) if direction == 0 and numVotes: #track.append(SoundInterval(self.upArrowSfx)) pass elif direction == 1 and numVotes: #track.append(SoundInterval(self.downArrowSfx)) pass else: track.append(SoundInterval(self.noVoteSfx)) track.append(LerpFunc(avVotesTicker,duration=duration, name='countAvVotes %d'% index)) return track
def set_scene(self, scene_module): # self.transitions.fadeOut(0.2) args = [] if self.scene: args.append( Parallel(Func(self.fade_out), LerpFunc(self.blur_out, duration=0.2))) args.append(Wait(0.2)) args.append(Func(self._set_scene, scene_module)) args.append( Parallel(Func(self.fade_in), LerpFunc(self.blur_in, duration=0.4))) Sequence(*args).start()
def getAlertPulse(text, toScale1=0.12, toScale2=0.1): def change_text_scale(num): text.setScale(num) seq = Sequence( LerpFunc(change_text_scale, duration=0.3, toData=toScale1, fromData=0.01, blendType='easeOut'), LerpFunc(change_text_scale, duration=0.2, toData=toScale2, fromData=toScale1, blendType='easeInOut'), Wait(3.0), Func(text.setText, '')) return seq
def endScan(self): if self.shootTrack: self.shootTrack.finish() if self.lightScanIval: self.lightScanIval.pause() taskMgr.remove(self.taskName("scanTask")) self.scanLoopSound.stop() self.shootTrack = Parallel( SoundInterval(self.scanEndSound, node=self), Sequence( LerpHprInterval(self.scannerMdl, duration=0.25, hpr=(180, 0, 0), startHpr=self.scannerMdl.getHpr()), LerpScaleInterval(self.scannerMdl, duration=0.7, scale=(0.3, 2, 1), startScale=(2, 2, 1)), LerpScaleInterval(self.scannerMdl, duration=0.7, scale=(0.01, 0.01, 0.01), startScale=(0.3, 2, 1)), Func(self.scannerMdl.hide), LerpFunc(self.blendAnimFromBase, fromData=1, toData=0, duration=0.5, extraArgs=['scan']))) self.shootTrack.start()
def enterScan(self): self.setPlayRate(1, "scan") self.pingpong("scan", fromFrame=94, toFrame=96) self.scannerMdl.setHpr(180, 0, 0) self.shootTrack = Sequence( LerpFunc(self.blendAnimFromBase, fromData=0, toData=1, duration=0.5, extraArgs=['scan']), Parallel( SoundInterval(self.scanBeginSound, node=self), Func(self.scannerMdl.show), Sequence( LerpScaleInterval(self.scannerMdl, duration=0.5, scale=(0.3, 2, 1), startScale=(0.01, 0.01, 0.01)), LerpScaleInterval(self.scannerMdl, duration=0.5, scale=(2, 2, 1), startScale=(0.3, 2, 1)), LerpHprInterval(self.scannerMdl, duration=0.25, hpr=(180, 20, 0), startHpr=(180, 0, 0)))), Func(self.beginScan)) self.shootTrack.start()
def fadeAudio(self, time, audio, start, end): from direct.interval.IntervalGlobal import LerpFunc def __changeMusicVolume(vol): audio.setVolume(vol) LerpFunc(__changeMusicVolume, time, start, end).start()
def requestChangeVolume(self, duration, finalVolume, priority): if priority < self.curPriority: return self.curPriority = priority if not self.sfx.getActive(): if self.reloadAttempt < 1: self.reloadAttempt += 1 if self.isMusic: self.sfx = loader.loadMusic(self.path) else: self.sfx = loader.loadSfx(self.path) if self.sfx: self.sfx.setLoop(self.loop) self.duration = duration self.startVolume = self.getVolume() self.finalVolume = finalVolume if self.activeInterval: self.activeInterval.pause() del self.activeInterval self.activeInterval = Sequence( LerpFunc(self.changeVolumeTask, fromData=self.startVolume, toData=self.finalVolume, duration=self.duration)) self.activeInterval.start()
def _initIntervals(self): self.streamerIvals = [] minDur = Globals.Gameplay.FanStreamerMinDuration maxDur = Globals.Gameplay.FanStreamerMaxDuration for streamer in self.streamers: dur = random.uniform(minDur, maxDur) streamerLerp = LerpFunc(streamer.setH, fromData=0.0, toData=360.0, duration=dur, name='%s.streamerLerp%i-%s' % (self.__class__.__name__, self.index, streamer.getName())) self.streamerIvals.append(streamerLerp)
def initPlayer(self): #load man self.man = render.attachNewNode( 'man') # keep this node scaled to identity self.man.setPos(0, 0, 10) # camera base.camera.reparentTo(self.man) base.camera.setPos(0, 0, 1.7) base.camLens.setNearFar(.1, 1000) base.disableMouse() #create a collsion solid around the man manC = self.man.attachCollisionSphere('manSphere', 0, 0, 1, .4, self.groundCollBit, self.collBitOff) self.pusher.addCollider(manC, self.man) base.cTrav.addCollider(manC, self.pusher) speed = 4 Forward = Vec3(0, speed * 2, 0) Back = Vec3(0, -speed, 0) Left = Vec3(-speed, 0, 0) Right = Vec3(speed, 0, 0) Stop = Vec3(0) self.walk = Stop self.strife = Stop self.jump = 0 taskMgr.add(self.move, 'move-task') self.jumping = LerpFunc(Functor(self.__setattr__, "jump"), duration=.5, fromData=.4, toData=0) self.accept("escape", sys.exit) self.accept("space", self.startJump) self.accept("s", self.__setattr__, ["walk", Back]) self.accept("w", self.__setattr__, ["walk", Forward]) self.accept("s-up", self.__setattr__, ["walk", Stop]) self.accept("w-up", self.__setattr__, ["walk", Stop]) self.accept("a", self.__setattr__, ["strife", Left]) self.accept("d", self.__setattr__, ["strife", Right]) self.accept("a-up", self.__setattr__, ["strife", Stop]) self.accept("d-up", self.__setattr__, ["strife", Stop]) self.accept("wheel_up", self.nextWeapon) self.accept("wheel_down", self.prevWeapon) self.accept("1", self.Pistol) self.accept("2", self.Shotgun) self.accept("3", self.M4) self.accept("4", self.Scar) self.accept('mouse1', self.onMouseTask) #add mouse collision to our world self.setupMouseCollision() self.manGroundColNp = self.man.attachCollisionRay( 'manRay', 0, 0, .6, 0, 0, -1, self.groundCollBit, self.collBitOff) self.manGroundHandler = CollisionHandlerGravity() self.manGroundHandler.addCollider(self.manGroundColNp, self.man) base.cTrav.addCollider(self.manGroundColNp, self.manGroundHandler)
def showAlert(self, text): self.stopPulse() def change_text_scale(num): self.alertText.setScale(num) base.playSfx(self.popupSound) self.alertText.setText(text) self.alertPulse = Sequence( LerpFunc(change_text_scale, duration=0.3, toData=0.12, fromData=0.01, blendType='easeOut'), LerpFunc(change_text_scale, duration=0.2, toData=0.1, fromData=0.12, blendType='easeInOut'), Wait(1.5), Func(self.alertText.setText, '')) self.alertPulse.start()
def reorientNorth(self, time=0.0): self.setNorth(Vec3(0, 1, 0)) curQ = self.getInternalQuat() pt = self.getCamRayCollision() upQ = self.getUprightCorrectionQuat(pt) def rotateFunc(t): self._rotateQuatByQuat(curQ, upQ, t) if self._ballIval: self._ballIval.pause() self._ballIval = LerpFunc(rotateFunc, duration=time) self._ballIval.start()
def setup_credits(self, data): base.cam.set_pos(0, -10, 0) base.cam.look_at(0, 0, 0) self.ball = base.loader.load_model("models/smiley") self.ball.reparent_to(base.render) return LerpFunc( self.run_credits, fromData=0, toData=1, duration=5.0, blendType='noBlend', extraArgs=[], name=None, )
def enterShoot(self, target=None): if not target: target = base.localAvatar self.pose("collapse", 1) self.shootTrack = Sequence( Parallel( Sequence( LerpFunc(self.blendAnimFromBase, fromData=0, toData=1, duration=0.25, extraArgs=['collapse']), ActorInterval(self, "collapse", startFrame=1, endFrame=5, playRate=0.8), ActorInterval(self, "collapse", startFrame=5, endFrame=22, playRate=0.7), ActorInterval(self, "collapse", startFrame=22, endFrame=5, playRate=0.7), LerpFunc(self.blendAnimFromBase, fromData=1, toData=0, duration=0.25, extraArgs=['collapse'])), Sequence(Wait(0.1), SoundInterval(self.whipSound, node=self)), Sequence(Wait(0.55), SoundInterval(self.shootSound, node=self)), Sequence(Wait(0.635), Func(self.fireLaser, target)))) self.shootTrack.start()
def startHitFlyingToonInterval(self): hitByEnemyPos = self.toon.getPos(render) collVec = hitByEnemyPos - self.collPos collVec[2] = 0.0 collVec.normalize() collVec *= Globals.Gameplay.HitKnockbackDist def spinPlayer(t, rand): if rand == 0: self.toon.setH(-(t * 720.0)) else: self.toon.setH(t * 720.0) direction = random.randint(0, 1) self.startEnemyHitIval(Sequence(Parallel(LerpFunc(spinPlayer, fromData=0.0, toData=1.0, duration=Globals.Gameplay.HitKnockbackTime, blendType='easeInOut', extraArgs=[direction]), LerpPosInterval(self.toon, duration=Globals.Gameplay.HitKnockbackTime, pos=hitByEnemyPos + collVec, blendType='easeOut')), Func(self.request, 'FreeFly'), name='hitByLegalEagleIval-%i' % self.toon.doId))
def update_fired_props(self, pos, fwd): if pos == (0, 0, 0) and fwd == (0, 0, 0): return wpn_np = self.gfx_np.node old_pos = wpn_np.get_pos(render) self.gfx_np.node.reparent_to(render) wpn_np.set_pos(old_pos) self.ipos = LerpPosInterval(wpn_np, self.eng.client.rate, pos) self.ipos.start() fwd_start = render.get_relative_vector(wpn_np, Vec3(0, 1, 0)) if self.ifwd: self.ifwd.finish() self.ifwd = LerpFunc(self._rotate_wpn, fromData=0, toData=1, duration=self.eng.client.rate, extraArgs=[wpn_np, fwd_start, fwd]) self.ifwd.start()
def requestChangeVolume(self, duration, finalVolume, priority): if priority < self.__currentPriority: return self.__currentPriority = priority self.__duration = duration self.__startVolume = self.getVolume() self.__finalVolume = finalVolume if self.__currentActionInterval: self.__currentActionInterval.pause() self.__currentActionInterval = None self.__currentActionInterval = Sequence( LerpFunc(self.__changeVolumeTask, fromData=self.__startVolume, toData=self.__finalVolume, duration=self.__duration)) self.__currentActionInterval.start()
def pickUp(self, toon, elapsedSeconds = 0.0): self._wasPickedUp = True if self._animSeq is not None: self._animSeq.finish() self._animSeq = None if self._animate: def lerpFlyToToon(t): vec = toon.getPos(render) - self.getPos(render) vec[2] += toon.getHeight() self.setPos(self.getPos() + vec * t) self.setScale(1.0 - t * 0.8) self._animSeq = Sequence(LerpFunc(lerpFlyToToon, fromData=0.0, toData=1.0, duration=self._animDuration), Wait(0.1), Func(self.hide)) self._animSeq.start(elapsedSeconds) else: self.hide()
def doSpraySoundIval(self, dir=0): self.stopSpraySoundIval() currVol = self.spraySound.getVolume() if dir == 0: goalVol = 1 else: goalVol = 0 dist = abs(currVol - goalVol) dur = dist / self.spraySoundSpeed ival = Sequence() if dir == 0: ival.append(Func(self.spraySound.play)) ival.append(LerpFunc(self.__updateSprayVol, dur, currVol, goalVol)) if dir == 1: ival.append(Func(self.spraySound.stop)) self.spraySoundIval = ival self.spraySoundIval.start()
def createLights(self, r, g, b, startColor=1, fade=0): self.deleteLights() self.amblight = AmbientLight("amblight") self.amblight.setColor(VBase4(r, g, b, 1)) self.ambNode = render.attachNewNode(self.amblight) render.setLight(self.ambNode) if fade: self.lightTrack = LerpFunc(self.setLightColor, fromData=startColor, toData=r, duration=2.5, blendType="easeInOut") self.lightTrack.start() self.skyTrack = LerpColorInterval(self.sky, color=VBase4(r + 0.4, g + 0.4, b + 0.4, 1.0), startColor=VBase4(startColor, startColor, startColor, 1.0), duration=1.5) self.skyTrack.start() sky = "tt" if r < 0.6: sky = "br" self.skySeq = Sequence(Wait(1.5), Func(self.createSky, sky)) self.skySeq.start()
def load(self): StateData.load(self) self.topBar = DirectFrame(parent = render2d, frameSize = (2,-2,0.3,-0.3), frameColor=(0, 0, 0, 1), pos=(0,1,1.4)) self.btmBar = DirectFrame(parent = render2d, frameSize = (2,-2,0.3,-0.3), frameColor=(0,0,0,1), pos=(0,-1,-1.4)) self.ival = ParallelEndTogether( LerpPosInterval(self.topBar, duration=self.barDur, pos=(0,1,1.0), startPos=(0,1,1.4), blendType='easeOut' ), LerpPosInterval(self.btmBar, duration=self.barDur, pos=(0,-1,-1.0), startPos=(0,-1,-1.4), blendType='easeOut' ), LerpFunc( self.__lerpFov, duration = self.barDur, blendType = 'easeOut', fromData = self.origFov, toData = self.fov ) ) self.hide()
def splitBoard(self): self.sawingLine.reset() board = self.currentBoard boardIndex = self.currentBoardIndex if self.hitZone2Penalty: boardSplitAnim = Parallel( LerpPosInterval(self.board_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone2_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone2_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) elif self.hitZone1Penalty: boardSplitAnim = Parallel( LerpPosInterval(self.board_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone1_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) else: boardSplitAnim = Parallel( LerpPosInterval(self.piece1, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, self.config.boardYDist, 0.0)), LerpPosInterval(self.piece2, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, self.config.boardYDist, 0.0)), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) self.splitBoardSequence = Sequence( Func(self.updateScore), Func(self.boardComplete.play), boardSplitAnim, Func(board.stash), Func(self.piece1.setPos, self.piece1.getPos()), Func(self.piece2.setPos, self.piece2.getPos()), Func(self.board_right.setPos, self.board_right.getPos()), Func(self.board_left.setPos, self.board_left.getPos()), Func(self.zone2_right.setPos, self.zone2_right.getPos()), Func(self.zone2_left.setPos, self.zone2_left.getPos()), Func(self.zone1_right.setPos, self.zone1_right.getPos()), Func(self.zone1_left.setPos, self.zone1_left.getPos()), Func(self.cut.setSa, 1.0), Func(self.zone1_right.setSa, 1.0), Func(self.zone1_left.setSa, 1.0), Func(self.zone2_right.setSa, 1.0), Func(self.zone2_left.setSa, 1.0), Func(self.board_right.setSa, 1.0), Func(self.board_left.setSa, 1.0), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex), name='RepairSawGame.splitBoardSequence') self.splitBoardSequence.start()
def setup(self): # Store current values self.entry_background_color = VBase4(base.win.get_clear_color()) self.entry_cam_pos = VBase3(base.cam.get_pos()) self.entry_cam_hpr = VBase3(base.cam.get_hpr()) self.entry_cam_scale = VBase3(base.cam.get_scale()) self.entry_cam_fov = VBase2(base.cam.node().get_lens().get_fov()) # Set values for splash base.win.set_clear_color((0,0,0,1)) cam_dist = 2 base.cam.set_pos(0, -2.2 * cam_dist, 0) base.cam.set_hpr(0, 0, 0) base.cam.set_scale(1) base.cam.node().get_lens().set_fov(45/cam_dist) # Set up the splash itself self.logo_animation = Actor(asset_path / "panda3d_logo.bam") self.logo_animation.reparent_to(render) self.logo_animation.set_two_sided(True) shader = Shader.load( Shader.SL_GLSL, vertex=asset_path / "panda3d_logo.vert", fragment=asset_path / "panda3d_logo.frag", ) self.logo_animation.set_shader(shader) self.logo_animation.set_shader_input("fade", 0.0) self.logo_animation.set_shader_input("pattern", self.pattern.value) self.logo_animation.set_shader_input("colors", self.colors.value) self.logo_animation.set_shader_input("pattern_freq", self.pattern_freq) self.logo_animation.set_shader_input("cycle_freq", self.cycle_freq) self.logo_sound = base.loader.loadSfx(asset_path / "panda3d_logo.wav") # Build interval def shader_time(t): self.logo_animation.set_shader_input("time", t) def fade_background_to_white(t): base.win.set_clear_color((t,t,t,1)) self.logo_animation.set_shader_input("time", t/3.878) self.logo_animation.set_shader_input("fade", t) def fade_to_black(t): base.win.set_clear_color((1-t,1-t,1-t,1)) #self.logo_animation.set_shader_input("time", t/3.878) #self.logo_animation.set_shader_input("fade", t) # Timing: # 0.000 Start # 3.878 Logo is assembled, fade to black-on-whitey # 4.878 Black on white achieved # <+1.500> Begin fade to black # <+1.741> Black on black achieved # 8.119 Sound ends effects = Parallel( self.logo_animation.actorInterval( "splash", loop=False, ), SoundInterval( self.logo_sound, loop=False, ), Sequence( LerpFunc( shader_time, fromData=0, toData=1, duration=3.878, ), LerpFunc( fade_background_to_white, fromData=0, toData=1, duration=1.0, ), Wait(1.5), LerpFunc( fade_to_black, fromData=0, toData=1, duration=1.741, ), ), ) return effects
def setup(self): x_size, y_size = base.win.get_x_size(), base.win.get_y_size() bg_buffer = base.win.makeTextureBuffer( "Background Scene", x_size, y_size, ) bg_buffer.set_clear_color_active(True) bg_buffer.set_clear_color(VBase4(0, 1, 0, 1)) bg_buffer.set_sort(-100) # render buffer before main scene. bg_texture = bg_buffer.get_texture() self.bg_texture = bg_texture bg_camera = base.make_camera(bg_buffer) self.setup_background_scene(bg_camera) # Foreground Scene base.win.set_clear_color((0, 0, 0, 1)) cam_dist = 2 base.cam.set_pos(0, -2.2 * cam_dist, 0) base.cam.node().get_lens().set_fov(45/cam_dist) self.logo_animation = Actor(asset_path / "panda3d_logo.bam") self.logo_animation.reparent_to(render) self.logo_animation.set_two_sided(True) shader = Shader.load( Shader.SL_GLSL, vertex=asset_path / "splash_window.vert", fragment=asset_path / "splash_window.frag", ) self.logo_animation.set_shader(shader) self.logo_animation.set_shader_input("background", bg_texture) self.logo_animation.set_shader_input("fade", 0.0) self.logo_sound = base.loader.loadSfx(asset_path / "panda3d_logo.wav") # Build interval def fade_background_to_white(t): base.win.set_clear_color((t,t,t,1)) self.logo_animation.set_shader_input("fade", t) def set_background_texture(t): self.logo_animation.set_shader_input( "background", self.bg_texture, ) effects = Parallel( self.logo_animation.actorInterval( "splash", loop=False, ), SoundInterval( self.logo_sound, loop=False, ), Sequence( LerpFunc( set_background_texture, fromData=0, toData=1, duration=3.878, ), LerpFunc( fade_background_to_white, fromData=0, toData=1, duration=1.0, ), ), ) return effects
def enterOnStage(self): dna = self.choice.dna name = self.choice.name self.stageToon.setName(name) self.stageToon.setDNAStrand(dna) self.stageToon.nametag.setNametagColor( NametagGlobals.NametagColors[NametagGlobals.CCLocal]) self.stageToon.nametag.setActive(0) self.stageToon.nametag.nametag3d.request('Rollover') self.stageToon.nametag.unmanage(base.marginManager) self.stageToon.nametag.updateAll() self.stageToon.animFSM.request('neutral') self.stageToon.setPosHpr(0, 0, 0, 10, 0, 0) self.stageToon.show() dat = HOOD_STAGE_DATA[self.choice.lastHood] self.stageToonRoot.setPos(dat[2]) self.stageToonRoot.setHpr(dat[3]) camera.reparentTo(self.stageToonRoot) camera.setPos(dat[0]) camera.lookAt(self.stageToonRoot, 0, 0, 3) startHpr = camera.getHpr() camera.setPos(dat[1]) camera.lookAt(self.stageToonRoot, 0, 0, 3) endHpr = camera.getHpr() self.camIval = Parallel( LerpPosInterval(camera, 5.0, dat[1] - (1.6, 0, 0), dat[0] - (1.6, 0, 0), blendType='easeInOut'), LerpQuatInterval(camera, 5.0, hpr=endHpr, startHpr=startHpr, blendType='easeInOut'), LerpFunc(self.__changeCamFOV, duration=5.0, fromData=80.0, toData=CIGlobals.DefaultCameraFov, blendType='easeInOut')) if self.isNewToon: self.camIval.append( Sequence( Func(self.stageToon.hide), Func(base.stopMusic), SoundInterval(self.newToonAnnounceSfx, startTime=1.674, duration=4.047), SoundInterval(self.newToonDrumrollSfx), Func(self.stageToon.pose, 'tele', self.stageToon.getNumFrames('tele')), Func(self.newToonAppear), Func(self.stageToon.show), SoundInterval(self.newToonRevealSfx), Func(base.cr.playTheme))) else: self.camIval.append( Sequence(Func(self.showActionButtons), Func(self.enableAllCharButtons), Wait(5.0), Func(self.beginRandomAnims))) self.camIval.start()
def startHitByWhirlwindInterval(self): def spinPlayer(t): self.controlVelocity[2] = 1.0 angle = math.radians(t * (720.0 * 2 - 180)) self.toon.setPos(self.activeWhirlwind.model.getX(self.game.level.root) + math.cos(angle) * 2, self.activeWhirlwind.model.getY(self.game.level.root) + math.sin(angle) * 2, self.toon.getZ()) def movePlayerBack(t): self.toon.setY(self.activeWhirlwind.model.getY(self.game.level.root) - t * Globals.Gameplay.WhirlwindMoveBackDist) self.startEventIval(Sequence(Func(self._cameraMgr.freeze), Func(self.activeWhirlwind.disable), LerpFunc(spinPlayer, fromData=0.0, toData=1.0, duration=Globals.Gameplay.WhirlwindSpinTime), LerpFunc(movePlayerBack, fromData=0.0, toData=1.0, duration=Globals.Gameplay.WhirlwindMoveBackTime, blendType='easeOut'), Func(self.activeWhirlwind.enable), Func(self._cameraMgr.unfreeze), Func(self.request, 'FreeFly'), name='spinPlayerIval-%i' % self.toon.doId))
def startFade(lbl): LerpFunc(fadeText, fromData=1.0, toData=0.0, duration=1.0, extraArgs=[lbl]).start()