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