def setEveryoneDone(self):
if not self.hasLocalToon:
return
else:
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return
self.notify.debug('setEveryoneDone')
def endGame(task, self=self):
if not PairingGameGlobals.EndlessGame:
self.gameOver()
return Task.done
self.timer.hide()
self.bonusGlow.hide()
if len(self.inactiveList) == len(self.cards):
self.notify.debug('perfect game!')
perfectTextSubnode = hidden.attachNewNode(
self.__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5,
scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')),
Func(destroyText), WaitInterval(0.5), Func(endGame, None))
soundTrack = SoundInterval(self.sndPerfect)
self.perfectIval = Parallel(textTrack, soundTrack)
self.perfectIval.start()
else:
taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)
return
def lerpCameraFov(self, fov, time):
taskMgr.remove('cam-fov-lerp-play')
oldFov = base.camLens.getHfov()
if abs(fov - oldFov) > 0.1:
def setCamFov(fov):
base.camLens.setMinFov(fov / (4.0 / 3.0))
self.camLerpInterval = LerpFunctionInterval(setCamFov, fromData=oldFov, toData=fov, duration=time, name='cam-fov-lerp')
self.camLerpInterval.start()
def _initIntervals(self):
self._healthIval = LerpFunctionInterval(self.healthBar.setSz,
fromData=0.0,
toData=1.0,
duration=2.0)
self.baseSpinDuration = 2.0
self._spinIval = LerpFunctionInterval(self.propellerMain.setR,
fromData=0.0,
toData=-360.0,
duration=self.baseSpinDuration)
def go(self):
if self.destination:
base.sounds[self.sound].play()
if self.description:
base.interface.say(self.description)
base.start_sequence(
LerpFunctionInterval(base.camLens.set_fov, 0.2, fromData=base.camLens.get_fov()[0], toData=2, blendType='easeIn'),
Func(self.swap),
LerpFunctionInterval(base.camLens.set_fov, 0.2, fromData=base.camLens.get_fov()[0], toData=base.base_fov, blendType='easeInOut'),
)
def unblur(self):
if not self.blurred:
return
self.blurred = False
LerpFunctionInterval(lambda x: base.blur_scale.set_element(0, x), 0.5, fromData=1.0, toData=0.0).start()
if self.wind_sound:
self.wind_sound.set_loop(True)
self.wind_sound.play()
LerpFunctionInterval(lambda x: self.wind_sound.set_volume(x), 0.5, fromData=0.0, toData=1.0).start()
def blur(self):
if self.blurred:
return
self.blurred = True
LerpFunctionInterval(lambda x: base.blur_scale.set_element(0, x), 0.5, fromData=0.0, toData=1.0).start()
if self.wind_sound:
Sequence(
LerpFunctionInterval(lambda x: self.wind_sound.set_volume(x), 0.5, fromData=1.0, toData=0.0),
Func(self.wind_sound.stop),
).start()
def startConclusion(self):
DistributedPartyCatchActivity.notify.debug('startConclusion')
for avId in self.toonIds:
if avId in self.toonSDs:
toonSD = self.toonSDs[avId]
toonSD.fsm.request('notPlaying')
self.destroyCatchCollisions()
if base.localAvatar.doId not in self.toonIds:
return
else:
self.localToonExiting()
if self.fruitsCaught >= self.numFruits:
finishText = TTLocalizer.PartyCatchActivityFinishPerfect
else:
finishText = TTLocalizer.PartyCatchActivityFinish
perfectTextSubnode = hidden.attachNewNode(self.__genText(finishText))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')), Func(destroyText),
WaitInterval(0.5))
soundTrack = SoundInterval(self.sndPerfect)
self.finishIval = Parallel(textTrack, soundTrack)
self.finishIval.start()
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(self.propeller.setH, fromData=0.0, toData=360.0, duration=self.baseSpinDuration, name='%s.propellerSpinLerp-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Attacked), Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Targeted), name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(Func(self.blinkLoop.loop), Wait(blinkTime), Func(self.blinkLoop.clearToInitial), name='%s.blinkWarningSeq-%s' % (self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed), Wait(dur), Func(self.returnBackpackToLastStateFunc), name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(Sequence(LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale, toData=scale * 1.1, duration=pulseTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale * 1.1, toData=scale, duration=pulseTime / 2.0, blendType='easeInOut')), LerpHprInterval(self.redTapeRing, pulseTime, Vec3(360, 0, 0), startHpr=Vec3(0, 0, 0)), name='%s.pulseBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleTime, scale * bouncePercent, startScale=0.0, blendType='easeInOut')
self.popUpBubbleSeq = Sequence(Func(self.updateLerpStartScale, self.popUpBubbleLerp, self.redTapeRing), Func(self.redTapeRing.show), self.popUpBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.pulseBubbleSeq.loop), name='%s.popUpBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale * bouncePercent, startScale=scale, blendType='easeInOut')
self.removeBubbleSeq = Sequence(Func(self.pulseBubbleSeq.clearToInitial), Func(self.updateLerpStartScale, self.removeBubbleLerp, self.redTapeRing), self.removeBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleTime, 0.0, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.redTapeRing.hide), name='%s.removeBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(Parallel(LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0)), Func(self.toon.stash), name='%s.deathInterval-%s' % (self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(Func(self.toon.stash), Func(self.resetToon), Wait(1.0), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), name='%s.spawnInterval-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=1.0, toData=0.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=0.0, toData=1.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), name='%s.blinkBubbleLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(Wait(invulBuffTime - blinkTime), Func(self.blinkBubbleLoop.loop), Wait(blinkTime), Func(self.blinkBubbleLoop.finish), name='%s.blinkBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
def start_starting(self):
self.world.finish_loading()
old_hpr = base.cam.get_hpr()
base.cam.look_at(base.camera.get_parent(), (0, 0, 0))
base.cam.set_h(old_hpr[0])
cam_hpr = base.cam.get_hpr()
base.cam.set_hpr(old_hpr)
old_hpr = base.camera.get_hpr()
base.camera.look_at(0, 0, 0)
camera_hpr = base.camera.get_hpr()
base.camera.set_hpr(old_hpr)
#self.world.activate()
self.started = True
base.graphicsEngine.render_frame()
base.graphicsEngine.render_frame()
Sequence(
Wait(0.5),
Parallel(
LerpFunctionInterval(base.camLens.set_fov,
2.0,
fromData=base.camLens.get_fov()[0],
toData=80,
blendType='easeIn'),
base.cam.hprInterval(2, hpr=(0, 0, 0), blendType="easeInOut"),
base.camera.hprInterval(2,
hpr=camera_hpr,
blendType="easeInOut"),
),
Func(self.finish_starting),
).start()
def initFlash(self):
model = CogdoUtil.loadFlyingModel('gatherableFlash_card')
texName = Globals.Level.GatherableType2TextureName[self.type]
tex = model.findTexture(texName)
tex.setWrapU(Texture.WMRepeat)
tex.setWrapV(Texture.WMRepeat)
del model
self.ts = TextureStage('ts')
self.ts.setMode(TextureStage.MCombine)
self.ts.setSort(1)
self.ts.setCombineRgb(TextureStage.CMInterpolate,
TextureStage.CSPrevious,
TextureStage.COSrcColor,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSConstant,
TextureStage.COSrcColor,
)
self.ts.setCombineAlpha(TextureStage.CMInterpolate,
TextureStage.CSPrevious,
TextureStage.COSrcAlpha,
TextureStage.CSTexture,
TextureStage.COSrcAlpha,
TextureStage.CSConstant,
TextureStage.COSrcAlpha,
)
self._model.setTexture(self.ts, tex)
dur = Globals.Gameplay.GatherableFlashTime
self.flashLoop = Sequence(LerpFunctionInterval(self.setTextureAlphaFunc, fromData=1.0, toData=0.25, duration=dur / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.setTextureAlphaFunc, fromData=0.25, toData=1.0, duration=dur / 2.0, blendType='easeInOut'), Wait(1.0), name='%s.flashLoop-%s' % (self.__class__.__name__, self.serialNum))
def __init__(self, player):
self.player = player
self.root = NodePath("CogdoFlyingGui")
self.root.reparentTo(aspect2d)
self.fuelMeter = NodePath("scrubMeter")
self.fuelMeter.reparentTo(self.root)
self.fuelMeter.setPos(1.1, 0.0, -0.7)
self.fuelMeter.setSz(2.0)
cm = CardMaker('card')
cm.setFrame(-0.07, 0.07, 0.0, 0.75)
self.fuelMeterBar = self.fuelMeter.attachNewNode(cm.generate())
self.fuelMeterBar.setColor(0.95, 0.95, 0.0, 1.0)
self.fuelLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(1.1, 0, -0.8),
scale=0.075,
text="Fuel",
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
)
self.messageLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(0.0, 0.0, -0.9),
scale=0.1,
text=" ",
text_align=TextNode.ACenter,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
textMayChange=1,
)
self.messageLabel.stash()
self.winLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(0.0, 0.0, 0.0),
scale=0.25,
text="You win!",
text_align=TextNode.ACenter,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
)
self.winLabel.stash()
self.refuelLerp = LerpFunctionInterval(self.fuelMeterBar.setSz,
fromData=0.0,
toData=1.0,
duration=2.0)
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(Parallel(LerpScaleInterval(self.scoreCircle, time, Point3(scaleXY, scaleXY, 1.0)), SoundInterval(self.scoreCircleSound, duration=time, startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' % (avId, startScore, destScore))
def increaseScores(t, scorePanelIndex = scorePanelIndex, startScore = startScore, destScore = destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore - startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(Parallel(LerpFunctionInterval(increaseScores, duration), Sequence(LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)), LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)), LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)), LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)), LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)), LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
def animToSuit(self, timeStamp):
self.stopTransition()
if self.mode != 'toon':
self.setToToon()
self.loadAnimToSuitSfx()
sideBldgNodes = self.getNodePaths()
nodePath = hidden.find(self.getSbSearchString())
newNP = self.setupSuitBuilding(nodePath)
if not self.leftDoor:
return
closeDoors(self.leftDoor, self.rightDoor)
newNP.stash()
sideBldgNodes.append(newNP)
soundPlayed = 0
tracks = Parallel(name=self.taskName('toSuitTrack'))
for i in sideBldgNodes:
name = i.getName()
timeForDrop = TO_SUIT_BLDG_TIME * 0.85
if name[0] == 's':
showTrack = Sequence(name=self.taskName('ToSuitFlatsTrack') + '-' + str(sideBldgNodes.index(i)))
initPos = Point3(0, 0, self.SUIT_INIT_HEIGHT) + i.getPos()
showTrack.append(Func(i.setPos, initPos))
showTrack.append(Func(i.unstash))
if i == sideBldgNodes[len(sideBldgNodes) - 1]:
showTrack.append(Func(self.normalizeElevator))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogDropSound, 0, 1, None, 0.0))
showTrack.append(LerpPosInterval(i, timeForDrop, i.getPos(), name=self.taskName('ToSuitAnim') + '-' + str(sideBldgNodes.index(i))))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogLandSound, 0, 1, None, 0.0))
showTrack.append(self.createBounceTrack(i, 2, 0.65, TO_SUIT_BLDG_TIME - timeForDrop, slowInitBounce=1.0))
if not soundPlayed:
showTrack.append(Func(base.playSfx, self.cogSettleSound, 0, 1, None, 0.0))
tracks.append(showTrack)
if not soundPlayed:
soundPlayed = 1
elif name[0] == 't':
hideTrack = Sequence(name=self.taskName('ToSuitToonFlatsTrack'))
timeTillSquish = (self.SUIT_INIT_HEIGHT - 20.0) / self.SUIT_INIT_HEIGHT
timeTillSquish *= timeForDrop
hideTrack.append(LerpFunctionInterval(self.adjustColorScale, fromData=1, toData=0.25, duration=timeTillSquish, extraArgs=[i]))
hideTrack.append(LerpScaleInterval(i, timeForDrop - timeTillSquish, Vec3(1, 1, 0.01)))
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
hideTrack.append(Func(i.clearColorScale))
tracks.append(hideTrack)
self.stopTransition()
self._deleteTransitionTrack()
self.transitionTrack = tracks
self.transitionTrack.start(timeStamp)
return
def hide(self):
if not self.visible:
return
self.visible = False
duration = 0.5
Sequence(
Parallel(
LerpFunctionInterval(
lambda x: self.blur_card.set_alpha_scale(x),
duration,
toData=0.0,
fromData=1.0),
LerpFunctionInterval(
lambda x: self.fade_card.set_alpha_scale(x),
duration,
toData=0.0,
fromData=0.5),
),
Func(self.blur_card.hide),
Func(self.fade_card.hide),
).start()
self.path.hide()
def show(self):
if self.visible:
return
self.visible = True
duration = 0.5
Sequence(
Func(self.blur_card.show),
Func(self.fade_card.show),
Parallel(
LerpFunctionInterval(
lambda x: self.blur_card.set_alpha_scale(x),
duration,
fromData=0.0,
toData=1.0),
LerpFunctionInterval(
lambda x: self.fade_card.set_alpha_scale(x),
duration,
fromData=0.0,
toData=0.5),
),
Func(self.path.show),
Func(self.focus),
).start()
def playMusic(self, songList):
if self.currentSongList == songList and not self.playNextSong:
return
self.playNextSong = False
self.currentSongList = songList
newSound = loader.loadMusic("assets/audio/music/" +
random.choice(songList))
dur = 2.0
newSound.setFinishedEvent("playAudioNext")
newSound.play()
if self.currentTrack is not None:
oldTrack = self.currentTrack
oldTrack.setFinishedEvent("")
Sequence(
Parallel(LerpFunctionInterval(newSound.setVolume, dur, 0, 1),
LerpFunctionInterval(oldTrack.setVolume, dur, 1, 0)),
Func(oldTrack.stop)).start()
self.currentTrack = newSound
def showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + ` avId `)
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 50),
gravMult=1.0)
oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 40),
gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
avIndex = self.avIdList.index(avId)
endPos = CTGG.ToonStartingPositions[avIndex]
def flyFunc(t,
trajectory,
startPos=startPos,
endPos=endPos,
dur=flyDur,
moveNode=parentNode,
flyNode=toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc,
fromData=0.0,
toData=flyDur,
duration=flyDur,
extraArgs=[trajectory]),
name=toon.uniqueName('hitBySuit-fly'))
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(geomNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(rotNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx,
self.sndTable['hitBySuit'][i]),
Wait(flyDur * (2.0 / 3.0)),
SoundInterval(self.sndTable['falling'][i],
duration=flyDur * (1.0 / 3.0)),
name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.stopGameWalk()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self=self,
avId=avId,
oldGeomNodeZ=oldGeomNodeZ,
dropShadow=dropShadow,
parentNode=parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'gameWalk'):
toon = base.localAvatar
toon.setSpeed(0, 0)
self.startGameWalk()
dropShadow.removeNode()
del dropShadow
toon = self.getAvatar(avId)
if toon:
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
if toon:
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
if toon:
toon.startSmooth()
preFunc()
slipBack = Parallel(
Sequence(ActorInterval(toon, 'slip-backward', endFrame=24),
ActorInterval(toon, 'slip-backward', startFrame=24)))
if toon.doId == self.localAvId:
slipBack.append(SoundInterval(self.sndOof))
hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack,
soundTrack),
slipBack,
Func(postFunc),
name=toon.uniqueName('hitBySuit'))
self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration())
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
return
class CogdoFlyingPlayer(FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('CogdoFlyingPlayer')
def __init__(self, toon):
FSM.__init__(self, 'CogdoFlyingPlayer')
self.toon = toon
self.toon.reparentTo(render)
self.legalEaglesTargeting = []
self.activeBuffs = []
self.initModels()
self.initIntervals()
self.netTimeSentToStartDeath = 0
self.backpackState = -1
self.lastBackpackState = -1
self.lastPropellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.propellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.setFuelState(Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setOldFuelState(self.fuelState)
CogdoFlyingPlayer.setBlades(self, Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setBackpackState(Globals.Gameplay.BackpackStates.Normal)
def initModels(self):
self.createPropeller()
self.createRedTapeRing()
def createPropeller(self):
self.propellerSmoke = DustCloud.DustCloud(self.toon, wantSound=False)
self.propellerSmoke.setBillboardPointEye()
self.propellerSmoke.setBin('fixed', 5002)
self.backpack = CogdoUtil.loadFlyingModel('propellerPack')
self.backpack.setScale(1.3)
self.backpack.setHpr(180.0, 0.0, 0.0)
self.backpackInstances = []
self.backpackTextureCard = CogdoUtil.loadFlyingModel('propellerPack_card')
parts = self.toon.getTorsoParts()
for part in parts:
backpackInstance = part.attachNewNode('backpackInstance')
animal = self.toon.style.getAnimal()
bodyScale = ToontownGlobals.toonBodyScales[animal]
backpackHeight = ToontownGlobals.torsoHeightDict[self.toon.style.torso] * bodyScale - 0.5
backpackInstance.setPos(0.0, -0.325, backpackHeight)
self.backpackInstances.append(backpackInstance)
self.backpack.instanceTo(backpackInstance)
self.propInstances = []
self.propeller = CogdoUtil.loadFlyingModel('toonPropeller')
for part in self.backpackInstances:
propInstance = part.attachNewNode('propInstance')
propInstance.setPos(0.0, -0.275, 0.0)
propInstance.setHpr(0.0, 20.0, 0.0)
propInstance.setScale(1.0, 1.0, 1.25)
self.propInstances.append(propInstance)
self.propeller.instanceTo(propInstance)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propeller.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propeller.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
def createRedTapeRing(self):
self.redTapeRing = CogdoUtil.loadFlyingModel('redTapeRing')
self.redTapeRing.setTwoSided(True)
self.redTapeRing.reparentTo(self.toon)
self.redTapeRing.hide()
self.redTapeRing.setScale(1.25)
self.redTapeRing.setZ(self.toon.getHeight() / 2.0)
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(self.propeller.setH, fromData=0.0, toData=360.0, duration=self.baseSpinDuration, name='%s.propellerSpinLerp-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Attacked), Wait(singleBlinkTime / 2.0), Func(self.setBackpackTexture, Globals.Gameplay.BackpackStates.Targeted), name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(Func(self.blinkLoop.loop), Wait(blinkTime), Func(self.blinkLoop.clearToInitial), name='%s.blinkWarningSeq-%s' % (self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed), Wait(dur), Func(self.returnBackpackToLastStateFunc), name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(Sequence(LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale, toData=scale * 1.1, duration=pulseTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setScale, fromData=scale * 1.1, toData=scale, duration=pulseTime / 2.0, blendType='easeInOut')), LerpHprInterval(self.redTapeRing, pulseTime, Vec3(360, 0, 0), startHpr=Vec3(0, 0, 0)), name='%s.pulseBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleTime, scale * bouncePercent, startScale=0.0, blendType='easeInOut')
self.popUpBubbleSeq = Sequence(Func(self.updateLerpStartScale, self.popUpBubbleLerp, self.redTapeRing), Func(self.redTapeRing.show), self.popUpBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.pulseBubbleSeq.loop), name='%s.popUpBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing, scaleBounceTime, scale * bouncePercent, startScale=scale, blendType='easeInOut')
self.removeBubbleSeq = Sequence(Func(self.pulseBubbleSeq.clearToInitial), Func(self.updateLerpStartScale, self.removeBubbleLerp, self.redTapeRing), self.removeBubbleLerp, LerpScaleInterval(self.redTapeRing, scaleTime, 0.0, startScale=scale * bouncePercent, blendType='easeInOut'), Func(self.redTapeRing.hide), name='%s.removeBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(Parallel(LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0)), Func(self.toon.stash), name='%s.deathInterval-%s' % (self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(Func(self.toon.stash), Func(self.resetToon), Wait(1.0), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), name='%s.spawnInterval-%s' % (self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=1.0, toData=0.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), LerpFunctionInterval(self.redTapeRing.setAlphaScale, fromData=0.0, toData=1.0, duration=singleBlinkTime / 2.0, blendType='easeInOut'), name='%s.blinkBubbleLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(Wait(invulBuffTime - blinkTime), Func(self.blinkBubbleLoop.loop), Wait(blinkTime), Func(self.blinkBubbleLoop.finish), name='%s.blinkBubbleSeq-%s' % (self.__class__.__name__, self.toon.doId))
def returnBackpackToLastStateFunc(self):
if self.backpackState == Globals.Gameplay.BackpackStates.Refuel:
self.returnBackpackToLastState()
def setPropellerSpinRateFunc(self):
if self.propellerSpinRate == Globals.Gameplay.RefuelPropSpeed:
self.setPropellerSpinRate(self.lastPropellerSpinRate)
def returnBackpackToLastState(self):
self.setBackpackState(self.lastBackpackState)
def setBackpackState(self, state):
if state == self.backpackState:
return
self.lastBackpackState = self.backpackState
self.backpackState = state
self.blinkWarningSeq.clearToInitial()
self.refuelSeq.clearToInitial()
self.blinkLoop.clearToInitial()
if self.lastBackpackState == Globals.Gameplay.BackpackStates.Refuel:
self.setPropellerSpinRateFunc()
if state in Globals.Gameplay.BackpackStates:
if state == Globals.Gameplay.BackpackStates.Normal:
pass
elif state == Globals.Gameplay.BackpackStates.Targeted:
pass
elif state == Globals.Gameplay.BackpackStates.Refuel:
self.refuelSeq.start()
elif state == Globals.Gameplay.BackpackStates.Attacked:
self.blinkWarningSeq.start()
self.setBackpackTexture(state)
def setBackpackTexture(self, state):
texName = Globals.Gameplay.BackpackState2TextureName[state]
tex = self.backpackTextureCard.findTexture(texName)
self.backpack.setTexture(tex, 1)
def updateLerpStartScale(self, lerp, nodepath):
lerp.setStartScale(nodepath.getScale())
def handleEnterGatherable(self, gatherable, elapsedTime):
if gatherable.type == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.clearToInitial()
self.blinkBubbleSeq.start(elapsedTime)
self.removeBubbleSeq.clearToInitial()
self.popUpBubbleSeq.start()
if gatherable.type not in self.activeBuffs:
self.activeBuffs.append(gatherable.type)
elif gatherable.type == Globals.Level.GatherableTypes.Propeller:
self.setBackpackState(Globals.Gameplay.BackpackStates.Refuel)
def handleDebuffPowerup(self, pickupType, elapsedTime):
if pickupType == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.finish()
self.popUpBubbleSeq.clearToInitial()
self.removeBubbleSeq.start()
if pickupType in self.activeBuffs:
self.activeBuffs.remove(pickupType)
def isBuffActive(self, pickupType):
if pickupType in self.activeBuffs:
return True
return False
def isInvulnerable(self):
if Globals.Level.GatherableTypes.InvulPowerup in self.activeBuffs:
return True
return False
def setFuelState(self, fuelState):
self.fuelState = fuelState
def setOldFuelState(self, fuelState):
self.oldFuelState = fuelState
def hasFuelStateChanged(self):
if self.fuelState != self.oldFuelState:
return True
else:
return False
def updatePropellerSmoke(self):
if not self.hasFuelStateChanged():
return
if self.fuelState in [Globals.Gameplay.FuelStates.FuelNoPropeller, Globals.Gameplay.FuelStates.FuelNormal]:
self.propellerSmoke.stop()
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelVeryLow, Globals.Gameplay.FuelStates.FuelEmpty]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.25)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.5)
self.propellerSmoke.loop(rate=48)
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelLow]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.0825)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.0)
self.propellerSmoke.loop(rate=24)
def resetBlades(self):
self.setBlades(len(self.blades))
def setAsLegalEagleTarget(self, legalEagle):
if legalEagle not in self.legalEaglesTargeting:
self.legalEaglesTargeting.append(legalEagle)
def removeAsLegalEagleTarget(self, legalEagle):
if legalEagle in self.legalEaglesTargeting:
self.legalEaglesTargeting.remove(legalEagle)
def isLegalEagleTarget(self):
if len(self.legalEaglesTargeting) > 0:
return True
else:
return False
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in xrange(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
if numBlades > 0:
for i in xrange(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
if fuelState == Globals.Gameplay.FuelStates.FuelNoPropeller:
for prop in self.propInstances:
prop.hide()
else:
for prop in self.propInstances:
prop.show()
self.setFuelState(fuelState)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.setFuelState(len(self.activeBlades) + 1)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def setPropellerSpinRate(self, newRate):
self.lastPropellerSpinRate = self.propellerSpinRate
self.propellerSpinRate = newRate
self.notify.debug('(%s) New propeller speed:%s, old propeller speed:%s' % (self.toon.doId, self.propellerSpinRate, self.lastPropellerSpinRate))
self.propellerSpinLerp.setPlayRate(newRate)
def died(self, elapsedTime):
self.deathInterval.start(elapsedTime)
self.propellerSmoke.stop()
def spawn(self, elapsedTime):
self.spawnInterval.start(elapsedTime)
def resetToon(self):
self.toon.setScale(1.0)
def enable(self):
self.toon.setAnimState('Happy', 1.0)
self.toon.setForceJumpIdle(True)
self.toon.setSpeed(0, 0)
self.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed)
self.propellerSpinLerp.loop()
def disable(self):
pass
def unload(self):
self.ignoreAll()
if self.toon:
self.toon.showName()
self.backpackTextureCard.removeNode()
del self.backpackTextureCard
self.refuelSeq.clearToInitial()
del self.refuelSeq
self.pulseBubbleSeq.clearToInitial()
del self.pulseBubbleSeq
self.blinkBubbleLoop.clearToInitial()
del self.blinkBubbleLoop
self.blinkBubbleSeq.clearToInitial()
del self.blinkBubbleSeq
self.popUpBubbleLerp.clearToInitial()
del self.popUpBubbleLerp
self.popUpBubbleSeq.clearToInitial()
del self.popUpBubbleSeq
self.removeBubbleLerp.clearToInitial()
del self.removeBubbleLerp
self.removeBubbleSeq.clearToInitial()
del self.removeBubbleSeq
self.propellerSmoke.destroy()
del self.propellerSmoke
self.blinkWarningSeq.clearToInitial()
del self.blinkWarningSeq
self.blinkLoop.clearToInitial()
del self.blinkLoop
self.redTapeRing.removeNode()
del self.redTapeRing
self.propellerSpinLerp.clearToInitial()
del self.propellerSpinLerp
for prop in self.propInstances:
prop.removeNode()
del self.propInstances[:]
self.propeller.removeNode()
del self.propeller
for backpack in self.backpackInstances:
backpack.removeNode()
del self.backpackInstances[:]
self.backpack.removeNode()
del self.backpack
del self.activeBuffs[:]
del self.legalEaglesTargeting[:]
del self.toon
self.toon = None
if self.deathInterval:
self.deathInterval.clearToInitial()
self.deathInterval = None
if self.spawnInterval:
self.spawnInterval.clearToInitial()
self.spawnInterval = None
return
def start(self):
swapAvatarShadowPlacer(self.toon, self.toon.uniqueName('toonShadowPlacer'))
self.toon.startSmooth()
def exit(self):
self.toon.setForceJumpIdle(False)
self.propellerSmoke.reparentTo(hidden)
self.propellerSmoke.stop()
if self.toon:
CogdoFlyingPlayer.resetToon(self)
self.toon.setActiveShadow(0)
self.toon.deleteDropShadow()
self.toon.initializeDropShadow()
self.toon.setActiveShadow(1)
else:
self.notify.warning("There's no toon in offstage, this is bad!")
def initLocalPlayerIntervals(self):
self.coolDownAfterHitInterval = Sequence(Wait(Globals.Gameplay.HitCooldownTime), Func(self.setEnemyHitting, False), name='coolDownAfterHitInterval-%i' % self.toon.doId)
self.deathInterval = Sequence(Func(self.resetVelocities), Parallel(Parallel(Func(self._deathSfx.play), LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)), LerpFunctionInterval(self.toon.setScale, fromData=1.0, toData=0.1, duration=1.0), self.toon.posInterval(0.5, Vec3(0, 0, -25), other=self.toon)), Sequence(Wait(0.5), Func(base.transitions.irisOut))), Func(self.toon.stash), Wait(1.0), Func(self.toonSpawnFunc), name='%s.deathInterval' % self.__class__.__name__)
self.outOfTimeInterval = Sequence(Func(messenger.send, CogdoFlyingLocalPlayer.PlayWaitingMusicEventName), Func(self._loseSfx.play), Func(base.transitions.irisOut), Wait(1.0), Func(self.resetVelocities), Func(self._guiMgr.setMessage, '', transition=None), Func(self.toon.stash), Func(self.toonSpawnFunc), name='%s.outOfTimeInterval' % self.__class__.__name__)
self.spawnInterval = Sequence(Func(self.resetToonFunc), Func(self._cameraMgr.update, 0.0), Func(self._level.update), Func(self.toon.cnode.broadcastPosHprFull), Func(base.transitions.irisIn), Wait(0.5), Func(self.toon.setAnimState, 'TeleportIn'), Func(self.toon.unstash), Wait(1.5), Func(self.requestPostSpawnState), name='%s.spawnInterval' % self.__class__.__name__)
self.waitingForWinInterval = Sequence(Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '.'), Wait(1.5), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '..'), Wait(1.5), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGameWaiting % '...'), Wait(1.5), name='%s.waitingForWinInterval' % self.__class__.__name__)
self.waitingForWinSeq = Sequence(Func(self.setWaitingForWinState), Wait(4.0), Func(self.removeAllMemos), Wait(2.0), Func(self.game.distGame.d_sendRequestAction, Globals.AI.GameActions.LandOnWinPlatform, 0), Func(self.playWaitingForWinInterval), name='%s.waitingForWinSeq' % self.__class__.__name__)
self.winInterval = Sequence(Func(self._guiMgr.setMessage, ''), Wait(4.0), Func(self.game.distGame.d_sendRequestAction, Globals.AI.GameActions.WinStateFinished, 0), name='%s.winInterval' % self.__class__.__name__)
self.goSadSequence = Sequence(Wait(2.5), Func(base.transitions.irisOut, 1.5), name='%s.goSadSequence' % self.__class__.__name__)
self.introGuiSeq = Sequence(Wait(0.5), Parallel(Func(self._guiMgr.setTemporaryMessage, TTLocalizer.CogdoFlyingGameMinimapIntro, duration=5.0), Sequence(Wait(1.0), Func(self._guiMgr.presentProgressGui))), Wait(5.0), Func(self._guiMgr.setMessage, TTLocalizer.CogdoFlyingGamePickUpAPropeller), name='%s.introGuiSeq' % self.__class__.__name__)
return
class CogdoFlyingFuelGui(DirectFrame):
def __init__(self, parent):
DirectFrame.__init__(self, relief=None, state=DGG.NORMAL, sortOrder=DGG.BACKGROUND_SORT_INDEX)
self.reparentTo(parent)
self.active = 0
self._initModel()
self._initIntervals()
return
def _initModel(self):
self.setPos(Globals.Gui.FuelPos2D[0], 0.0, Globals.Gui.FuelPos2D[1])
self.gui = CogdoUtil.loadFlyingModel('propellerMeter', group='gui')
self.gui.reparentTo(self)
self.gui.setBin('fixed', 0)
self.healthBar = self.gui.find('**/healthBar')
self.healthBar.setBin('fixed', 1)
self.healthBar.setColor(*Globals.Gui.FuelNormalColor)
bottomBarLocator = self.gui.find('**/bottomOfBar_loc')
bottomBarPos = bottomBarLocator.getPos(render)
topBarLocator = self.gui.find('**/topOfBar_loc')
topBarPos = topBarLocator.getPos(render)
zDist = topBarPos.getZ() - bottomBarPos.getZ()
self.fuelLowIndicator = self.gui.find('**/fuelLowIndicator')
self.fuelLowIndicator.setBin('fixed', 2)
pos = self.fuelLowIndicator.getPos(render)
newPos = pos
newPos.setZ(bottomBarPos.getZ() + zDist * Globals.Gameplay.FuelLowAmt)
self.fuelLowIndicator.setPos(render, newPos)
self.fuelVeryLowIndicator = self.gui.find('**/fuelVeryLowIndicator')
self.fuelVeryLowIndicator.setBin('fixed', 2)
pos = self.fuelVeryLowIndicator.getPos(render)
newPos = pos
newPos.setZ(bottomBarPos.getZ() + zDist * Globals.Gameplay.FuelVeryLowAmt)
self.fuelVeryLowIndicator.setPos(render, newPos)
self.propellerMain = self.gui.find('**/propellers')
self.propellerMain.setBin('fixed', 3)
self.propellerHead = self.gui.find('**/propellerHead')
self.propellerHead.setBin('fixed', 4)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propellerMain.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propellerMain.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
self.bladeNumberLabel = DirectLabel(parent=self.propellerHead, relief=None, pos=(Globals.Gui.FuelNumBladesPos2D[0], 0, Globals.Gui.FuelNumBladesPos2D[1]), scale=Globals.Gui.FuelNumBladesScale, text=str(len(self.activeBlades)), text_align=TextNode.ACenter, text_fg=(0.0,
0.0,
-0.002,
1), text_shadow=(0.75, 0.75, 0.75, 1), text_font=ToontownGlobals.getInterfaceFont())
self.bladeNumberLabel.setBin('fixed', 5)
return
def _initIntervals(self):
self._healthIval = LerpFunctionInterval(self.healthBar.setSz, fromData=0.0, toData=1.0, duration=2.0)
self.baseSpinDuration = 2.0
self._spinIval = LerpFunctionInterval(self.propellerMain.setR, fromData=0.0, toData=-360.0, duration=self.baseSpinDuration)
def show(self):
DirectFrame.show(self)
self._spinIval.loop()
def hide(self):
DirectFrame.hide(self)
self._spinIval.pause()
def resetBlades(self):
self.setBlades(len(self.blades))
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in range(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
for i in range(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
self.bladeNumberLabel['text'] = str(len(self.activeBlades))
self.bladeNumberLabel.setText()
self.updateHealthBarColor()
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.bladeNumberLabel['text'] = str(len(self.activeBlades))
self.bladeNumberLabel.setText()
self.updateHealthBarColor()
def updateHealthBarColor(self):
color = Globals.Gui.NumBlades2FuelColor[len(self.activeBlades)]
self.healthBar.setColor(*color)
def setPropellerSpinRate(self, newRate):
self._spinIval.setPlayRate(newRate)
def setRefuelLerpFromData(self):
startScale = self.healthBar.getSz()
self._healthIval.fromData = startScale
def setFuel(self, fuel):
self.fuel = fuel
def update(self):
self.healthBar.setSz(self.fuel)
def destroy(self):
self.bladeNumberLabel.removeNode()
self.bladeNumberLabel = None
self._healthIval.clearToInitial()
del self._healthIval
self.healthBar = None
self.fuelLowIndicator = None
self.fuelVeryLowIndicator = None
self.propellerMain = None
self.propellerHead = None
del self.blades[:]
del self.activeBlades[:]
self.gui.detachNode()
self.gui = None
DirectFrame.destroy(self)
return
def getDropIval(self, x, y, dropObjName, generation, num):
objType = PartyGlobals.Name2DropObjectType[dropObjName]
id = (generation, num)
dropNode = hidden.attachNewNode('catchDropNode%s' % (id,))
dropNode.setPos(x, y, 0)
shadow = self.dropShadow.copyTo(dropNode)
shadow.setZ(PartyGlobals.CatchDropShadowHeight)
shadow.setColor(1, 1, 1, 1)
object = self.getObjModel(dropObjName)
object.reparentTo(hidden)
if dropObjName in ['watermelon', 'anvil']:
objH = object.getH()
absDelta = {'watermelon': 12,
'anvil': 15}[dropObjName]
delta = (self.randomNumGen.random() * 2.0 - 1.0) * absDelta
newH = objH + delta
else:
newH = self.randomNumGen.random() * 360.0
object.setH(newH)
sphereName = 'FallObj%s' % (id,)
radius = self.ObjRadius
if objType.good:
radius *= lerp(1.0, 1.3, 0.5)
collSphere = CollisionSphere(0, 0, 0, radius)
collSphere.setTangible(0)
collNode = CollisionNode(sphereName)
collNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
collNode.addSolid(collSphere)
collNodePath = object.attachNewNode(collNode)
collNodePath.hide()
if self.ShowObjSpheres:
collNodePath.show()
catchEventName = 'ltCatch' + sphereName
def eatCollEntry(forward, collEntry):
forward()
self.accept(catchEventName, Functor(eatCollEntry, Functor(self.__handleCatch, id[0], id[1])))
def cleanup(self = self, dropNode = dropNode, id = id, event = catchEventName):
self.ignore(event)
dropNode.removeNode()
duration = objType.fallDuration
onscreenDuration = objType.onscreenDuration
targetShadowScale = 0.3
if self.trickShadows:
intermedScale = targetShadowScale * (self.OffscreenTime / self.BaselineDropDuration)
shadowScaleIval = Sequence(LerpScaleInterval(shadow, self.OffscreenTime, intermedScale, startScale=0))
shadowScaleIval.append(LerpScaleInterval(shadow, duration - self.OffscreenTime, targetShadowScale, startScale=intermedScale))
else:
shadowScaleIval = LerpScaleInterval(shadow, duration, targetShadowScale, startScale=0)
targetShadowAlpha = 0.4
shadowAlphaIval = LerpColorScaleInterval(shadow, self.OffscreenTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
if self.useGravity:
def setObjPos(t, objType = objType, object = object):
z = objType.trajectory.calcZ(t)
object.setZ(z)
setObjPos(0)
dropIval = LerpFunctionInterval(setObjPos, fromData=0, toData=onscreenDuration, duration=onscreenDuration)
else:
startPos = Point3(0, 0, self.MinOffscreenHeight)
object.setPos(startPos)
dropIval = LerpPosInterval(object, onscreenDuration, Point3(0, 0, 0), startPos=startPos, blendType='easeIn')
ival = Sequence(Func(Functor(dropNode.reparentTo, self.root)), Parallel(Sequence(WaitInterval(self.OffscreenTime), Func(Functor(object.reparentTo, dropNode)), dropIval), shadowIval), Func(cleanup), name='drop%s' % (id,))
if objType == PartyGlobals.Name2DropObjectType['anvil']:
ival.append(Func(self.playAnvil))
return ival
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(
self.propeller.setH,
fromData=0.0,
toData=360.0,
duration=self.baseSpinDuration,
name='%s.propellerSpinLerp-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Attacked),
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Targeted),
name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(
Func(self.blinkLoop.loop),
Wait(blinkTime),
Func(self.blinkLoop.clearToInitial),
name='%s.blinkWarningSeq-%s' %
(self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(
Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed),
Wait(dur),
Func(self.returnBackpackToLastStateFunc),
name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(
Sequence(
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale,
toData=scale * 1.1,
duration=pulseTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale * 1.1,
toData=scale,
duration=pulseTime / 2.0,
blendType='easeInOut')),
LerpHprInterval(self.redTapeRing,
pulseTime,
Vec3(360, 0, 0),
startHpr=Vec3(0, 0, 0)),
name='%s.pulseBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleTime,
scale * bouncePercent,
startScale=0.0,
blendType='easeInOut')
self.popUpBubbleSeq = Sequence(
Func(self.updateLerpStartScale, self.popUpBubbleLerp,
self.redTapeRing),
Func(self.redTapeRing.show),
self.popUpBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.pulseBubbleSeq.loop),
name='%s.popUpBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale * bouncePercent,
startScale=scale,
blendType='easeInOut')
self.removeBubbleSeq = Sequence(
Func(self.pulseBubbleSeq.clearToInitial),
Func(self.updateLerpStartScale, self.removeBubbleLerp,
self.redTapeRing),
self.removeBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleTime,
0.0,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.redTapeRing.hide),
name='%s.removeBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(
Parallel(
LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)),
LerpFunctionInterval(self.toon.setScale,
fromData=1.0,
toData=0.1,
duration=1.0)),
Func(self.toon.stash),
name='%s.deathInterval-%s' %
(self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(
Func(self.toon.stash),
Func(self.resetToon),
Wait(1.0),
Func(self.toon.setAnimState, 'TeleportIn'),
Func(self.toon.unstash),
name='%s.spawnInterval-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=1.0,
toData=0.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=0.0,
toData=1.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
name='%s.blinkBubbleLoop-%s' %
(self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(
Wait(invulBuffTime - blinkTime),
Func(self.blinkBubbleLoop.loop),
Wait(blinkTime),
Func(self.blinkBubbleLoop.finish),
name='%s.blinkBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
class CogdoFlyingPlayer(FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('CogdoFlyingPlayer')
def __init__(self, toon):
FSM.__init__(self, 'CogdoFlyingPlayer')
self.toon = toon
self.toon.reparentTo(render)
self.legalEaglesTargeting = []
self.activeBuffs = []
self.initModels()
self.initIntervals()
self.netTimeSentToStartDeath = 0
self.backpackState = -1
self.lastBackpackState = -1
self.lastPropellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.propellerSpinRate = Globals.Gameplay.NormalPropSpeed
self.setFuelState(Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setOldFuelState(self.fuelState)
CogdoFlyingPlayer.setBlades(
self, Globals.Gameplay.FuelStates.FuelNoPropeller)
self.setBackpackState(Globals.Gameplay.BackpackStates.Normal)
def initModels(self):
self.createPropeller()
self.createRedTapeRing()
def createPropeller(self):
self.propellerSmoke = DustCloud.DustCloud(self.toon, wantSound=False)
self.propellerSmoke.setBillboardPointEye()
self.propellerSmoke.setBin('fixed', 5002)
self.backpack = CogdoUtil.loadFlyingModel('propellerPack')
self.backpack.setScale(1.3)
self.backpack.setHpr(180.0, 0.0, 0.0)
self.backpackInstances = []
self.backpackTextureCard = CogdoUtil.loadFlyingModel(
'propellerPack_card')
parts = self.toon.getTorsoParts()
for part in parts:
backpackInstance = part.attachNewNode('backpackInstance')
animal = self.toon.style.getAnimal()
bodyScale = ToontownGlobals.toonBodyScales[animal]
backpackHeight = ToontownGlobals.torsoHeightDict[
self.toon.style.torso] * bodyScale - 0.5
backpackInstance.setPos(0.0, -0.325, backpackHeight)
self.backpackInstances.append(backpackInstance)
self.backpack.instanceTo(backpackInstance)
self.propInstances = []
self.propeller = CogdoUtil.loadFlyingModel('toonPropeller')
for part in self.backpackInstances:
propInstance = part.attachNewNode('propInstance')
propInstance.setPos(0.0, -0.275, 0.0)
propInstance.setHpr(0.0, 20.0, 0.0)
propInstance.setScale(1.0, 1.0, 1.25)
self.propInstances.append(propInstance)
self.propeller.instanceTo(propInstance)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propeller.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propeller.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
def createRedTapeRing(self):
self.redTapeRing = CogdoUtil.loadFlyingModel('redTapeRing')
self.redTapeRing.setTwoSided(True)
self.redTapeRing.reparentTo(self.toon)
self.redTapeRing.hide()
self.redTapeRing.setScale(1.25)
self.redTapeRing.setZ(self.toon.getHeight() / 2.0)
def initIntervals(self):
self.baseSpinDuration = 1.0
self.propellerSpinLerp = LerpFunctionInterval(
self.propeller.setH,
fromData=0.0,
toData=360.0,
duration=self.baseSpinDuration,
name='%s.propellerSpinLerp-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.TargetedWarningSingleBlinkTime
blinkTime = Globals.Gameplay.TargetedWarningBlinkTime
self.blinkLoop = Sequence(
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Attacked),
Wait(singleBlinkTime / 2.0),
Func(self.setBackpackTexture,
Globals.Gameplay.BackpackStates.Targeted),
name='%s.blinkLoop-%s' % (self.__class__.__name__, self.toon.doId))
self.blinkWarningSeq = Sequence(
Func(self.blinkLoop.loop),
Wait(blinkTime),
Func(self.blinkLoop.clearToInitial),
name='%s.blinkWarningSeq-%s' %
(self.__class__.__name__, self.toon.doId))
dur = Globals.Gameplay.BackpackRefuelDuration
self.refuelSeq = Sequence(
Func(self.setPropellerSpinRate, Globals.Gameplay.RefuelPropSpeed),
Wait(dur),
Func(self.returnBackpackToLastStateFunc),
name='%s.refuelSeq-%s' % (self.__class__.__name__, self.toon.doId))
scale = self.redTapeRing.getScale()
pulseTime = 1.0
self.pulseBubbleSeq = Parallel(
Sequence(
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale,
toData=scale * 1.1,
duration=pulseTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setScale,
fromData=scale * 1.1,
toData=scale,
duration=pulseTime / 2.0,
blendType='easeInOut')),
LerpHprInterval(self.redTapeRing,
pulseTime,
Vec3(360, 0, 0),
startHpr=Vec3(0, 0, 0)),
name='%s.pulseBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
bouncePercent = 1.2
scaleTime = 0.5
scaleBounceTime = 0.25
self.popUpBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleTime,
scale * bouncePercent,
startScale=0.0,
blendType='easeInOut')
self.popUpBubbleSeq = Sequence(
Func(self.updateLerpStartScale, self.popUpBubbleLerp,
self.redTapeRing),
Func(self.redTapeRing.show),
self.popUpBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.pulseBubbleSeq.loop),
name='%s.popUpBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.removeBubbleLerp = LerpScaleInterval(self.redTapeRing,
scaleBounceTime,
scale * bouncePercent,
startScale=scale,
blendType='easeInOut')
self.removeBubbleSeq = Sequence(
Func(self.pulseBubbleSeq.clearToInitial),
Func(self.updateLerpStartScale, self.removeBubbleLerp,
self.redTapeRing),
self.removeBubbleLerp,
LerpScaleInterval(self.redTapeRing,
scaleTime,
0.0,
startScale=scale * bouncePercent,
blendType='easeInOut'),
Func(self.redTapeRing.hide),
name='%s.removeBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
self.redTapeRing.setScale(0.0)
self.deathInterval = Sequence(
Parallel(
LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)),
LerpFunctionInterval(self.toon.setScale,
fromData=1.0,
toData=0.1,
duration=1.0)),
Func(self.toon.stash),
name='%s.deathInterval-%s' %
(self.__class__.__name__, self.toon.doId))
self.spawnInterval = Sequence(
Func(self.toon.stash),
Func(self.resetToon),
Wait(1.0),
Func(self.toon.setAnimState, 'TeleportIn'),
Func(self.toon.unstash),
name='%s.spawnInterval-%s' %
(self.__class__.__name__, self.toon.doId))
singleBlinkTime = Globals.Gameplay.InvulSingleBlinkTime
blinkTime = Globals.Gameplay.InvulBlinkTime
invulBuffTime = Globals.Gameplay.InvulBuffTime
self.blinkBubbleLoop = Sequence(
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=1.0,
toData=0.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
LerpFunctionInterval(self.redTapeRing.setAlphaScale,
fromData=0.0,
toData=1.0,
duration=singleBlinkTime / 2.0,
blendType='easeInOut'),
name='%s.blinkBubbleLoop-%s' %
(self.__class__.__name__, self.toon.doId))
self.blinkBubbleSeq = Sequence(
Wait(invulBuffTime - blinkTime),
Func(self.blinkBubbleLoop.loop),
Wait(blinkTime),
Func(self.blinkBubbleLoop.finish),
name='%s.blinkBubbleSeq-%s' %
(self.__class__.__name__, self.toon.doId))
def returnBackpackToLastStateFunc(self):
if self.backpackState == Globals.Gameplay.BackpackStates.Refuel:
self.returnBackpackToLastState()
def setPropellerSpinRateFunc(self):
if self.propellerSpinRate == Globals.Gameplay.RefuelPropSpeed:
self.setPropellerSpinRate(self.lastPropellerSpinRate)
def returnBackpackToLastState(self):
self.setBackpackState(self.lastBackpackState)
def setBackpackState(self, state):
if state == self.backpackState:
return
self.lastBackpackState = self.backpackState
self.backpackState = state
self.blinkWarningSeq.clearToInitial()
self.refuelSeq.clearToInitial()
self.blinkLoop.clearToInitial()
if self.lastBackpackState == Globals.Gameplay.BackpackStates.Refuel:
self.setPropellerSpinRateFunc()
if state in Globals.Gameplay.BackpackStates:
if state == Globals.Gameplay.BackpackStates.Normal:
pass
elif state == Globals.Gameplay.BackpackStates.Targeted:
pass
elif state == Globals.Gameplay.BackpackStates.Refuel:
self.refuelSeq.start()
elif state == Globals.Gameplay.BackpackStates.Attacked:
self.blinkWarningSeq.start()
self.setBackpackTexture(state)
def setBackpackTexture(self, state):
texName = Globals.Gameplay.BackpackState2TextureName[state]
tex = self.backpackTextureCard.findTexture(texName)
self.backpack.setTexture(tex, 1)
def updateLerpStartScale(self, lerp, nodepath):
lerp.setStartScale(nodepath.getScale())
def handleEnterGatherable(self, gatherable, elapsedTime):
if gatherable.type == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.clearToInitial()
self.blinkBubbleSeq.start(elapsedTime)
self.removeBubbleSeq.clearToInitial()
self.popUpBubbleSeq.start()
if gatherable.type not in self.activeBuffs:
self.activeBuffs.append(gatherable.type)
elif gatherable.type == Globals.Level.GatherableTypes.Propeller:
self.setBackpackState(Globals.Gameplay.BackpackStates.Refuel)
def handleDebuffPowerup(self, pickupType, elapsedTime):
if pickupType == Globals.Level.GatherableTypes.InvulPowerup:
self.blinkBubbleSeq.finish()
self.popUpBubbleSeq.clearToInitial()
self.removeBubbleSeq.start()
if pickupType in self.activeBuffs:
self.activeBuffs.remove(pickupType)
def isBuffActive(self, pickupType):
if pickupType in self.activeBuffs:
return True
return False
def isInvulnerable(self):
if Globals.Level.GatherableTypes.InvulPowerup in self.activeBuffs:
return True
return False
def setFuelState(self, fuelState):
self.fuelState = fuelState
def setOldFuelState(self, fuelState):
self.oldFuelState = fuelState
def hasFuelStateChanged(self):
if self.fuelState != self.oldFuelState:
return True
else:
return False
def updatePropellerSmoke(self):
if not self.hasFuelStateChanged():
return
if self.fuelState in [
Globals.Gameplay.FuelStates.FuelNoPropeller,
Globals.Gameplay.FuelStates.FuelNormal
]:
self.propellerSmoke.stop()
elif self.fuelState in [
Globals.Gameplay.FuelStates.FuelVeryLow,
Globals.Gameplay.FuelStates.FuelEmpty
]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.25)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.5)
self.propellerSmoke.loop(rate=48)
elif self.fuelState in [Globals.Gameplay.FuelStates.FuelLow]:
self.propellerSmoke.stop()
self.propellerSmoke.setScale(0.0825)
self.propellerSmoke.setZ(self.toon.getHeight() + 2.0)
self.propellerSmoke.loop(rate=24)
def resetBlades(self):
self.setBlades(len(self.blades))
def setAsLegalEagleTarget(self, legalEagle):
if legalEagle not in self.legalEaglesTargeting:
self.legalEaglesTargeting.append(legalEagle)
def removeAsLegalEagleTarget(self, legalEagle):
if legalEagle in self.legalEaglesTargeting:
self.legalEaglesTargeting.remove(legalEagle)
def isLegalEagleTarget(self):
if len(self.legalEaglesTargeting) > 0:
return True
else:
return False
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in xrange(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
if numBlades > 0:
for i in xrange(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
if fuelState == Globals.Gameplay.FuelStates.FuelNoPropeller:
for prop in self.propInstances:
prop.hide()
else:
for prop in self.propInstances:
prop.show()
self.setFuelState(fuelState)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.setFuelState(len(self.activeBlades) + 1)
self.updatePropellerSmoke()
self.setOldFuelState(self.fuelState)
def setPropellerSpinRate(self, newRate):
self.lastPropellerSpinRate = self.propellerSpinRate
self.propellerSpinRate = newRate
self.notify.debug(
'(%s) New propeller speed:%s, old propeller speed:%s' %
(self.toon.doId, self.propellerSpinRate,
self.lastPropellerSpinRate))
self.propellerSpinLerp.setPlayRate(newRate)
def died(self, elapsedTime):
self.deathInterval.start(elapsedTime)
self.propellerSmoke.stop()
def spawn(self, elapsedTime):
self.spawnInterval.start(elapsedTime)
def resetToon(self):
self.toon.setScale(1.0)
def enable(self):
self.toon.setAnimState('Happy', 1.0)
self.toon.setForceJumpIdle(True)
self.toon.setSpeed(0, 0)
self.setPropellerSpinRate(Globals.Gameplay.NormalPropSpeed)
self.propellerSpinLerp.loop()
def disable(self):
pass
def unload(self):
self.ignoreAll()
if self.toon:
self.toon.showName()
self.backpackTextureCard.removeNode()
del self.backpackTextureCard
self.refuelSeq.clearToInitial()
del self.refuelSeq
self.pulseBubbleSeq.clearToInitial()
del self.pulseBubbleSeq
self.blinkBubbleLoop.clearToInitial()
del self.blinkBubbleLoop
self.blinkBubbleSeq.clearToInitial()
del self.blinkBubbleSeq
self.popUpBubbleLerp.clearToInitial()
del self.popUpBubbleLerp
self.popUpBubbleSeq.clearToInitial()
del self.popUpBubbleSeq
self.removeBubbleLerp.clearToInitial()
del self.removeBubbleLerp
self.removeBubbleSeq.clearToInitial()
del self.removeBubbleSeq
self.propellerSmoke.destroy()
del self.propellerSmoke
self.blinkWarningSeq.clearToInitial()
del self.blinkWarningSeq
self.blinkLoop.clearToInitial()
del self.blinkLoop
self.redTapeRing.removeNode()
del self.redTapeRing
self.propellerSpinLerp.clearToInitial()
del self.propellerSpinLerp
for prop in self.propInstances:
prop.removeNode()
del self.propInstances[:]
self.propeller.removeNode()
del self.propeller
for backpack in self.backpackInstances:
backpack.removeNode()
del self.backpackInstances[:]
self.backpack.removeNode()
del self.backpack
del self.activeBuffs[:]
del self.legalEaglesTargeting[:]
del self.toon
self.toon = None
if self.deathInterval:
self.deathInterval.clearToInitial()
self.deathInterval = None
if self.spawnInterval:
self.spawnInterval.clearToInitial()
self.spawnInterval = None
return
def start(self):
swapAvatarShadowPlacer(self.toon,
self.toon.uniqueName('toonShadowPlacer'))
self.toon.startSmooth()
def exit(self):
self.toon.setForceJumpIdle(False)
self.propellerSmoke.reparentTo(hidden)
self.propellerSmoke.stop()
if self.toon:
CogdoFlyingPlayer.resetToon(self)
self.toon.setActiveShadow(0)
self.toon.deleteDropShadow()
self.toon.initializeDropShadow()
self.toon.setActiveShadow(1)
else:
self.notify.warning("There's no toon in offstage, this is bad!")
def initIntervals(self):
self.deathInterval = Sequence(
Func(self.inputMgr.disable),
Parallel(
LerpHprInterval(self.toon, 1.0, Vec3(720, 0, 0)),
LerpFunctionInterval(self.toon.setScale,
fromData=1.0,
toData=0.0,
duration=1.0)),
Func(self.resetToon),
Wait(
0.5
), # Added this because with no pause here the FreeFly prop sound was attached to the old toon pos
Func(self.request, "FreeFly"),
name="%s.deathInterval" % (self.__class__.__name__))
self.refuelInterval = Sequence(
Func(self.guiMgr.setRefuelLerpFromData),
Func(self.guiMgr.messageLabel.unstash),
Parallel(
self.guiMgr.refuelLerp,
Sequence(
Func(self.guiMgr.setMessageLabelText, "Refueling"),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling."),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling.."),
Wait(0.5),
Func(self.guiMgr.setMessageLabelText, "Refueling..."),
Wait(0.5),
),
),
Func(self.resetFuel),
Func(self.guiMgr.messageLabel.stash),
Func(self.request, "FreeFly"),
name="%s.refuelInterval" % (self.__class__.__name__))
self.waitingForWinInterval = Sequence(
Func(self.guiMgr.setMessageLabelText, "Waiting for other players"),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players."),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players.."),
Wait(1.5),
Func(self.guiMgr.setMessageLabelText,
"Waiting for other players..."),
Wait(1.5),
name="%s.waitingForWinInterval" % (self.__class__.__name__))
self.winInterval = Sequence(Func(self.guiMgr.setMessageLabelText, ""),
Wait(1.0),
Func(self.guiMgr.winLabel.unstash),
Wait(2.0),
Func(self.guiMgr.winLabel.stash),
Wait(0.5),
Func(messenger.send, "escape"),
name="%s.waitingForWinInterval" %
(self.__class__.__name__))
self.slowPropTrack = Parallel(
ActorInterval(self.props['1000'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
ActorInterval(self.props['500'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
ActorInterval(self.props['250'],
'propeller',
startFrame=8,
endFrame=23,
playRate=1.0),
)
self.fastPropTrack = Parallel(
ActorInterval(self.props['1000'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
ActorInterval(self.props['500'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
ActorInterval(self.props['250'],
'propeller',
startFrame=8,
endFrame=23,
playRate=2.0),
)
class SmartCamera:
UPDATE_TASK_NAME = 'update_smartcamera'
notify = directNotify.newCategory('SmartCamera')
def __init__(self):
self.cTrav = CollisionTraverser('cam_traverser')
base.pushCTrav(self.cTrav)
self.cTrav.setRespectPrevTransform(1)
self.default_pos = None
self.parent = None
self.initialized = False
self.started = False
self.camFloorRayNode = None
self.ccRay2 = None
self.ccRay2Node = None
self.ccRay2NodePath = None
self.ccRay2BitMask = None
self.ccRay2MoveNodePath = None
self.camFloorCollisionBroadcaster = None
self.notify.debug('SmartCamera initialized!')
return
def lerpCameraFov(self, fov, time):
taskMgr.remove('cam-fov-lerp-play')
oldFov = base.camLens.getHfov()
if abs(fov - oldFov) > 0.1:
def setCamFov(fov):
base.camLens.setMinFov(fov / (4.0 / 3.0))
self.camLerpInterval = LerpFunctionInterval(setCamFov, fromData=oldFov, toData=fov, duration=time, name='cam-fov-lerp')
self.camLerpInterval.start()
def setCameraFov(self, fov):
self.fov = fov
if not (self.isPageDown or self.isPageUp):
base.camLens.setMinFov(self.fov / (4.0 / 3.0))
def initCameraPositions(self):
camHeight = max(base.localAvatar.getHeight(), 3.0)
nrCamHeight = base.localAvatar.getHeight()
heightScaleFactor = camHeight * 0.3333333333
defLookAt = Point3(0.0, 1.5, camHeight)
self.firstPersonCamPos = Point3(0.0, 0.7, nrCamHeight * 5.0)
scXoffset = 3.0
scPosition = (Point3(scXoffset - 1, -10.0, camHeight + 5.0), Point3(scXoffset, 2.0, camHeight))
self.cameraPositions = [
(Point3(0.0, -9.0 * heightScaleFactor, camHeight),
defLookAt,
Point3(0.0, camHeight, camHeight * 4.0),
Point3(0.0, camHeight, camHeight * -1.0),
0),
(
Point3(0.0, 0.7, camHeight),
defLookAt,
Point3(0.0, camHeight, camHeight * 1.33),
Point3(0.0, camHeight, camHeight * 0.66),
1),
(
Point3(5.7 * heightScaleFactor, 7.65 * heightScaleFactor, camHeight + 2.0),
Point3(0.0, 1.0, camHeight),
Point3(0.0, 1.0, camHeight * 4.0),
Point3(0.0, 1.0, camHeight * -1.0),
0),
(
Point3(0.0, 8.65 * heightScaleFactor, camHeight),
Point3(0.0, 1.0, camHeight),
Point3(0.0, 1.0, camHeight * 4.0),
Point3(0.0, 1.0, camHeight * -1.0),
0),
(
Point3(0.0, -24.0 * heightScaleFactor, camHeight + 4.0),
defLookAt,
Point3(0.0, 1.5, camHeight * 4.0),
Point3(0.0, 1.5, camHeight * -1.0),
0),
(
Point3(0.0, -12.0 * heightScaleFactor, camHeight + 4.0),
defLookAt,
Point3(0.0, 1.5, camHeight * 4.0),
Point3(0.0, 1.5, camHeight * -1.0),
0)]
def pageUp(self):
if not base.localAvatar.avatarMovementEnabled:
return
if not self.isPageUp:
self.isPageDown = 0
self.isPageUp = 1
self.lerpCameraFov(70, 0.6)
self.setCameraPositionByIndex(self.cameraIndex)
else:
self.clearPageUpDown()
def pageDown(self):
if not base.localAvatar.avatarMovementEnabled:
return
if not self.isPageDown:
self.isPageUp = 0
self.isPageDown = 1
self.lerpCameraFov(70, 0.6)
self.setCameraPositionByIndex(self.cameraIndex)
else:
self.clearPageUpDown()
def clearPageUpDown(self):
if self.isPageDown or self.isPageUp:
self.lerpCameraFov(self.fov, 0.6)
self.isPageDown = 0
self.isPageUp = 0
self.setCameraPositionByIndex(self.cameraIndex)
def nextCameraPos(self, forward):
if not base.localAvatar.avatarMovementEnabled:
return
self.__cameraHasBeenMoved = 1
if forward:
self.cameraIndex += 1
if self.cameraIndex > len(self.cameraPositions) - 1:
self.cameraIndex = 0
else:
self.cameraIndex -= 1
if self.cameraIndex < 0:
self.cameraIndex = len(self.cameraPositions) - 1
self.setCameraPositionByIndex(self.cameraIndex)
def setCameraPositionByIndex(self, index):
self.notify.debug('switching to camera position %s' % index)
self.setCameraSettings(self.cameraPositions[index])
def setCameraSettings(self, camSettings):
self.setIdealCameraPos(camSettings[0])
if self.isPageUp and self.isPageDown or not self.isPageUp and not self.isPageDown:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[1])
else:
if self.isPageUp:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[2])
else:
if self.isPageDown:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[3])
else:
self.notify.error('This case should be impossible.')
self.__disableSmartCam = camSettings[4]
if self.__disableSmartCam:
self.putCameraFloorRayOnAvatar()
self.cameraZOffset = 0.0
def set_default_pos(self, pos):
self.default_pos = pos
def get_default_pos(self):
return self.default_pos
def set_parent(self, parent):
self.parent = parent
def get_parent(self):
return self.parent
def getVisibilityPoint(self):
return Point3(0.0, 0.0, base.localAvatar.getHeight())
def setLookAtPoint(self, la):
self.__curLookAt = Point3(la)
def getLookAtPoint(self):
return Point3(self.__curLookAt)
def setIdealCameraPos(self, pos):
self.__idealCameraPos = Point3(pos)
self.updateSmartCameraCollisionLineSegment()
def getIdealCameraPos(self):
return Point3(self.__idealCameraPos)
def getCompromiseCameraPos(self):
if self.__idealCameraObstructed == 0:
compromisePos = self.getIdealCameraPos()
else:
visPnt = self.getVisibilityPoint()
idealPos = self.getIdealCameraPos()
distance = Vec3(idealPos - visPnt).length()
ratio = self.closestObstructionDistance / distance
compromisePos = idealPos * ratio + visPnt * (1 - ratio)
liftMult = 1.0 - ratio * ratio
compromisePos = Point3(compromisePos[0], compromisePos[1], compromisePos[2] + base.localAvatar.getHeight() * 0.4 * liftMult)
compromisePos.setZ(compromisePos[2] + self.cameraZOffset)
return compromisePos
def updateSmartCameraCollisionLineSegment(self):
pointB = self.getIdealCameraPos()
pointA = self.getVisibilityPoint()
vectorAB = Vec3(pointB - pointA)
lengthAB = vectorAB.length()
if lengthAB > 0.001:
self.ccLine.setPointA(pointA)
self.ccLine.setPointB(pointB)
def initializeSmartCamera(self):
self.__idealCameraObstructed = 0
self.closestObstructionDistance = 0.0
self.cameraIndex = 0
self.cameraPositions = []
self.auxCameraPositions = []
self.cameraZOffset = 0.0
self.setGeom(render)
self.__onLevelGround = 0
self.__camCollCanMove = 0
self.__disableSmartCam = 0
self.initializeSmartCameraCollisions()
self._smartCamEnabled = False
self.isPageUp = 0
self.isPageDown = 0
self.fov = CIGlobals.DefaultCameraFov
def enterFirstPerson(self):
self.stop_smartcamera()
if hasattr(self.get_parent(), 'toon_head'):
head = self.get_parent().toon_head
camera.reparentTo(head)
camera.setPos(0, -0.35, 0)
camera.setHpr(0, 0, 0)
def exitFirstPerson(self):
self.initialize_smartcamera()
self.initialize_smartcamera_collisions()
self.start_smartcamera()
def putCameraFloorRayOnAvatar(self):
self.camFloorRayNode.setPos(base.localAvatar, 0, 0, 5)
def putCameraFloorRayOnCamera(self):
self.camFloorRayNode.setPos(self.ccSphereNodePath, 0, 0, 0)
def recalcCameraSphere(self):
nearPlaneDist = base.camLens.getNear()
hFov = base.camLens.getHfov()
vFov = base.camLens.getVfov()
hOff = nearPlaneDist * math.tan(deg2Rad(hFov / 2.0))
vOff = nearPlaneDist * math.tan(deg2Rad(vFov / 2.0))
camPnts = [Point3(hOff, nearPlaneDist, vOff),
Point3(-hOff, nearPlaneDist, vOff),
Point3(hOff, nearPlaneDist, -vOff),
Point3(-hOff, nearPlaneDist, -vOff),
Point3(0.0, 0.0, 0.0)]
avgPnt = Point3(0.0, 0.0, 0.0)
for camPnt in camPnts:
avgPnt = avgPnt + camPnt
avgPnt = avgPnt / len(camPnts)
sphereRadius = 0.0
for camPnt in camPnts:
dist = Vec3(camPnt - avgPnt).length()
if dist > sphereRadius:
sphereRadius = dist
avgPnt = Point3(avgPnt)
self.ccSphereNodePath.setPos(avgPnt)
self.ccSphereNodePath2.setPos(avgPnt)
self.ccSphere.setRadius(sphereRadius)
def setGeom(self, geom):
self.__geom = geom
def initializeSmartCameraCollisions(self):
if self.initialized:
return
self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav')
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode)
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.camCollisionQueue = CollisionHandlerQueue()
self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue)
self.ccSphere = CollisionSphere(0, 0, 0, 1)
self.ccSphereNode = CollisionNode('ccSphereNode')
self.ccSphereNode.addSolid(self.ccSphere)
self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode)
self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode.setIntoCollideMask(BitMask32.allOff())
self.camPusher = CollisionHandlerPusher()
self.camPusher.addCollider(self.ccSphereNodePath, base.camera)
self.camPusher.setCenter(base.localAvatar)
self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav')
self.ccSphere2 = self.ccSphere
self.ccSphereNode2 = CollisionNode('ccSphereNode2')
self.ccSphereNode2.addSolid(self.ccSphere2)
self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2)
self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff())
self.camPusher2 = CollisionHandlerPusher()
self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2)
self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera)
self.camPusher2.setCenter(base.localAvatar)
self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode')
self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRayNode = CollisionNode('ccRayNode')
self.ccRayNode.addSolid(self.ccRay)
self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode)
self.ccRayBitMask = CIGlobals.FloorBitmask
self.ccRayNode.setFromCollideMask(self.ccRayBitMask)
self.ccRayNode.setIntoCollideMask(BitMask32.allOff())
self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor')
self.camFloorCollisionQueue = CollisionHandlerQueue()
self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue)
self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor')
self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRay2Node = CollisionNode('ccRay2Node')
self.ccRay2Node.addSolid(self.ccRay2)
self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node)
self.ccRay2BitMask = CIGlobals.FloorBitmask
self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask)
self.ccRay2Node.setIntoCollideMask(BitMask32.allOff())
self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode')
self.camFloorCollisionBroadcaster = CollisionHandlerFloor()
self.camFloorCollisionBroadcaster.setInPattern('on-floor')
self.camFloorCollisionBroadcaster.setOutPattern('off-floor')
self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath)
self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster)
self.initialized = True
def deleteSmartCameraCollisions(self):
del self.ccTrav
del self.ccLine
del self.ccLineNode
self.ccLineNodePath.removeNode()
del self.ccLineNodePath
del self.camCollisionQueue
del self.ccRay
del self.ccRayNode
self.ccRayNodePath.removeNode()
del self.ccRayNodePath
del self.ccRay2
del self.ccRay2Node
self.ccRay2NodePath.removeNode()
del self.ccRay2NodePath
self.ccRay2MoveNodePath.removeNode()
del self.ccRay2MoveNodePath
del self.ccTravOnFloor
del self.ccTravFloor
del self.camFloorCollisionQueue
del self.camFloorCollisionBroadcaster
del self.ccSphere
del self.ccSphereNode
self.ccSphereNodePath.removeNode()
del self.ccSphereNodePath
del self.camPusher
del self.ccPusherTrav
del self.ccSphere2
del self.ccSphereNode2
self.ccSphereNodePath2.removeNode()
del self.ccSphereNodePath2
del self.camPusher2
self.initialized = False
def startUpdateSmartCamera(self):
if self.started:
return
self.__floorDetected = 0
self.__cameraHasBeenMoved = 1
self.recalcCameraSphere()
self.__instantaneousCamPos = camera.getPos()
self.cTrav.addCollider(self.ccSphereNodePath, self.camPusher)
self.ccTravOnFloor.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster)
self.__disableSmartCam = 0
self.__lastPosWrtRender = camera.getPos(render) + 1
self.__lastHprWrtRender = camera.getHpr(render) + 1
taskName = base.localAvatar.taskName('updateSmartCamera')
taskMgr.remove(taskName)
taskMgr.add(self.updateSmartCamera, taskName, priority=47)
self.started = True
def stopUpdateSmartCamera(self):
self.cTrav.removeCollider(self.ccSphereNodePath)
self.ccTravOnFloor.removeCollider(self.ccRay2NodePath)
taskName = base.localAvatar.taskName('updateSmartCamera')
taskMgr.remove(taskName)
camera.setPos(self.getIdealCameraPos())
self.started = False
def updateSmartCamera(self, task):
if not self.__camCollCanMove and not self.__cameraHasBeenMoved:
if self.__lastPosWrtRender == camera.getPos(render):
if self.__lastHprWrtRender == camera.getHpr(render):
return Task.cont
self.__cameraHasBeenMoved = 0
self.__lastPosWrtRender = camera.getPos(render)
self.__lastHprWrtRender = camera.getHpr(render)
self.__idealCameraObstructed = 0
if not self.__disableSmartCam:
self.ccTrav.traverse(self.__geom)
if self.camCollisionQueue.getNumEntries() > 0:
try:
self.camCollisionQueue.sortEntries()
self.handleCameraObstruction(self.camCollisionQueue.getEntry(0))
except AssertionError:
pass
if not self.__onLevelGround:
self.handleCameraFloorInteraction()
if not self.__idealCameraObstructed:
self.nudgeCamera()
if not self.__disableSmartCam:
self.ccPusherTrav.traverse(self.__geom)
self.putCameraFloorRayOnCamera()
self.ccTravOnFloor.traverse(self.__geom)
return Task.cont
def positionCameraWithPusher(self, pos, lookAt):
camera.setPos(pos)
self.ccPusherTrav.traverse(self.__geom)
camera.lookAt(lookAt)
def nudgeCamera(self):
CLOSE_ENOUGH = 0.1
curCamPos = self.__instantaneousCamPos
curCamHpr = camera.getHpr()
targetCamPos = self.getCompromiseCameraPos()
targetCamLookAt = self.getLookAtPoint()
posDone = 0
if Vec3(curCamPos - targetCamPos).length() <= CLOSE_ENOUGH:
camera.setPos(targetCamPos)
posDone = 1
camera.setPos(targetCamPos)
camera.lookAt(targetCamLookAt)
targetCamHpr = camera.getHpr()
hprDone = 0
if Vec3(curCamHpr - targetCamHpr).length() <= CLOSE_ENOUGH:
hprDone = 1
if posDone and hprDone:
return
lerpRatio = 0.15
lerpRatio = 1 - pow(1 - lerpRatio, globalClock.getDt() * 30.0)
self.__instantaneousCamPos = targetCamPos * lerpRatio + curCamPos * (1 - lerpRatio)
if self.__disableSmartCam or not self.__idealCameraObstructed:
newHpr = targetCamHpr * lerpRatio + curCamHpr * (1 - lerpRatio)
else:
newHpr = targetCamHpr
camera.setPos(self.__instantaneousCamPos)
camera.setHpr(newHpr)
def popCameraToDest(self):
newCamPos = self.getCompromiseCameraPos()
newCamLookAt = self.getLookAtPoint()
self.positionCameraWithPusher(newCamPos, newCamLookAt)
self.__instantaneousCamPos = camera.getPos()
def handleCameraObstruction(self, camObstrCollisionEntry):
collisionPoint = camObstrCollisionEntry.getSurfacePoint(self.ccLineNodePath)
collisionVec = Vec3(collisionPoint - self.ccLine.getPointA())
distance = collisionVec.length()
self.__idealCameraObstructed = 1
self.closestObstructionDistance = distance
self.popCameraToDest()
def handleCameraFloorInteraction(self):
self.putCameraFloorRayOnCamera()
self.ccTravFloor.traverse(self.__geom)
if self.__onLevelGround:
return
if self.camFloorCollisionQueue.getNumEntries() == 0:
return
self.camFloorCollisionQueue.sortEntries()
camObstrCollisionEntry = self.camFloorCollisionQueue.getEntry(0)
camHeightFromFloor = camObstrCollisionEntry.getSurfacePoint(self.ccRayNodePath)[2]
self.cameraZOffset = camera.getPos()[2] + camHeightFromFloor
if self.cameraZOffset < 0:
self.cameraZOffset = 0
if self.__floorDetected == 0:
self.__floorDetected = 1
self.popCameraToDest()
def setEveryoneDone(self):
if not self.hasLocalToon: return
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return
self.notify.debug('setEveryoneDone')
def endGame(task, self=self):
if not PairingGameGlobals.EndlessGame:
self.gameOver()
return Task.done
# hide the timer
self.timer.hide()
# hide the bonus
self.bonusGlow.hide()
# if it was a perfect game, let the players know
if len(self.inactiveList) == len(self.cards):
self.notify.debug("perfect game!")
perfectTextSubnode = hidden.attachNewNode(
self.__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
# offset the subnode so that the text is centered on both axes
# we need the parent node so that the text will scale correctly
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, .1, .1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=.5,
scale=.3,
startScale=0.),
LerpFunctionInterval(
fadeFunc,
fromData=0.,
toData=1.,
duration=.5,
)),
Wait(2.),
Parallel(
LerpScaleInterval(perfectText, duration=.5, scale=1.),
LerpFunctionInterval(fadeFunc,
fromData=1.,
toData=0.,
duration=.5,
blendType="easeIn"),
),
Func(destroyText),
WaitInterval(.5),
Func(endGame, None),
)
soundTrack = SoundInterval(self.sndPerfect)
self.perfectIval = Parallel(textTrack, soundTrack)
self.perfectIval.start()
else:
taskMgr.doMethodLater(1, endGame, self.EndGameTaskName)
def setIndex(self, index):
self.index = index
hood = self.cr.playGame.hood
hoodAbbr = None
if self.index == 0:
hoodAbbr = hood.abbr
elif self.index == 1:
hoodAbbr = 'TT' #ZoneUtil.ZoneId2HoodAbbr[self.toZone]
self.hoodAbbr = hoodAbbr
findStr = '**/prop_trolley_station_' + hoodAbbr + '_DNARoot'
self.trolleyStation = hood.loader.geom.find(findStr)
self.trolleyStation.flattenStrong()
self.trolleyCar = self.trolleyStation.find('**/trolley_car')
self.trolleyKey = self.trolleyStation.find('**/key')
base.audio3d.attachSoundToObject(self.trolleyAwaySfx, self.trolleyCar)
base.audio3d.attachSoundToObject(self.trolleyBellSfx, self.trolleyCar)
exitFog = Fog('TrolleyExitFog')
exitFog.setColor(0.0, 0.0, 0.0)
exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)
exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)
exitFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)
self.trolleyExitFogNode = exitFog
enterFog = Fog('TrolleyEnterFog')
enterFog.setColor(0.0, 0.0, 0.0)
enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)
enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)
enterFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)
self.trolleyEnterFogNode = enterFog
self.trolleyCar.setFogOff()
tn = TextNode('trolleycountdowntext')
tn.setFont(CIGlobals.getMickeyFont())
tn.setTextColor(1, 0, 0, 1)
tn.setAlign(TextNode.ACenter)
self.keys = self.trolleyCar.findAllMatches('**/key')
self.numKeys = self.keys.getNumPaths()
self.keyInit = []
self.keyRef = []
for i in range(self.numKeys):
key = self.keys[i]
key.setTwoSided(1)
ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')
ref.setPosHpr(key, 0, 0, 0, 0, 0, 0)
self.keyRef.append(ref)
self.keyInit.append(key.getTransform())
self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')
self.numFrontWheels = self.frontWheels.getNumPaths()
self.frontWheelInit = []
self.frontWheelRef = []
for i in range(self.numFrontWheels):
wheel = self.frontWheels[i]
ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.frontWheelRef.append(ref)
self.frontWheelInit.append(wheel.getTransform())
self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')
self.numBackWheels = self.backWheels.getNumPaths()
self.backWheelInit = []
self.backWheelRef = []
for i in range(self.numBackWheels):
wheel = self.backWheels[i]
ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')
ref.setPosHpr(wheel, 0, 0, 0, 0, 0, 0)
self.backWheelRef.append(ref)
self.backWheelInit.append(wheel.getTransform())
trolleyAnimationReset = Func(self.resetAnimation)
trolleyEnterStartPos = Point3(-20, 14, -1)
trolleyEnterEndPos = Point3(15, 14, -1)
trolleyEnterPos = Sequence(name='TrolleyEnterPos')
trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))
trolleyEnterPos.append(self.trolleyCar.posInterval(TROLLEY_ENTER_TIME, trolleyEnterEndPos, startPos=trolleyEnterStartPos, blendType='easeOut'))
trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))
trolleyEnterTrack = Sequence(trolleyAnimationReset, trolleyEnterPos, name='trolleyEnter')
keyAngle = round(TROLLEY_ENTER_TIME) * 360
dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyEnterAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_ENTER_TIME, blendType='easeOut', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
self.trolleyEnterTrack = Parallel(trolleyEnterTrack, trolleyEnterAnimateInterval, trolleyEnterSoundTrack)
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitPos = Sequence(name='TrolleyExitPos')
trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))
trolleyExitPos.append(self.trolleyCar.posInterval(TROLLEY_EXIT_TIME, trolleyExitEndPos, startPos=trolleyExitStartPos, blendType='easeIn'))
trolleyExitPos.append(Func(self.trolleyCar.setFogOff))
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)
trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
keyAngle = round(TROLLEY_EXIT_TIME) * 360
dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyExitAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_EXIT_TIME, blendType='easeIn', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
self.trolleyExitTrack = Parallel(trolleyExitPos, trolleyExitBellInterval, trolleyExitAwayInterval, trolleyExitAnimateInterval, name=self.uniqueName('trolleyExit'))
self.countdownText = self.trolleyStation.attachNewNode(tn)
self.countdownText.setScale(3.0)
self.countdownText.setPos(14.58, 10.77, 11.17)
try:
self.trolleySphere = self.trolleyStation.find('**/trolley_sphere')
self.trolleySphere.setName('trolley{0}_sphere'.format(hoodAbbr))
except:
pass
class SmartCamera:
UPDATE_TASK_NAME = "update_smartcamera"
notify = directNotify.newCategory("SmartCamera")
OTSIndex = 0
def __init__(self):
self.cTrav = CollisionTraverser('cam_traverser')
base.pushCTrav(self.cTrav)
self.cTrav.setRespectPrevTransform(1)
self.default_pos = None
self.parent = None
self.initialized = False
self.started = False
self.camFloorRayNode = None
self.ccRay2 = None
self.ccRay2Node = None
self.ccRay2NodePath = None
self.ccRay2BitMask = None
self.ccRay2MoveNodePath = None
self.camFloorCollisionBroadcaster = None
self.pointA = Point3(0)
self.pointB = Point3(0)
self.floorLineStart = Point3(0)
self.camRadiusPoint = Point3(0)
self.notify.debug("SmartCamera initialized!")
def lerpCameraFov(self, fov, time):
taskMgr.remove('cam-fov-lerp-play')
oldFov = base.camLens.getHfov()
if abs(fov - oldFov) > 0.1:
def setCamFov(fov):
base.camLens.setMinFov(fov / (4. / 3.))
self.camLerpInterval = LerpFunctionInterval(setCamFov,
fromData=oldFov,
toData=fov,
duration=time,
name='cam-fov-lerp')
self.camLerpInterval.start()
def setCameraFov(self, fov):
self.fov = fov
if not (self.isPageDown or self.isPageUp):
base.camLens.setMinFov(self.fov / (4. / 3.))
def initCameraPositions(self):
camHeight = max(base.localAvatar.getHeight(), 3.0)
nrCamHeight = base.localAvatar.getHeight()
heightScaleFactor = camHeight * 0.3333333333
defLookAt = Point3(0.0, 1.5, camHeight)
self.firstPersonCamPos = Point3(0.0, 0.7, nrCamHeight * 5.0)
scXoffset = 3.0
scPosition = (Point3(scXoffset - 1, -10.0,
camHeight + 5.0), Point3(scXoffset, 2.0,
camHeight))
self.cameraPositions = [
(Point3(0.0, -9.0 * heightScaleFactor, camHeight), defLookAt,
Point3(0.0, camHeight,
camHeight * 4.0), Point3(0.0, camHeight,
camHeight * -1.0), 0),
(Point3(0.0, 0.7, camHeight), defLookAt,
Point3(0.0, camHeight,
camHeight * 1.33), Point3(0.0, camHeight,
camHeight * 0.66), 1),
(Point3(0.0, -24.0 * heightScaleFactor,
camHeight + 4.0), defLookAt,
Point3(0.0, 1.5,
camHeight * 4.0), Point3(0.0, 1.5, camHeight * -1.0), 0),
(Point3(0.0, -12.0 * heightScaleFactor,
camHeight + 4.0), defLookAt,
Point3(0.0, 1.5,
camHeight * 4.0), Point3(0.0, 1.5, camHeight * -1.0), 0)
]
gta = base.config.GetBool("want-gta-controls", False)
if not gta:
# Insert the two front facing camera angles.
self.cameraPositions.insert(
2, (Point3(5.7 * heightScaleFactor, 7.65 * heightScaleFactor,
camHeight + 2.0), Point3(0.0, 1.0, camHeight),
Point3(0.0, 1.0, camHeight * 4.0),
Point3(0.0, 1.0, camHeight * -1.0), 0))
self.cameraPositions.insert(
3, (Point3(0.0, 8.65 * heightScaleFactor,
camHeight), Point3(0.0, 1.0, camHeight),
Point3(0.0, 1.0, camHeight * 4.0),
Point3(0.0, 1.0, camHeight * -1.0), 0))
else:
# Insert an over the shoulder camera angle.
self.cameraPositions.insert(
self.OTSIndex, (Point3(1.0, -4.25 * heightScaleFactor,
camHeight), Point3(1.0, 1.5, camHeight),
Point3(0.0, camHeight, camHeight * 4.0),
Point3(0.0, camHeight, camHeight * -1.0), 0))
def pageUp(self):
if not base.localAvatarReachable() or (
base.localAvatarReachable()
and not base.localAvatar.avatarMovementEnabled):
return
if not self.isPageUp:
self.isPageDown = 0
self.isPageUp = 1
self.lerpCameraFov(70, 0.6)
self.setCameraPositionByIndex(self.cameraIndex)
else:
self.clearPageUpDown()
def pageDown(self):
if not base.localAvatarReachable() or (
base.localAvatarReachable()
and not base.localAvatar.avatarMovementEnabled):
return
if not self.isPageDown:
self.isPageUp = 0
self.isPageDown = 1
self.lerpCameraFov(70, 0.6)
self.setCameraPositionByIndex(self.cameraIndex)
else:
self.clearPageUpDown()
def clearPageUpDown(self):
if self.isPageDown or self.isPageUp:
self.lerpCameraFov(self.fov, 0.6)
self.isPageDown = 0
self.isPageUp = 0
self.setCameraPositionByIndex(self.cameraIndex)
def nextCameraPos(self, forward):
if not base.localAvatarReachable() or (
base.localAvatarReachable()
and not base.localAvatar.avatarMovementEnabled):
return
self.__cameraHasBeenMoved = 1
if forward:
self.cameraIndex += 1
if self.cameraIndex > len(self.cameraPositions) - 1:
self.cameraIndex = 0
else:
self.cameraIndex -= 1
if self.cameraIndex < 0:
self.cameraIndex = len(self.cameraPositions) - 1
self.setCameraPositionByIndex(self.cameraIndex)
def setCameraPositionByIndex(self, index):
self.notify.debug('switching to camera position %s' % index)
self.cameraIndex = index
self.setCameraSettings(self.cameraPositions[index])
def isOverTheShoulder(self):
return self.cameraIndex == self.OTSIndex
def setCameraSettings(self, camSettings):
base.localAvatar.hideCrosshair()
#if self.isOverTheShoulder() and base.localAvatar.avatarMovementEnabled:
# base.localAvatar.showCrosshair()
# spine = base.localAvatar.find("**/def_cageA")
# if spine.isEmpty():
# base.localAvatar.controlJoint(None, "torso", "def_cageA")
#else:
# base.localAvatar.hideCrosshair()
# spine = base.localAvatar.find("**/def_spineA")
# if not spine.isEmpty():
# spine.detachNode()
# base.localAvatar.releaseJoint("torso", "def_cageA")
self.setIdealCameraPos(camSettings[0])
if self.isPageUp and self.isPageDown or not self.isPageUp and not self.isPageDown:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[1])
elif self.isPageUp:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[2])
elif self.isPageDown:
self.__cameraHasBeenMoved = 1
self.setLookAtPoint(camSettings[3])
else:
self.notify.error('This case should be impossible.')
self.__disableSmartCam = camSettings[4]
if self.__disableSmartCam:
self.putCameraFloorRayOnAvatar()
self.cameraZOffset = 0.0
def set_default_pos(self, pos):
self.default_pos = pos
#self.notify.debug("default camera position set as (%s, %s, %s)" % (x, y, z))
def get_default_pos(self):
return self.default_pos
def set_parent(self, parent):
self.parent = parent
def get_parent(self):
return self.parent
def getVisibilityPoint(self):
return Point3(0.0, 0.0, self.getIdealCameraPos()[2])
def setLookAtPoint(self, la):
self.__curLookAt = Point3(la)
def getLookAtPoint(self):
return Point3(self.__curLookAt)
def setIdealCameraPos(self, pos):
self.__idealCameraPos = Point3(pos)
self.updateSmartCameraCollisionLineSegment()
def getIdealCameraPos(self):
return Point3(self.__idealCameraPos)
def getPushedCameraPos(self):
ideal = self.getIdealCameraPos()
return ideal + (ideal.normalized() * 0.25)
def getCompromiseCameraPos(self):
if self.__idealCameraObstructed == 0:
compromisePos = self.getIdealCameraPos()
else:
visPnt = self.getVisibilityPoint()
idealPos = self.getIdealCameraPos()
distance = Vec3(idealPos - visPnt).length()
ratio = self.closestObstructionDistance / distance
compromisePos = idealPos * ratio + visPnt * (1 - ratio)
if not base.localAvatar.battleControls:
# Lift the camera up in classic controls.
# In third person battle controls, we want to just move the camera closer to the player.
liftMult = max(0.0, 1.0 - ratio * ratio)
compromisePos = Point3(
compromisePos[0], compromisePos[1], compromisePos[2] +
base.localAvatar.getHeight() * 0.4 * liftMult)
if base.localAvatarReachable() and not base.localAvatar.battleControls:
compromisePos.setZ(compromisePos[2] + self.cameraZOffset)
return compromisePos
def updateSmartCameraCollisionLineSegment(self):
pointB = self.getPushedCameraPos()
pointA = self.getVisibilityPoint()
vectorAB = Vec3(pointB - pointA)
lengthAB = vectorAB.length()
if lengthAB > 0.001:
self.pointA = pointA
self.pointB = pointB
def initializeSmartCamera(self):
self.__idealCameraObstructed = 0
self.closestObstructionDistance = 0.0
self.cameraIndex = 0
self.cameraPositions = []
self.auxCameraPositions = []
self.cameraZOffset = 0.0
self.setGeom(render)
self.__onLevelGround = 0
self.__camCollCanMove = 0
self.__disableSmartCam = 0
self.initializeSmartCameraCollisions()
self._smartCamEnabled = False
self.isPageUp = 0
self.isPageDown = 0
self.fov = CIGlobals.DefaultCameraFov
def enterFirstPerson(self):
self.stop_smartcamera()
if hasattr(self.get_parent(), 'toon_head'):
head = self.get_parent().toon_head
camera.reparentTo(head)
camera.setPos(0, -0.35, 0)
camera.setHpr(0, 0, 0)
def exitFirstPerson(self):
self.initialize_smartcamera()
self.initialize_smartcamera_collisions()
self.start_smartcamera()
def putCameraFloorRayOnAvatar(self):
self.floorLineStart = Point3(0, 0, 5)
def putCameraFloorRayOnCamera(self):
self.floorLineStart = self.getIdealCameraPos() + (0, 0, 10)
def recalcCameraSphere(self):
nearPlaneDist = base.camLens.getNear()
hFov = base.camLens.getHfov()
vFov = base.camLens.getVfov()
hOff = nearPlaneDist * math.tan(deg2Rad(hFov / 2.0))
vOff = nearPlaneDist * math.tan(deg2Rad(vFov / 2.0))
camPnts = [
Point3(hOff, nearPlaneDist, vOff),
Point3(-hOff, nearPlaneDist, vOff),
Point3(hOff, nearPlaneDist, -vOff),
Point3(-hOff, nearPlaneDist, -vOff),
Point3(0.0, 0.0, 0.0)
]
avgPnt = Point3(0.0, 0.0, 0.0)
for camPnt in camPnts:
avgPnt = avgPnt + camPnt
avgPnt = avgPnt / len(camPnts)
sphereRadius = 0.0
for camPnt in camPnts:
dist = Vec3(camPnt - avgPnt).length()
if dist > sphereRadius:
sphereRadius = dist
avgPnt = Point3(avgPnt)
self.camRadiusPoint = avgPnt
def setGeom(self, geom):
self.__geom = geom
def initializeSmartCameraCollisions(self):
if self.initialized:
return
self.initialized = True
def deleteSmartCameraCollisions(self):
self.initialized = False
return
def startUpdateSmartCamera(self):
if self.started:
return
self.__floorDetected = 0
self.__cameraHasBeenMoved = 1
self.recalcCameraSphere()
self.__instantaneousCamPos = camera.getPos()
self.__disableSmartCam = 0
self.__lastPosWrtRender = camera.getPos(render) + 1
self.__lastHprWrtRender = camera.getHpr(render) + 1
self.updateSmartCameraCollisionLineSegment()
taskName = base.localAvatar.taskName('updateSmartCamera')
taskMgr.remove(taskName)
taskMgr.add(self.updateSmartCamera, taskName, priority=47)
self.started = True
def stopUpdateSmartCamera(self):
taskName = base.localAvatar.taskName('updateSmartCamera')
taskMgr.remove(taskName)
camera.setPos(self.getIdealCameraPos())
self.started = False
def updateSmartCamera(self, task):
if base.localAvatarReachable(
) and base.localAvatar.battleControls and base.localAvatar.isFirstPerson(
):
return Task.cont
if not self.__camCollCanMove and not self.__cameraHasBeenMoved:
if self.__lastPosWrtRender == camera.getPos(render):
if self.__lastHprWrtRender == camera.getHpr(render):
return Task.cont
self.__cameraHasBeenMoved = 0
self.__lastPosWrtRender = camera.getPos(render)
self.__lastHprWrtRender = camera.getHpr(render)
self.__idealCameraObstructed = 0
self.updateSmartCameraCollisionLineSegment()
if not self.__disableSmartCam:
pointA = render.getRelativePoint(camera.getParent(), self.pointA)
pointB = render.getRelativePoint(camera.getParent(), self.pointB)
mask = CIGlobals.WallGroup | CIGlobals.CameraGroup
if base.localAvatarReachable():
if base.localAvatar.battleControls:
mask |= (CIGlobals.FloorGroup | CIGlobals.StreetVisGroup)
result = PhysicsUtils.rayTestClosestNotMe(
base.localAvatar, pointA, pointB, mask)
if result:
self.handleCameraObstruction(result)
if not self.__onLevelGround:
self.handleCameraFloorInteraction()
if not self.__idealCameraObstructed:
self.nudgeCamera()
return Task.cont
def positionCameraWithPusher(self, pos, lookAt):
camera.setPos(pos)
#self.ccPusherTrav.traverse(self.__geom)
camera.lookAt(lookAt)
def nudgeCamera(self):
CLOSE_ENOUGH = 0.1
curCamPos = self.__instantaneousCamPos
curCamHpr = camera.getHpr()
targetCamPos = self.getCompromiseCameraPos()
targetCamLookAt = self.getLookAtPoint()
posDone = 0
if Vec3(curCamPos - targetCamPos).length() <= CLOSE_ENOUGH:
camera.setPos(targetCamPos)
posDone = 1
camera.setPos(targetCamPos)
camera.lookAt(targetCamLookAt)
targetCamHpr = camera.getHpr()
hprDone = 0
if Vec3(curCamHpr - targetCamHpr).length() <= CLOSE_ENOUGH:
hprDone = 1
if posDone and hprDone:
return
lerpRatio = 0.15
lerpRatio = 1 - pow(1 - lerpRatio, globalClock.getDt() * 30.0)
self.__instantaneousCamPos = targetCamPos * lerpRatio + curCamPos * (
1 - lerpRatio)
if self.__disableSmartCam or not self.__idealCameraObstructed:
newHpr = targetCamHpr * lerpRatio + curCamHpr * (1 - lerpRatio)
else:
newHpr = targetCamHpr
camera.setPos(self.__instantaneousCamPos)
camera.setHpr(newHpr)
def popCameraToDest(self):
newCamPos = self.getCompromiseCameraPos()
newCamLookAt = self.getLookAtPoint()
self.positionCameraWithPusher(newCamPos, newCamLookAt)
self.__instantaneousCamPos = camera.getPos()
def handleCameraObstruction(self, camObstrCollisionEntry):
# Convert world space hit position to avatar space.
collisionPoint = camera.getParent().getRelativePoint(
render, camObstrCollisionEntry.getHitPos())
collisionVec = Vec3(collisionPoint - self.pointA)
pushVec = Vec3(self.getIdealCameraPos() - self.getPushedCameraPos())
distance = collisionVec.length() - pushVec.length()
self.__idealCameraObstructed = 1
self.closestObstructionDistance = distance
self.popCameraToDest()
def handleCameraFloorInteraction(self):
if self.__onLevelGround or not base.localAvatarReachable() or (
base.localAvatarReachable()
and base.localAvatar.battleControls):
return
self.putCameraFloorRayOnCamera()
pointA = render.getRelativePoint(camera.getParent(),
self.floorLineStart)
pointB = pointA + (Vec3.down() * 1000)
result = PhysicsUtils.rayTestClosestNotMe(base.localAvatar, pointA,
pointB, CIGlobals.FloorGroup)
if not result:
return
camObstrCollisionEntry = result
camHeightFromFloor = (camera.getRelativePoint(
render, camObstrCollisionEntry.getHitPos())).getZ()
heightOfFloorUnderCamera = (camera.getPos()[2] -
CIGlobals.FloorOffset) + camHeightFromFloor
self.cameraZOffset = camera.getPos()[2] + camHeightFromFloor
if self.cameraZOffset < 0:
self.cameraZOffset = self.cameraZOffset * 0.33333333329999998
camHeight = max(base.localAvatar.getHeight(), 3.0)
if self.cameraZOffset < -(camHeight * 0.5):
if self.cameraZOffset < -camHeight:
self.cameraZOffset = 0.0
else:
self.cameraZOffset = -(camHeight * 0.5)
if self.__floorDetected == 0:
self.__floorDetected = 1
self.popCameraToDest()
def __showToonHitBySuit(self, avId, timestamp):
toon = self.getAvatar(avId)
if toon == None:
return
rng = self.toonRNGs[self.avIdList.index(avId)]
curPos = toon.getPos(render)
oldTrack = self.toonHitTracks[avId]
if oldTrack.isPlaying():
oldTrack.finish()
toon.setPos(curPos)
toon.setZ(self.TOON_Z)
parentNode = render.attachNewNode('mazeFlyToonParent-' + repr(avId))
parentNode.setPos(toon.getPos())
toon.reparentTo(parentNode)
toon.setPos(0, 0, 0)
startPos = parentNode.getPos()
dropShadow = toon.dropShadow.copyTo(parentNode)
dropShadow.setScale(toon.dropShadow.getScale(render))
trajectory = Trajectory.Trajectory(0,
Point3(0, 0, 0),
Point3(0, 0, 50),
gravMult=1.0)
flyDur = trajectory.calcTimeOfImpactOnPlane(0.0)
while 1:
endTile = [
rng.randint(2, self.maze.width - 1),
rng.randint(2, self.maze.height - 1)
]
if self.maze.isWalkable(endTile[0], endTile[1]):
break
endWorldCoords = self.maze.tile2world(endTile[0], endTile[1])
endPos = Point3(endWorldCoords[0], endWorldCoords[1], startPos[2])
def flyFunc(t,
trajectory,
startPos=startPos,
endPos=endPos,
dur=flyDur,
moveNode=parentNode,
flyNode=toon):
u = t / dur
moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0]))
moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1]))
flyNode.setPos(trajectory.getPos(t))
flyTrack = Sequence(LerpFunctionInterval(flyFunc,
fromData=0.0,
toData=flyDur,
duration=flyDur,
extraArgs=[trajectory]),
name=toon.uniqueName('hitBySuit-fly'))
if avId != self.localAvId:
cameraTrack = Sequence()
else:
self.camParent.reparentTo(parentNode)
startCamPos = camera.getPos()
destCamPos = camera.getPos()
zenith = trajectory.getPos(flyDur / 2.0)[2]
destCamPos.setZ(zenith * 1.3)
destCamPos.setY(destCamPos[1] * 0.3)
def camTask(task,
zenith=zenith,
flyNode=toon,
startCamPos=startCamPos,
camOffset=destCamPos - startCamPos):
u = flyNode.getZ() / zenith
camera.setPos(startCamPos + camOffset * u)
camera.lookAt(toon)
return Task.cont
camTaskName = 'mazeToonFlyCam-' + repr(avId)
taskMgr.add(camTask, camTaskName, priority=20)
def cleanupCamTask(self=self,
toon=toon,
camTaskName=camTaskName,
startCamPos=startCamPos):
taskMgr.remove(camTaskName)
self.camParent.reparentTo(toon)
camera.setPos(startCamPos)
camera.lookAt(toon)
cameraTrack = Sequence(Wait(flyDur),
Func(cleanupCamTask),
name='hitBySuit-cameraLerp')
geomNode = toon.getGeomNode()
startHpr = geomNode.getHpr()
destHpr = Point3(startHpr)
hRot = rng.randrange(1, 8)
if rng.choice([0, 1]):
hRot = -hRot
destHpr.setX(destHpr[0] + hRot * 360)
spinHTrack = Sequence(LerpHprInterval(geomNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(geomNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinH'))
parent = geomNode.getParent()
rotNode = parent.attachNewNode('rotNode')
geomNode.reparentTo(rotNode)
rotNode.setZ(toon.getHeight() / 2.0)
oldGeomNodeZ = geomNode.getZ()
geomNode.setZ(-toon.getHeight() / 2.0)
startHpr = rotNode.getHpr()
destHpr = Point3(startHpr)
pRot = rng.randrange(1, 3)
if rng.choice([0, 1]):
pRot = -pRot
destHpr.setY(destHpr[1] + pRot * 360)
spinPTrack = Sequence(LerpHprInterval(rotNode,
flyDur,
destHpr,
startHpr=startHpr),
Func(rotNode.setHpr, startHpr),
name=toon.uniqueName('hitBySuit-spinP'))
i = self.avIdList.index(avId)
soundTrack = Sequence(Func(base.playSfx,
self.sndTable['hitBySuit'][i]),
Wait(flyDur * (2.0 / 3.0)),
SoundInterval(self.sndTable['falling'][i],
duration=flyDur * (1.0 / 3.0)),
name=toon.uniqueName('hitBySuit-soundTrack'))
def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow):
forwardSpeed = toon.forwardSpeed
rotateSpeed = toon.rotateSpeed
if avId == self.localAvId:
self.orthoWalk.stop()
else:
toon.stopSmooth()
if forwardSpeed or rotateSpeed:
toon.setSpeed(forwardSpeed, rotateSpeed)
toon.dropShadow.hide()
def postFunc(self=self,
avId=avId,
oldGeomNodeZ=oldGeomNodeZ,
dropShadow=dropShadow,
parentNode=parentNode):
if avId == self.localAvId:
base.localAvatar.setPos(endPos)
if hasattr(self, 'orthoWalk'):
if self.gameFSM.getCurrentState().getName() == 'play':
self.orthoWalk.start()
dropShadow.removeNode()
del dropShadow
toon.dropShadow.show()
geomNode = toon.getGeomNode()
rotNode = geomNode.getParent()
baseNode = rotNode.getParent()
geomNode.reparentTo(baseNode)
rotNode.removeNode()
del rotNode
geomNode.setZ(oldGeomNodeZ)
toon.reparentTo(render)
toon.setPos(endPos)
parentNode.removeNode()
del parentNode
if avId != self.localAvId:
toon.startSmooth()
preFunc()
hitTrack = Sequence(Parallel(flyTrack, cameraTrack, spinHTrack,
spinPTrack, soundTrack),
Func(postFunc),
name=toon.uniqueName('hitBySuit'))
self.toonHitTracks[avId] = hitTrack
hitTrack.start(globalClockDelta.localElapsedTime(timestamp))
def _initIntervals(self):
self._healthIval = LerpFunctionInterval(self.healthBar.setSz, fromData=0.0, toData=1.0, duration=2.0)
self.baseSpinDuration = 2.0
self._spinIval = LerpFunctionInterval(self.propellerMain.setR, fromData=0.0, toData=-360.0, duration=self.baseSpinDuration)
def showResults(self):
if not self.gameIsEnding:
self.gameIsEnding = True
for barrel in self.barrels:
barrel.wrtReparentTo(render)
for key in self.cogInfo:
thief = self.cogInfo[key]['suit']
thief.suit.setPos(100, 0, 0)
thief.suit.hide()
self.__killRewardCountdown()
self.stopGameWalk()
numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels)
resultStr = ''
if numBarrelsSaved == len(self.barrels):
resultStr = TTLocalizer.CogThiefPerfect
else:
if numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {
'num': numBarrelsSaved
}
else:
if numBarrelsSaved == 1:
resultStr = TTLocalizer.CogThiefBarrelSaved % {
'num': numBarrelsSaved
}
else:
resultStr = TTLocalizer.CogThiefNoBarrelsSaved
perfectTextSubnode = hidden.attachNewNode(
self.__genText(resultStr))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self.__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.1, 0.1, 1)
def fadeFunc(t, text=perfectText):
text.setColorScale(1, 1, 1, t)
def destroyText(text=perfectText):
text.removeNode()
def safeGameOver(self=self):
if not self.frameworkFSM.isInternalStateInFlux():
self.gameOver()
textTrack = Sequence(
Func(perfectText.reparentTo, aspect2d),
Parallel(
LerpScaleInterval(perfectText,
duration=0.5,
scale=0.3,
startScale=0.0),
LerpFunctionInterval(fadeFunc,
fromData=0.0,
toData=1.0,
duration=0.5)), Wait(2.0),
Parallel(
LerpScaleInterval(perfectText, duration=0.5, scale=1.0),
LerpFunctionInterval(fadeFunc,
fromData=1.0,
toData=0.0,
duration=0.5,
blendType='easeIn')),
Func(destroyText), WaitInterval(0.5), Func(safeGameOver))
if numBarrelsSaved == len(self.barrels):
soundTrack = SoundInterval(self.sndPerfect)
else:
soundTrack = Sequence()
self.resultIval = Parallel(textTrack, soundTrack)
self.resultIval.start()
if config.GetBool('want-blueprint4-ARG', False):
MinigameGlobals.generateDebugARGPhrase()
class CogdoFlyingFuelGui(DirectFrame):
def __init__(self, parent):
DirectFrame.__init__(self, relief=None, state=DGG.NORMAL, sortOrder=DGG.BACKGROUND_SORT_INDEX)
self.reparentTo(parent)
self.active = 0
self._initModel()
self._initIntervals()
return
def _initModel(self):
self.setPos(Globals.Gui.FuelPos2D[0], 0.0, Globals.Gui.FuelPos2D[1])
self.gui = CogdoUtil.loadFlyingModel('propellerMeter', group='gui')
self.gui.reparentTo(self)
self.gui.setBin('fixed', 0)
self.healthBar = self.gui.find('**/healthBar')
self.healthBar.setBin('fixed', 1)
self.healthBar.setColor(*Globals.Gui.FuelNormalColor)
bottomBarLocator = self.gui.find('**/bottomOfBar_loc')
bottomBarPos = bottomBarLocator.getPos(render)
topBarLocator = self.gui.find('**/topOfBar_loc')
topBarPos = topBarLocator.getPos(render)
zDist = topBarPos.getZ() - bottomBarPos.getZ()
self.fuelLowIndicator = self.gui.find('**/fuelLowIndicator')
self.fuelLowIndicator.setBin('fixed', 2)
pos = self.fuelLowIndicator.getPos(render)
newPos = pos
newPos.setZ(bottomBarPos.getZ() + zDist * Globals.Gameplay.FuelLowAmt)
self.fuelLowIndicator.setPos(render, newPos)
self.fuelVeryLowIndicator = self.gui.find('**/fuelVeryLowIndicator')
self.fuelVeryLowIndicator.setBin('fixed', 2)
pos = self.fuelVeryLowIndicator.getPos(render)
newPos = pos
newPos.setZ(bottomBarPos.getZ() + zDist * Globals.Gameplay.FuelVeryLowAmt)
self.fuelVeryLowIndicator.setPos(render, newPos)
self.propellerMain = self.gui.find('**/propellers')
self.propellerMain.setBin('fixed', 3)
self.propellerHead = self.gui.find('**/propellerHead')
self.propellerHead.setBin('fixed', 4)
self.blades = []
self.activeBlades = []
index = 1
blade = self.propellerMain.find('**/propeller%d' % index)
while not blade.isEmpty():
self.blades.append(blade)
index += 1
blade = self.propellerMain.find('**/propeller%d' % index)
for blade in self.blades:
self.activeBlades.append(blade)
self.bladeNumberLabel = DirectLabel(parent=self.propellerHead, relief=None, pos=(Globals.Gui.FuelNumBladesPos2D[0], 0, Globals.Gui.FuelNumBladesPos2D[1]), scale=Globals.Gui.FuelNumBladesScale, text=str(len(self.activeBlades)), text_align=TextNode.ACenter, text_fg=(0.0,
0.0,
-0.002,
1), text_shadow=(0.75, 0.75, 0.75, 1), text_font=ToontownGlobals.getInterfaceFont())
self.bladeNumberLabel.setBin('fixed', 5)
return
def _initIntervals(self):
self._healthIval = LerpFunctionInterval(self.healthBar.setSz, fromData=0.0, toData=1.0, duration=2.0)
self.baseSpinDuration = 2.0
self._spinIval = LerpFunctionInterval(self.propellerMain.setR, fromData=0.0, toData=-360.0, duration=self.baseSpinDuration)
def show(self):
DirectFrame.show(self)
self._spinIval.loop()
def hide(self):
DirectFrame.hide(self)
self._spinIval.pause()
def resetBlades(self):
self.setBlades(len(self.blades))
def setBlades(self, fuelState):
if fuelState not in Globals.Gameplay.FuelStates:
return
numBlades = fuelState - 1
if len(self.activeBlades) != numBlades:
for i in range(len(self.activeBlades)):
blade = self.activeBlades.pop()
blade.stash()
if numBlades > len(self.blades):
numBlades = len(self.blades)
for i in range(numBlades):
blade = self.blades[i]
self.activeBlades.append(blade)
blade.unstash()
self.bladeNumberLabel['text'] = str(len(self.activeBlades))
self.bladeNumberLabel.setText()
self.updateHealthBarColor()
def bladeLost(self):
if len(self.activeBlades) > 0:
blade = self.activeBlades.pop()
blade.stash()
self.bladeNumberLabel['text'] = str(len(self.activeBlades))
self.bladeNumberLabel.setText()
self.updateHealthBarColor()
def updateHealthBarColor(self):
color = Globals.Gui.NumBlades2FuelColor[len(self.activeBlades)]
self.healthBar.setColor(*color)
def setPropellerSpinRate(self, newRate):
self._spinIval.setPlayRate(newRate)
def setRefuelLerpFromData(self):
startScale = self.healthBar.getSz()
self._healthIval.fromData = startScale
def setFuel(self, fuel):
self.fuel = fuel
def update(self):
self.healthBar.setSz(self.fuel)
def destroy(self):
self.bladeNumberLabel.removeNode()
self.bladeNumberLabel = None
self._healthIval.clearToInitial()
del self._healthIval
self.healthBar = None
self.fuelLowIndicator = None
self.fuelVeryLowIndicator = None
self.propellerMain = None
self.propellerHead = None
del self.blades[:]
del self.activeBlades[:]
self.gui.detachNode()
self.gui = None
DirectFrame.destroy(self)
return
def start_move(self, dir):
die = self.world.component_for_entity(self.player, components.Die)
spatial = self.world.component_for_entity(self.player,
components.Spatial)
orig_pos = spatial.path.get_pos()
orig_quat = spatial.path.get_quat()
target_pos = spatial.path.get_pos()
target_quat = spatial.path.get_quat()
next_number = None
vector = core.Vec2(0, 0)
if dir == 'N':
vector.y += 1
target_quat *= core.LRotation((1, 0, 0), -90)
next_number = die.die.north_number
elif dir == 'E':
vector.x += 1
target_quat *= core.LRotation((0, 1, 0), 90)
next_number = die.die.east_number
elif dir == 'S':
vector.y -= 1
target_quat *= core.LRotation((1, 0, 0), 90)
next_number = die.die.south_number
elif dir == 'W':
vector.x -= 1
target_quat *= core.LRotation((0, 1, 0), -90)
next_number = die.die.west_number
z_scale = math.sqrt(0.5) - 0.5
target_pos.xy += vector
x, y = int(target_pos[0]), int(target_pos[1])
type = self.world.level.get_tile(x, y)
if not type.is_passable(
next_number, self.world.toggle_state
) and not base.mouseWatcherNode.is_button_down('pause'):
self.moving = True
Sequence(
Parallel(
spatial.path.posInterval(0.05,
orig_pos * 0.9 + target_pos * 0.1,
blendType='easeInOut'),
LerpFunctionInterval(
lambda x: spatial.path.set_z(math.sin(x) * z_scale),
0.05,
toData=math.pi * 0.1,
blendType='easeInOut'),
spatial.path.quatInterval(0.05,
orig_quat * 0.9 +
target_quat * 0.1,
blendType='easeInOut'),
),
Parallel(
spatial.path.posInterval(0.05,
orig_pos,
blendType='easeIn'),
LerpFunctionInterval(
lambda x: spatial.path.set_z(math.sin(x) * z_scale),
0.05,
fromData=math.pi * 0.1,
toData=0,
blendType='easeIn'),
spatial.path.quatInterval(0.05,
orig_quat,
blendType='easeIn'),
), Func(self.stop_move)).start()
if type.value and type.value in '123456':
self.world.die_icon.flash((1, 0, 0, 1))
if base.impassable_sound:
base.impassable_sound.play()
return False
# Build up the animation; the parallel gets prepended to the sequence
parallel = [
spatial.path.posInterval(0.25, target_pos),
LerpFunctionInterval(
lambda x: spatial.path.set_z(math.sin(x) * z_scale),
0.25,
toData=math.pi),
spatial.path.quatInterval(0.25, target_quat),
]
sequence = []
if type == TileType.ice:
if base.slide_sound:
sequence.append(Func(base.slide_sound.play))
else:
if base.move_sound:
sequence.append(Func(base.move_sound.play))
while type == TileType.ice:
target_pos.xy += vector
x, y = int(target_pos[0]), int(target_pos[1])
type = self.world.level.get_tile(x, y)
if type == TileType.ice:
sequence.append(spatial.path.posInterval(0.25, target_pos))
else:
sequence.append(
spatial.path.posInterval(0.5,
target_pos,
blendType='easeOut'))
if type == TileType.teleporter:
# Find other teleporter.
x, y = int(target_pos[0]), int(target_pos[1])
others = set(self.world.teleporters)
others.discard((x, y))
if others:
new_xy = others.pop()
new_target_pos = core.Point3(target_pos)
new_target_pos.xy = new_xy
tile1 = self.world.tiles[(x, y)]
tile2 = self.world.tiles[new_xy]
tile1_path = self.world.component_for_entity(
tile1, components.Spatial).path
tile2_path = self.world.component_for_entity(
tile2, components.Spatial).path
tile1_path.set_pos(new_target_pos)
tile2_path.set_pos(target_pos)
elevation = (0, 0, 0.65)
time = max((target_pos.xy - new_target_pos.xy).length() * 0.15,
0.35)
if base.transport_sound:
sequence.append(Func(base.transport_sound.play))
sequence.append(
Parallel(
Sequence(
spatial.path.posInterval(0.25,
target_pos + elevation,
blendType='easeInOut'),
spatial.path.posInterval(time,
new_target_pos +
elevation,
blendType='easeInOut'),
spatial.path.posInterval(0.25,
new_target_pos,
blendType='easeInOut'),
),
Sequence(
tile2_path.posInterval(0.25,
target_pos + elevation,
blendType='easeInOut'),
tile2_path.posInterval(time,
new_target_pos + elevation,
blendType='easeInOut'),
tile2_path.posInterval(0.25,
new_target_pos,
blendType='easeInOut'),
),
Sequence(
tile1_path.posInterval(0.25,
new_target_pos - elevation,
blendType='easeInOut'),
tile1_path.posInterval(time,
target_pos - elevation,
blendType='easeInOut'),
tile1_path.posInterval(0.25,
target_pos,
blendType='easeInOut'),
),
))
if self.button_tile:
# Make the button raised again
button_path = self.world.component_for_entity(
self.button_tile, components.Spatial).path
button_pos = core.LPoint3(button_path.get_pos())
button_pos.z = 0.07
parallel.append(button_path.posInterval(0.25, button_pos))
if self.cracked_tile:
# Break away the cracked tile
if base.collapse_sound:
base.collapse_sound.play()
self.world.add_component(self.cracked_tile,
components.Falling(drag=5.0))
self.cracked_tile = None
if type == TileType.exit:
self.winning_move = True
self.lock()
if type == TileType.cracked:
self.cracked_tile = self.world.tiles[(x, y)]
self.world.level.remove_tile(x, y)
del self.world.tiles[(x, y)]
sequence.append(Func(base.crack_sound.play))
if type == TileType.button:
button_tile = self.world.tiles[(x, y)]
button_path = self.world.component_for_entity(
button_tile, components.Spatial).path
button_pos = core.LPoint3(button_path.get_pos())
button_pos.z = 0.0
parallel.append(button_path.posInterval(0.25, button_pos))
parallel.append(Sequence(Wait(0.1),
Func(self.world.toggle_button)))
if base.button_sound:
parallel.append(Func(base.button_sound.play))
self.button_tile = button_tile
if dir == 'N':
die.die.rotate_north()
elif dir == 'E':
die.die.rotate_east()
elif dir == 'S':
die.die.rotate_south()
elif dir == 'W':
die.die.rotate_west()
self.moving = True
sequence.insert(0, Parallel(*parallel))
sequence.append(Func(self.stop_move))
Sequence(*sequence).start()
self.world.on_player_move()
return True
def generate(self):
DistributedObject.announceGenerate(self)
self.trolleyStation = self.cr.playGame.hood.loader.geom.find('**/prop_trolley_station_DNARoot')
self.trolleyCar = self.trolleyStation.find('**/trolley_car')
self.trolleyKey = self.trolleyStation.find('**/key')
exitFog = Fog('TrolleyExitFog')
exitFog.setColor(0.0, 0.0, 0.0)
exitFog.setLinearOnsetPoint(30.0, 14.0, 0.0)
exitFog.setLinearOpaquePoint(37.0, 14.0, 0.0)
exitFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyExitFog = self.trolleyStation.attachNewNode(exitFog)
self.trolleyExitFogNode = exitFog
enterFog = Fog('TrolleyEnterFog')
enterFog.setColor(0.0, 0.0, 0.0)
enterFog.setLinearOnsetPoint(0.0, 14.0, 0.0)
enterFog.setLinearOpaquePoint(-7.0, 14.0, 0.0)
enterFog.setLinearFallback(70.0, 999.0, 1000.0)
self.trolleyEnterFog = self.trolleyStation.attachNewNode(enterFog)
self.trolleyEnterFogNode = enterFog
self.trolleyCar.setFogOff()
tn = TextNode('trolleycountdowntext')
tn.setFont(CIGlobals.getMickeyFont())
tn.setTextColor(1, 0, 0, 1)
tn.setAlign(TextNode.ACenter)
self.keys = self.trolleyCar.findAllMatches('**/key')
self.numKeys = self.keys.getNumPaths()
self.keyInit = []
self.keyRef = []
for i in range(self.numKeys):
key = self.keys[i]
key.setTwoSided(1)
ref = self.trolleyCar.attachNewNode('key' + `i` + 'ref')
ref.iPosHpr(key)
self.keyRef.append(ref)
self.keyInit.append(key.getTransform())
self.frontWheels = self.trolleyCar.findAllMatches('**/front_wheels')
self.numFrontWheels = self.frontWheels.getNumPaths()
self.frontWheelInit = []
self.frontWheelRef = []
for i in range(self.numFrontWheels):
wheel = self.frontWheels[i]
ref = self.trolleyCar.attachNewNode('frontWheel' + `i` + 'ref')
ref.iPosHpr(wheel)
self.frontWheelRef.append(ref)
self.frontWheelInit.append(wheel.getTransform())
self.backWheels = self.trolleyCar.findAllMatches('**/back_wheels')
self.numBackWheels = self.backWheels.getNumPaths()
self.backWheelInit = []
self.backWheelRef = []
for i in range(self.numBackWheels):
wheel = self.backWheels[i]
ref = self.trolleyCar.attachNewNode('backWheel' + `i` + 'ref')
ref.iPosHpr(wheel)
self.backWheelRef.append(ref)
self.backWheelInit.append(wheel.getTransform())
trolleyAnimationReset = Func(self.resetAnimation)
trolleyEnterStartPos = Point3(-20, 14, -1)
trolleyEnterEndPos = Point3(15, 14, -1)
trolleyEnterPos = Sequence(name='TrolleyEnterPos')
trolleyEnterPos.append(Func(self.trolleyCar.setFog, self.trolleyEnterFogNode))
trolleyEnterPos.append(self.trolleyCar.posInterval(TROLLEY_ENTER_TIME, trolleyEnterEndPos, startPos=trolleyEnterStartPos, blendType='easeOut'))
trolleyEnterPos.append(Func(self.trolleyCar.setFogOff))
trolleyEnterTrack = Sequence(trolleyAnimationReset, trolleyEnterPos, name='trolleyEnter')
keyAngle = round(TROLLEY_ENTER_TIME) * 360
dist = Vec3(trolleyEnterEndPos - trolleyEnterStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyEnterAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_ENTER_TIME, blendType='easeOut', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
trolleyEnterSoundTrack = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
self.trolleyEnterTrack = Parallel(trolleyEnterTrack, trolleyEnterAnimateInterval, trolleyEnterSoundTrack)
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitPos = Sequence(name='TrolleyExitPos')
trolleyExitPos.append(Func(self.trolleyCar.setFog, self.trolleyExitFogNode))
trolleyExitPos.append(self.trolleyCar.posInterval(TROLLEY_EXIT_TIME, trolleyExitEndPos, startPos=trolleyExitStartPos, blendType='easeIn'))
trolleyExitPos.append(Func(self.trolleyCar.setFogOff))
trolleyExitStartPos = Point3(15, 14, -1)
trolleyExitEndPos = Point3(50, 14, -1)
trolleyExitBellInterval = SoundInterval(self.trolleyBellSfx, node=self.trolleyCar)
trolleyExitAwayInterval = SoundInterval(self.trolleyAwaySfx, node=self.trolleyCar)
keyAngle = round(TROLLEY_EXIT_TIME) * 360
dist = Vec3(trolleyExitEndPos - trolleyExitStartPos).length()
wheelAngle = dist / (2.0 * math.pi * 0.95) * 360
trolleyExitAnimateInterval = LerpFunctionInterval(self.animateTrolley, duration=TROLLEY_EXIT_TIME, blendType='easeIn', extraArgs=[keyAngle, wheelAngle], name='TrolleyAnimate')
self.trolleyExitTrack = Parallel(trolleyExitPos, trolleyExitBellInterval, trolleyExitAwayInterval, trolleyExitAnimateInterval, name=self.uniqueName('trolleyExit'))
self.countdownText = self.trolleyStation.attachNewNode(tn)
self.countdownText.setScale(3.0)
self.countdownText.setPos(14.58, 10.77, 11.17)
self.acceptOnce('entertrolley_sphere', self.__handleTrolleyTrigger)
