def addLine(self, text, color):
# Whilst in a battle, we don't want to display update text.
if base.localAvatarReachable():
place = base.cr.playGame.getPlace()
if base.localAvatar.getBattleZone() or (
place and place.fsm.getCurrentState().getName() != 'walk'):
self.queuedLines[text] = color
return
if len(self.lines) == self.MAX_LINES:
oldestLine = self.lines[len(self.lines) - 1]
ival = self.ivalDict.get(oldestLine, None)
ival.finish()
newLine = OnscreenText(parent=self,
text=text,
fg=color,
shadow=(color[0] * self.SHADOW_MODIFIER,
color[1] * self.SHADOW_MODIFIER,
color[2] * self.SHADOW_MODIFIER, 1.0),
mayChange=1,
font=CIGlobals.getMinnieFont())
newLine.setPos(*self.LINE_MINIMUM_POS)
initScale = (1.0, 1.0, 1.0)
growScale = (1.15, 1.15, 1.15)
"""
LerpScaleInterval(newLine, 0.5,
scale = initScale,
blendType = 'easeIn',
bakeInStart = 0),
"""
lineIval = Sequence(
Func(self.alertSfx.play),
LerpScaleInterval(newLine,
0.5,
scale=initScale,
startScale=(0.01, 0.01, 0.01),
blendType='easeOut',
bakeInStart=0), Wait(0.5),
Wait(self.SHOW_DURATION),
Parallel(
LerpPosInterval(newLine,
self.FADE_DURATION,
pos=(0.0, 0.0, (self.LINE_Y_OFFSET *
(self.MAX_LINES + 1.8))),
blendType='easeIn',
bakeInStart=0,
other=self),
LerpColorScaleInterval(newLine,
self.FADE_DURATION - 0.5,
(1.0, 1.0, 1.0, 0.01),
blendType='easeIn')),
Func(self.deleteLine, newLine))
self.lines.insert(0, newLine)
self.ivalDict.update({newLine: lineIval})
for i in range(1, len(self.lines)):
line = self.lines[i]
if not line.isEmpty():
# Let's reposition this element.
line.setPos(
line.getX(),
self.LINE_MINIMUM_POS[1] + (self.LINE_Y_OFFSET * i))
lineIval.start()
def enterReward(self):
taskMgr.remove('shaderTickUpdate')
self.loseCount = 0
base.cam.reparentTo(self.gameObject.fishingSpot)
self.gameObject.tutorialManager.showTutorial(
InventoryType.FishingCaughtFish)
self.gameObject.lure.showHelpText(None)
self.gameObject.distributedFishingSpot.showTutorial = False
self.gameObject.sfx['ambience'].stop()
if self.gameObject.fishManager.activeFish.myData['size'] in [
'small', 'medium'
]:
self.animationSequence = Sequence(
Wait(0.4), Func(localAvatar.loop, 'fsh_smallSuccess'),
Wait(localAvatar.getDuration('fsh_smallSuccess')),
Func(localAvatar.loop, 'fsh_idle'), Wait(1.0))
self.animationSequence.loop()
else:
localAvatar.loop('fsh_bigSuccess')
i = random.randint(0, 2)
if self.gameObject.fishManager.activeFish.myData['size'] == 'small':
if i == 0:
self.gameObject.sfx['fishOutSmall01'].play()
elif i == 1:
self.gameObject.sfx['fishOutSmall02'].play()
else:
self.gameObject.sfx['fishOutSmall03'].play()
else:
if self.gameObject.fishManager.activeFish.myData[
'size'] == 'medium':
if i == 0:
self.gameObject.sfx['fishOutMedium01'].play()
elif i == 1:
self.gameObject.sfx['fishOutMedium02'].play()
else:
self.gameObject.sfx['fishOutMedium01'].play()
else:
if self.gameObject.fishManager.activeFish.myData[
'size'] == 'large':
if i == 0:
self.gameObject.sfx['fishOutLarge01'].play()
elif i == 1:
self.gameObject.sfx['fishOutLarge02'].play()
else:
self.gameObject.sfx['fishOutLarge03'].play()
self.gameObject.sfx['successCaught'].play()
fishId = int(self.gameObject.fishManager.activeFish.myData['id'])
self.gameObject.distributedFishingSpot.d_caughtFish(
fishId, self.gameObject.fishManager.activeFish.weight)
self.gameObject.oceanEye = False
self.gameObject.playRewardSequence()
self.gameObject.fishManager.activeFish.actor.loop('reelIdle')
self.gameObject.fishManager.activeFish.setY(0.0)
self.gameObject.fishManager.activeFish.setHpr(0.0, 0.0, 0.0)
self.gameObject.fishManager.activeFish.fishStatusIconNodePath.hide()
self.gameObject.hideFishAndBackdrop()
self.gameObject.fishManager.activeFish.show()
self.gameObject.fishManager.activeFish.actor.show()
taskMgr.remove('%s_StartFighting' %
self.gameObject.fishManager.activeFish.getName())
taskMgr.remove('%s_StopFighting' %
self.gameObject.fishManager.activeFish.getName())
taskMgr.remove('%s_GoFighting' %
self.gameObject.fishManager.activeFish.getName())
return
def start(self):
SoundGag.start(self)
INSTRUMENT_SCALE_MODIFIER = 0.5
delayTime = 2.45
delayUntilAppearSound = 1.0
tracks = Parallel()
instrMin = Vec3(0.001, 0.001, 0.001)
instrMax = Vec3(0.65, 0.65, 0.65)
instrMax *= INSTRUMENT_SCALE_MODIFIER
instrStretch = Vec3(0.6, 1.1, 0.6)
instrStretch *= INSTRUMENT_SCALE_MODIFIER
def setInstrumentStats():
self.gag.setPos(-1.1, -1.4, 0.1)
self.gag.setHpr(145, 0, 0)
self.gag.setScale(instrMin)
megaphoneShow = Sequence(
Func(self.placeProp, self.handJoint, self.megaphone),
Func(self.placeProp, self.handJoint, self.gag),
Func(setInstrumentStats))
grow = self.getScaleIntervals(self.gag,
duration=0.2,
startScale=instrMin,
endScale=instrMax)
instrumentAppear = grow
stretchInstr = self.getScaleBlendIntervals(self.gag,
duration=0.2,
startScale=instrMax,
endScale=instrStretch,
blendType='easeOut')
backInstr = self.getScaleBlendIntervals(self.gag,
duration=0.2,
startScale=instrStretch,
endScale=instrMax,
blendType='easeIn')
stretchMega = self.getScaleBlendIntervals(
self.megaphone,
duration=0.2,
startScale=self.megaphone.getScale(),
endScale=0.9,
blendType='easeOut')
backMega = self.getScaleBlendIntervals(
self.megaphone,
duration=0.2,
startScale=0.9,
endScale=self.megaphone.getScale(),
blendType='easeIn')
attackTrack = Parallel(Sequence(stretchInstr, backInstr),
Sequence(stretchMega, backMega))
megaphoneTrack = Sequence(
megaphoneShow, Wait(delayUntilAppearSound),
SoundInterval(self.appearSfx, node=self.avatar), instrumentAppear)
tracks.append(megaphoneTrack)
tracks.append(ActorInterval(self.avatar, 'sound'))
instrumentshrink = self.getScaleIntervals(self.gag,
duration=0.1,
startScale=instrMax,
endScale=instrMin)
soundTrack = Sequence(
Wait(delayTime),
Parallel(attackTrack, SoundInterval(self.soundSfx,
node=self.avatar), Wait(0.2),
instrumentshrink, Func(self.damageCogsNearby), Wait(0.4),
Func(self.finish)))
tracks.append(soundTrack)
tracks.start()
self.tracks = tracks
def initIntervals(self):
dur = Globals.LegalEagle.LiftOffTime
nestPos = self.nest.getPos(render)
airPos = nestPos + Vec3(0.0, 0.0, Globals.LegalEagle.LiftOffHeight)
self.takeOffSeq = Sequence(Parallel(
Sequence(
Wait(dur * 0.6),
LerpPosInterval(self.suit,
dur * 0.4,
startPos=nestPos,
pos=airPos,
blendType='easeInOut'))),
Wait(1.5),
Func(self.request, 'next'),
name='%s.takeOffSeq-%i' %
(self.__class__.__name__, self.index))
self.landOnNestPosLerp = LerpPosInterval(self.suit,
1.0,
startPos=airPos,
pos=nestPos,
blendType='easeInOut')
self.landingSeq = Sequence(Func(self.updateLandOnNestPosLerp),
Parallel(self.landOnNestPosLerp),
Func(self.request, 'next'),
name='%s.landingSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.ChargeUpTime
self.chargeUpPosLerp = LerpFunc(
self.moveAlongChargeUpMopathFunc,
fromData=0.0,
toData=self.chargeUpMotionPath.getMaxT(),
duration=dur,
blendType='easeInOut')
self.chargeUpAttackSeq = Sequence(
Func(self.updateChargeUpPosLerp),
self.chargeUpPosLerp,
Func(self.request, 'next'),
name='%s.chargeUpAttackSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToNestTime
self.retreatToNestPosLerp = LerpPosInterval(self.suit,
dur,
startPos=Vec3(0, 0, 0),
pos=airPos,
blendType='easeInOut')
self.retreatToNestSeq = Sequence(Func(self.updateRetreatToNestPosLerp),
self.retreatToNestPosLerp,
Func(self.request, 'next'),
name='%s.retreatToNestSeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.RetreatToSkyTime
self.retreatToSkyPosLerp = LerpFunc(
self.moveAlongRetreatMopathFunc,
fromData=0.0,
toData=self.retreatToSkyMotionPath.getMaxT(),
duration=dur,
blendType='easeOut')
self.retreatToSkySeq = Sequence(Func(self.updateRetreatToSkyPosLerp),
self.retreatToSkyPosLerp,
Func(self.request, 'next'),
name='%s.retreatToSkySeq-%i' %
(self.__class__.__name__, self.index))
dur = Globals.LegalEagle.PreAttackTime
self.preAttackLerpXY = LerpFunc(self.updateAttackXY,
fromData=0.0,
toData=1.0,
duration=dur)
self.preAttackLerpZ = LerpFunc(self.updateAttackZ,
fromData=0.0,
toData=1.0,
duration=dur,
blendType='easeOut')
dur = Globals.LegalEagle.PostAttackTime
self.postAttackPosLerp = LerpPosInterval(self.suit,
dur,
startPos=Vec3(0, 0, 0),
pos=Vec3(0, 0, 0))
self.attackSeq = Sequence(
Parallel(self.preAttackLerpXY, self.preAttackLerpZ),
Func(self.updatePostAttackPosLerp),
self.postAttackPosLerp,
Func(self.request, 'next'),
name='%s.attackSeq-%i' % (self.__class__.__name__, self.index))
dur = Globals.LegalEagle.CooldownTime
self.cooldownSeq = Sequence(Wait(dur),
Func(self.request, 'next'),
name='%s.cooldownSeq-%i' %
(self.__class__.__name__, self.index))
self.propTrack = Sequence(
ActorInterval(self.prop, 'propeller', startFrame=0, endFrame=14))
self.hoverOverNestSeq = Sequence(
ActorInterval(self.suit,
'landing',
startFrame=10,
endFrame=20,
playRate=0.5),
ActorInterval(self.suit,
'landing',
startFrame=20,
endFrame=10,
playRate=0.5))
def setup(self):
# Store current values
self.entry_background_color = VBase4(base.win.get_clear_color())
self.entry_cam_pos = VBase3(base.cam.get_pos())
self.entry_cam_hpr = VBase3(base.cam.get_hpr())
self.entry_cam_scale = VBase3(base.cam.get_scale())
self.entry_cam_fov = VBase2(base.cam.node().get_lens().get_fov())
# Set values for splash
base.win.set_clear_color((0,0,0,1))
cam_dist = 2
base.cam.set_pos(0, -2.2 * cam_dist, 0)
base.cam.set_hpr(0, 0, 0)
base.cam.set_scale(1)
base.cam.node().get_lens().set_fov(45/cam_dist)
# Set up the splash itself
self.logo_animation = Actor(asset_path / "panda3d_logo.bam")
self.logo_animation.reparent_to(render)
self.logo_animation.set_two_sided(True)
shader = Shader.load(
Shader.SL_GLSL,
vertex=asset_path / "panda3d_logo.vert",
fragment=asset_path / "panda3d_logo.frag",
)
self.logo_animation.set_shader(shader)
self.logo_animation.set_shader_input("fade", 0.0)
self.logo_animation.set_shader_input("pattern", self.pattern.value)
self.logo_animation.set_shader_input("colors", self.colors.value)
self.logo_animation.set_shader_input("pattern_freq", self.pattern_freq)
self.logo_animation.set_shader_input("cycle_freq", self.cycle_freq)
self.logo_sound = base.loader.loadSfx(asset_path / "panda3d_logo.wav")
# Build interval
def shader_time(t):
self.logo_animation.set_shader_input("time", t)
def fade_background_to_white(t):
base.win.set_clear_color((t,t,t,1))
self.logo_animation.set_shader_input("time", t/3.878)
self.logo_animation.set_shader_input("fade", t)
def fade_to_black(t):
base.win.set_clear_color((1-t,1-t,1-t,1))
#self.logo_animation.set_shader_input("time", t/3.878)
#self.logo_animation.set_shader_input("fade", t)
# Timing:
# 0.000 Start
# 3.878 Logo is assembled, fade to black-on-whitey
# 4.878 Black on white achieved
# <+1.500> Begin fade to black
# <+1.741> Black on black achieved
# 8.119 Sound ends
effects = Parallel(
self.logo_animation.actorInterval(
"splash",
loop=False,
),
SoundInterval(
self.logo_sound,
loop=False,
),
Sequence(
LerpFunc(
shader_time,
fromData=0,
toData=1,
duration=3.878,
),
LerpFunc(
fade_background_to_white,
fromData=0,
toData=1,
duration=1.0,
),
Wait(1.5),
LerpFunc(
fade_to_black,
fromData=0,
toData=1,
duration=1.741,
),
),
)
return effects
def handleShoot(self, action_list):
shoot = self.buildShoot(action_list)
s = Sequence(Func(self.beforeAnimHook), Wait(0.2), shoot, Func(self.afterAnimHook))
s.start()
def enterNeutral(self, ts=0):
self.show()
self.timestampAnimTrack = Sequence(Wait(ts), Func(self.loop, "flyNeutral"))
self.timestampAnimTrack.start()
def makeToonGrabInterval(self, toon):
toon.pose('leverNeutral', 0)
toon.update()
rightHandPos = toon.rightHand.getPos(toon)
self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0)
destZScale = rightHandPos[2] / self.handPos[2]
grabIval = Sequence(Func(toon.wrtReparentTo, self.waterPitcherNode), Func(toon.loop, 'neutral'), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), Parallel(ProjectileInterval(toon, duration=0.9, startPos=toon.getPos(self.waterPitcherNode), endPos=self.toonPitcherPosition), LerpHprInterval(toon, 0.9, Point3(0, 0, 0)), LerpScaleInterval(self.waterPitcherModel, 0.9, Point3(1, 1, destZScale))))), Func(toon.setPos, self.toonPitcherPosition), Func(toon.loop, 'leverNeutral'))
return grabIval
def makeToonReleaseInterval(self, toon):
temp1 = self.waterPitcherNode.attachNewNode('temp1')
temp1.setPos(self.toonPitcherPosition)
temp2 = self.waterPitcherNode.attachNewNode('temp2')
temp2.setPos(0, -10, -self.waterPitcherNode.getZ())
startPos = temp1.getPos(render)
endPos = temp2.getPos(render)
temp1.removeNode()
temp2.removeNode()
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -10, 0))
if self.gotHitByBoss:
self.notify.debug('creating zap interval instead')
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)))
else:
grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), ProjectileInterval(toon, duration=0.9, startPos=startPos, endPos=endPos))))
return grabIval
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 enterFallBCK(self, ts=0, callback=None, extraArgs=[]):
self.playingAnim = 'fallb'
self.play("fallb")
Sequence(Wait(0.5), SoundInterval(self.fallSfx, node=self)).start()
def getRideElevatorInterval(type = ELEVATOR_NORMAL):
ival = Sequence(Wait(0.5), LerpPosInterval(camera, 0.5, Point3(0, 14, 3.8), startPos=Point3(0, 14, 4), blendType='easeOut'),
LerpPosInterval(camera, 0.5, Point3(0, 14, 4), startPos=Point3(0, 14, 3.8)),
Wait(1.0), LerpPosInterval(camera, 0.5, Point3(0, 14, 4.2), startPos=Point3(0, 14, 4), blendType='easeOut'),
LerpPosInterval(camera, 1.0, Point3(0, 14, 4), startPos=Point3(0, 14, 4.2)))
return ival
def enterScrollBy(self):
BLUE_START_POS = Point3(-20, 0, 4)
BLUE_END_POS = Point3(20, 0, 4)
BLUE_HPR = Vec3(0, 0, 0)
RED_START_POS = Point3(20, 0, 4)
RED_END_POS = Point3(-20, 0, 4)
RED_HPR = Vec3(180, 0, 0)
self.playMinigameMusic()
self.scrollBySeq = Sequence(Func(camera.setHpr, BLUE_HPR), LerpPosInterval(camera, duration=5.0, pos=BLUE_END_POS, startPos=BLUE_START_POS, blendType='easeOut'), Func(base.transitions.fadeOut, 0.4), Wait(0.5), Func(base.transitions.fadeIn, 0.4), Func(camera.setHpr, RED_HPR), LerpPosInterval(camera, duration=5.0, pos=RED_END_POS, startPos=RED_START_POS, blendType='easeOut'), name='SCROLLBYSEQ')
self.scrollBySeq.setDoneEvent(self.scrollBySeq.getName())
self.acceptOnce(self.scrollBySeq.getDoneEvent(), self.__handleScrollByDone)
self.scrollBySeq.start()
def getSprayTrack(self,
color,
origin,
target,
dScaleUp,
dHold,
dScaleDown,
horizScale=1.0,
vertScale=1.0,
parent=render):
track = Sequence()
SPRAY_LEN = 1.5
sprayProp = MovieUtil.globalPropPool.getProp('spray')
sprayScale = hidden.attachNewNode('spray-parent')
sprayRot = hidden.attachNewNode('spray-rotate')
spray = sprayRot
spray.setColor(color)
if color[3] < 1.0:
spray.setTransparency(1)
def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent):
if callable(origin):
origin = origin()
if callable(target):
target = target()
sprayRot.reparentTo(parent)
sprayRot.clearMat()
sprayScale.reparentTo(sprayRot)
sprayScale.clearMat()
sprayProp.reparentTo(sprayScale)
sprayProp.clearMat()
sprayRot.setPos(origin)
sprayRot.lookAt(Point3(target))
track.append(
Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target,
parent))
def calcTargetScale(target=target,
origin=origin,
horizScale=horizScale,
vertScale=vertScale):
if callable(target):
target = target()
if callable(origin):
origin = origin()
distance = Vec3(target - origin).length()
yScale = distance / SPRAY_LEN
targetScale = Point3(yScale * horizScale, yScale,
yScale * vertScale)
return targetScale
track.append(
LerpScaleInterval(sprayScale,
dScaleUp,
calcTargetScale,
startScale=Point3(0.01, 0.01, 0.01)))
track.append(Func(self.checkHitObject))
track.append(Wait(dHold))
def prepareToShrinkSpray(spray, sprayProp, origin, target):
if callable(target):
target = target()
if callable(origin):
origin = origin()
sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0))
spray.setPos(target)
track.append(
Func(prepareToShrinkSpray, spray, sprayProp, origin, target))
track.append(
LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01,
0.01)))
def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool):
sprayProp.detachNode()
MovieUtil.removeProp(sprayProp)
sprayRot.removeNode()
sprayScale.removeNode()
track.append(
Func(hideSpray, spray, sprayScale, sprayRot, sprayProp,
MovieUtil.globalPropPool))
return track
def buildDeleteAnim(self, unit_id):
return Sequence(Func(self.interface.clearMarker, unit_id), Func(self.sgm.hideUnit, unit_id), Func(self.deleteUnit, unit_id), Wait(0.2))
def doMolePop(self, startTime, timeToMoveUp, timeToStayUp, timeToMoveDown, moleType):
if self.hillType == MoleFieldBase.HILL_WHACKED or self.hillType == MoleFieldBase.HILL_COGWHACKED:
return
if self.popIval:
self.popIval.pause()
if self.downIval:
self.downIval.pause()
self.downIval = None
moleColor = None
self.switchUp()
self.popupNum += 1
if self.hillType == MoleFieldBase.HILL_BOMB:
self.popIval = Sequence(Func(self.setHillType, moleType), Func(self.moleColNodePath.unstash), LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)), Wait(timeToStayUp), LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)), Func(self.stashMoleCollision), Func(self.switchDown))
else:
self.popIval = Sequence(Func(self.setHillType, moleType), LerpPosInterval(self.mole, timeToMoveUp, Point3(0, 0, 0.0)), Func(self.moleColNodePath.unstash), Wait(timeToStayUp), Func(self.stashMoleCollision), LerpPosInterval(self.mole, timeToMoveDown, Point3(0, 0, -2.5)), Func(self.switchDown))
self.popIval.start()
return
def buildDetachAnim(self, unit_id):
return Sequence(Func(self.sgm.detachUnit, unit_id), Wait(0.2))
def setEveryoneDone(self):
if not self.hasLocalToon:
return None
if self.gameFSM.getCurrentState().getName() != 'play':
self.notify.warning('ignoring setEveryoneDone msg')
return None
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._DistributedPairingGame__genText(TTLocalizer.PairingGamePerfect))
perfectText = hidden.attachNewNode('perfectText')
perfectTextSubnode.reparentTo(perfectText)
frame = self._DistributedPairingGame__textGen.getCardActual()
offsetY = -abs(frame[2] + frame[3]) / 2.0
perfectTextSubnode.setPos(0, 0, offsetY)
perfectText.setColor(1, 0.10000000000000001, 0.10000000000000001, 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.29999999999999999, 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)
def createAnimSequence(self, animPhase):
result = Sequence(self.phaseIvals[animPhase], Wait(self.phaseInfo[self.curPhase][1]), Func(self.startNextAnim))
return result
def loadNewBoard(self):
self.progressLabel.stash()
self.progressDescriptionLabel.stash()
if self.totalScore >= self.config.totalPoints:
if self.onDeckBoard:
self.onDeckBoard.stash()
self.progressDescriptionLabel.stash()
taskMgr.remove('SawingGame.updateSawTask')
self.request('Outro')
return
self.currentBoard = self.onDeckBoard
self.currentBoardIndex = self.onDeckBoardIndex
self.piece1 = self.currentBoard.find('**/piece_1')
self.piece1.setTransparency(1)
self.piece2 = self.currentBoard.find('**/piece_2')
self.piece2.setTransparency(1)
self.cut = self.currentBoard.find('**/piece_cut')
self.cut.setColor(self.config.cutColor)
self.cut.setTransparency(1)
self.board_left = self.piece1.find('**/board')
self.board_left.setTransparency(1)
self.zone1_left = self.piece1.find('**/zone_1')
self.zone1_left.setTransparency(1)
self.zone2_left = self.piece1.find('**/zone_2')
self.zone2_left.setTransparency(1)
self.board_right = self.piece2.find('**/board')
self.board_right.setTransparency(1)
self.zone1_right = self.piece2.find('**/zone_1')
self.zone1_right.setTransparency(1)
self.zone2_right = self.piece2.find('**/zone_2')
self.zone2_right.setTransparency(1)
self.board_left.setCollideMask(SAW_COLLIDE_MASK)
self.board_right.setCollideMask(SAW_COLLIDE_MASK)
self.cut.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
self.startPositions = (
self.currentBoard.find('**/locator_start_0').getPos() +
Point3(*self.config.activeBoardPosition),
self.currentBoard.find('**/locator_start_1').getPos() +
Point3(*self.config.activeBoardPosition))
self.currentStartIndex = 0
for waypoint in self.sawWaypoints:
waypoint.removeNode()
self.sawWaypoints = []
locator = self.currentBoard.find('**/locator_0')
index = 0
while not locator.isEmpty():
self.sawWaypoints.append(
SawWaypoint(index, self.currentBoard, locator.getPos()))
locator = self.currentBoard.find('**/locator_%i' % (index + 1))
index += 1
self.sawButton.deactivate()
self.sawButton.setPos(self.startPositions[self.currentStartIndex])
self.hitBoardPenalty = False
self.hitZone1Penalty = False
self.hitZone2Penalty = False
self.lastMousePos = None
self.moveDiffForSound = self.config.playSawingSoundDelta + 0.1
self.newBoardSequence = Sequence(
Parallel(
self.currentBoard.posInterval(
self.config.newBoardAnimTime,
Point3(*self.config.activeBoardPosition)),
self.currentBoard.scaleInterval(self.config.newBoardAnimTime,
1.0)),
name='RepairSawingGame.newBoardSequence')
if self.state in ['Game']:
self.newBoardSequence.append(Func(self.sawButton.activate))
self.newBoardSequence.append(Wait(0.5))
self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
self.newBoardSequence.start()
return
def __transitionEffect(self, callback):
self.disableButtons()
ival = Sequence(Func(base.fadeOutMusic),
Func(base.transitions.irisOut, 0.5), Wait(1.0),
Func(callback))
ival.start()
def animToToon(self, timeStamp):
self.stopTransition()
if self.mode != 'suit':
self.setToSuit()
self.loadAnimToToonSfx()
suitSoundPlayed = 0
toonSoundPlayed = 0
bldgNodes = self.getNodePaths()
tracks = Parallel()
for i in bldgNodes:
name = i.getName()
if name[0] == 's':
hideTrack = Sequence(
name=self.taskName('ToToonSuitFlatsTrack'))
landmark = name.find('_landmark_') != -1
if not suitSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.cogWeakenSound, 0, 1, None,
0.0))
hideTrack.append(
self.createBounceTrack(i,
3,
1.2,
TO_TOON_BLDG_TIME * 0.05,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
5,
0.8,
TO_TOON_BLDG_TIME * 0.1,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
7,
1.2,
TO_TOON_BLDG_TIME * 0.17,
slowInitBounce=0.0))
hideTrack.append(
self.createBounceTrack(i,
9,
1.2,
TO_TOON_BLDG_TIME * 0.18,
slowInitBounce=0.0))
realScale = i.getScale()
hideTrack.append(
LerpScaleInterval(i, TO_TOON_BLDG_TIME * 0.1,
Vec3(realScale[0], realScale[1], 0.01)))
hideTrack.append(Func(base.disablePhysicsNodes, i))
if landmark:
hideTrack.append(Func(i.removeNode))
else:
hideTrack.append(Func(i.stash))
hideTrack.append(Func(i.setScale, Vec3(1)))
if not suitSoundPlayed:
suitSoundPlayed = 1
tracks.append(hideTrack)
elif name[0] == 't':
hideTrack = Sequence(name=self.taskName('ToToonFlatsTrack'))
hideTrack.append(Wait(TO_TOON_BLDG_TIME * 0.5))
if not toonSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.toonGrowSound, 0, 1, None,
0.0))
hideTrack.append(Func(i.unstash))
hideTrack.append(Func(base.enablePhysicsNodes, i))
hideTrack.append(Func(i.setScale, Vec3(1, 1, 0.01)))
if not toonSoundPlayed:
hideTrack.append(
Func(base.playSfx, self.toonSettleSound, 0, 1, None,
0.0))
hideTrack.append(
self.createBounceTrack(i,
11,
1.2,
TO_TOON_BLDG_TIME * 0.5,
slowInitBounce=4.0))
tracks.append(hideTrack)
if not toonSoundPlayed:
toonSoundPlayed = 1
self.stopTransition()
bldgMTrack = tracks
localToonIsVictor = self.localToonIsVictor()
if localToonIsVictor:
base.localAvatar.loop('neutral')
camTrack = self.walkOutCameraTrack()
victoryRunTrack, delayDeletes = self.getVictoryRunTrack()
trackName = self.taskName('toToonTrack')
self._deleteTransitionTrack()
if localToonIsVictor:
freedomTrack1 = Func(self.cr.playGame.getPlace().fsm.request,
'walk')
freedomTrack2 = Func(base.localAvatar.d_setParent,
CIGlobals.SPRender)
freedomTrack3 = Func(messenger.send,
BattleGlobals.BATTLE_COMPLETE_EVENT)
self.transitionTrack = Parallel(camTrack,
Sequence(victoryRunTrack,
bldgMTrack, freedomTrack1,
freedomTrack2,
freedomTrack3),
name=trackName)
else:
self.transitionTrack = Sequence(victoryRunTrack,
bldgMTrack,
name=trackName)
self.transitionTrack.delayDeletes = delayDeletes
if localToonIsVictor:
self.transitionTrack.start(0)
else:
self.transitionTrack.start(timeStamp)
def finalize(self):
if not self.parallel:
self.parallel = Parallel()
func = Sequence(Wait(self.wait), Func(self.end))
self.parallel.append(func)
self.parallel.start()
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, 50),
gravMult=0.55)
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),
Wait(CTGG.LyingDownDuration - (flyDur - oldFlyDur)),
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
def fillSlot(self, index, avId, wantBoardingShow=0):
self.notify.debug('%s.fillSlot(%s, %s, ... %s)' %
(self.doId, index, avId, globalClock.getRealTime()))
request = self.toonRequests.get(index)
if request:
self.cr.relatedObjectMgr.abortRequest(request)
del self.toonRequests[index]
if avId == 0:
pass
elif avId not in self.cr.doId2do:
func = PythonUtil.Functor(self.gotToon, index, avId)
self.toonRequests[index] = self.cr.relatedObjectMgr.requestObjects(
[avId], allCallback=func)
elif not self.isSetup:
self.deferredSlots.append((index, avId, wantBoardingShow))
else:
if avId == base.localAvatar.getDoId():
place = base.cr.playGame.getPlace()
if not place:
return
elevator = self.getPlaceElevator()
if elevator == None:
place.fsm.request('elevator')
elevator = self.getPlaceElevator()
if not elevator:
return
self.localToonOnBoard = 1
if hasattr(localAvatar,
'boardingParty') and localAvatar.boardingParty:
localAvatar.boardingParty.forceCleanupInviteePanel()
localAvatar.boardingParty.forceCleanupInviterPanels()
if hasattr(base.localAvatar, 'elevatorNotifier'):
base.localAvatar.elevatorNotifier.cleanup()
cameraTrack = Sequence()
cameraTrack.append(
Func(elevator.fsm.request, 'boarding',
[self.getElevatorModel()]))
cameraTrack.append(Func(elevator.fsm.request, 'boarded'))
toon = self.cr.doId2do[avId]
toon.stopSmooth()
toon.wrtReparentTo(self.golfKart)
sitStartDuration = toon.getDuration('sit-start')
jumpTrack = self.generateToonJumpTrack(toon, index)
track = Sequence(jumpTrack,
Func(toon.setAnimState, 'Sit', 1.0),
Func(self.clearToonTrack, avId),
name=toon.uniqueName('fillElevator'),
autoPause=1)
if wantBoardingShow:
boardingTrack, boardingTrackType = self.getBoardingTrack(
toon, index, True)
track = Sequence(boardingTrack, track)
if avId == base.localAvatar.getDoId():
cameraWaitTime = 2.5
if boardingTrackType == BoardingGroupShow.TRACK_TYPE_RUN:
cameraWaitTime = 0.5
cameraTrack = Sequence(Wait(cameraWaitTime), cameraTrack)
if self.canHideBoardingQuitBtn(avId):
track = Sequence(
Func(localAvatar.boardingParty.groupPanel.disableQuitButton
), track)
if avId == base.localAvatar.getDoId():
track = Parallel(cameraTrack, track)
track.delayDelete = DelayDelete.DelayDelete(
toon, 'CogKart.fillSlot')
self.storeToonTrack(avId, track)
track.start()
self.fillSlotTrack = track
self.boardedAvIds[avId] = None
return
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
elif numBarrelsSaved > 1:
resultStr = TTLocalizer.CogThiefBarrelsSaved % {
'num': numBarrelsSaved
}
elif 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()
def doDeathTrack(self):
def removeDeathSuit(suit, deathSuit):
if not deathSuit.isEmpty():
deathSuit.detachNode()
suit.cleanupLoseActor()
self.deathSuit.reparentTo(self.suit.getParent())
self.deathSuit.setScale(self.suit.getScale())
self.deathSuit.setPos(render, self.suit.getPos(render))
self.deathSuit.setHpr(render, self.suit.getHpr(render))
self.suit.hide()
self.collNodePath.reparentTo(self.deathSuit)
gearPoint = Point3(0, 0, self.suit.height / 2.0 + 2.0)
smallGears = BattleParticles.createParticleEffect(
file='gearExplosionSmall')
singleGear = BattleParticles.createParticleEffect('GearExplosion',
numParticles=1)
smallGearExplosion = BattleParticles.createParticleEffect(
'GearExplosion', numParticles=10)
bigGearExplosion = BattleParticles.createParticleEffect(
'BigGearExplosion', numParticles=30)
smallGears.setPos(gearPoint)
singleGear.setPos(gearPoint)
smallGearExplosion.setPos(gearPoint)
bigGearExplosion.setPos(gearPoint)
smallGears.setDepthWrite(False)
singleGear.setDepthWrite(False)
smallGearExplosion.setDepthWrite(False)
bigGearExplosion.setDepthWrite(False)
suitTrack = Sequence(
Func(self.collNodePath.stash),
ActorInterval(self.deathSuit, 'lose', startFrame=80, endFrame=140),
Func(removeDeathSuit,
self.suit,
self.deathSuit,
name='remove-death-suit'))
explosionTrack = Sequence(
Wait(1.5),
MovieUtil.createKapowExplosionTrack(self.deathSuit,
explosionPoint=gearPoint))
gears1Track = Sequence(ParticleInterval(smallGears,
self.deathSuit,
worldRelative=0,
duration=4.3,
cleanup=True),
name='gears1Track')
gears2MTrack = Track((0.0, explosionTrack),
(0.7,
ParticleInterval(singleGear,
self.deathSuit,
worldRelative=0,
duration=5.7,
cleanup=True)),
(5.2,
ParticleInterval(smallGearExplosion,
self.deathSuit,
worldRelative=0,
duration=1.2,
cleanup=True)),
(5.4,
ParticleInterval(bigGearExplosion,
self.deathSuit,
worldRelative=0,
duration=1.0,
cleanup=True)),
name='gears2MTrack')
def removeParticle(particle):
if particle and hasattr(particle, 'renderParent'):
particle.cleanup()
del particle
removeParticles = Sequence(Func(removeParticle, smallGears),
Func(removeParticle, singleGear),
Func(removeParticle, smallGearExplosion),
Func(removeParticle, bigGearExplosion))
self.deathTrack = Sequence(
Parallel(suitTrack, gears2MTrack, gears1Track,
self._deathSoundIval), removeParticles)
self.deathTrack.start()
def addNewAttacker(self, suitId, length = 5):
if not suitId in self.attackers:
self.attackers.append(suitId)
Sequence(Wait(length), Func(self.removeAttacker, suitId)).start()
def doActivity(self):
return Sequence(Func(self.avatar.animFSM.request, 'off'),
ActorInterval(self.avatar, 'righthand-start'),
Func(self.avatar.loop, 'righthand'), Wait(1.0))
def __handleGameOverAck(self):
self.fsm.requestFinalState()
Sequence(Func(base.transitions.irisOut, 1.0), Wait(1.2),
Func(self.d_leaving),
Func(self.headBackToMinigameArea)).start()
