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()
