def __init__(self): self.current_animations = [] self.enterRunDuration = 1.5 self.enterWalkDuration = 0.5 self.skipPlayRateChanges = [self.IDLE] self.ease_in_idle = LerpFunc(self.easeAnimation, fromData=0, toData=1, blendType="easeIn", extraArgs=[self.IDLE]) self.ease_out_idle = LerpFunc(self.easeAnimation, fromData=1, toData=0, blendType="easeOut", extraArgs=[self.IDLE]) self.ease_in_walk = LerpFunc(self.easeAnimation, fromData=0, toData=1, duration=self.enterWalkDuration, blendType="noBlend", extraArgs=[self.WALK]) self.ease_out_walk = LerpFunc(self.easeAnimation, fromData=1, toData=0, blendType="noBlend", extraArgs=[self.WALK])
def camera_lookat(self, position, rel=False, duration=2.0, proportional=True): new_rot, angle = self.camera.calc_look_at(position, rel) if settings.debug_jump: duration = 0 if duration == 0: self.camera.set_camera_rot(new_rot) else: if proportional: duration = duration * angle / pi if self.current_interval != None: self.current_interval.pause() self.current_interval = LerpFunc( self.do_camera_rot, fromData=0, toData=1, duration=duration, blendType='easeInOut', extraArgs=[ self.camera.get_camera_rot(), new_rot - self.camera.get_camera_rot() ], name=None) self.current_interval.start()
def fadeOutLevel(self, fadeTime=1): """ the level-falls-apart animation. """ tiles = self.levelNode.findAllMatches("=Pos") for tile in tiles: x, y, z = self.getPosFromTile(tile) self.stopAnimatedTile(x, y, True) tile.setPos(x, y, 0) #tile.setHpr(random()*360,random()*360,random()*360) # seq = LerpPosHprInterval(tile,fadeTime+(0.3*fadeTime*random()),(x,y,-15),(random()*360 -180,random()*360-180,random()*360-180), blendType='easeIn') # seq.start() final_hpr = Vec3(random(), random(), random()) * 360.0 force = (Vec3(random(), random(), random()) - 0.5) * 5.0 force.z = 0 seq = LerpFunc(self.tileGravityAnimation, fromData=0, toData=1, duration=1.0, blendType='noBlend', extraArgs=[ tile.get_pos(render), Vec3(0), final_hpr, tile, force ]) tile.setPythonTag("Seq", seq) seq.start()
def loseGame(self, entry): # The triggers are set up so that the center of the ball should move to the # collision point to be in the hole global action action = "start" toPos = entry.getInteriorPoint(render) taskMgr.remove('rollTask') # Stop the maze task self.pathFollowed = np.zeros(self.pm.shape) self.maze.setP(0) self.maze.setR(0) # Move the ball into the hole over a short sequence of time. Then wait a # second and call start to reset the game Sequence( Parallel( LerpFunc(self.ballRoot.setX, fromData=self.ballRoot.getX(), toData=toPos.getX(), duration=.1), LerpFunc(self.ballRoot.setY, fromData=self.ballRoot.getY(), toData=toPos.getY(), duration=.1), LerpFunc(self.ballRoot.setZ, fromData=self.ballRoot.getZ(), toData=self.ballRoot.getZ() - .9, duration=.2)), Wait(1), Func(self.start)).start()
def poofBean(self, bean, beanAnim): if bean == None: self.notify.warning( 'poofBean, returning immediately as bean is None') return if bean.isEmpty(): self.notify.warning( 'poofBean, returning immediately as bean is empty') return currentAlpha = bean.getColorScale()[3] currentScale = bean.getScale() poofAnim = Sequence( Parallel( LerpFunc(bean.setAlphaScale, fromData=currentAlpha, toData=0.0, duration=0.25), LerpFunc(bean.setScale, fromData=currentScale, toData=currentScale * 5.0, duration=0.25)), Func(bean.stash), Func(beanAnim.finish), Func(bean.setAlphaScale, currentAlpha), Func(bean.setScale, currentScale)) poofAnim.start() return
def __shrinkLoadingBar(self): if self.__isValidDownloadBar(): ivalDuration = 0.5 barPosIval = LerpPosInterval(self.bar, ivalDuration, (-0.81, 0, -0.96)) barScaleIval = LerpScaleInterval(self.bar, ivalDuration, (0.25, 0.25, 0.25)) def posText(pos): self.bar['text_pos'] = (0, pos) def scaleText(scale): self.bar['text_scale'] = (scale, scale) textScaleIval = LerpFunc(scaleText, fromData=0.08, toData=0.16, duration=ivalDuration) textPosIval = LerpFunc(posText, fromData=-0.035, toData=-0.05, duration=ivalDuration) shrinkIval = Parallel(barPosIval, barScaleIval, textPosIval, textScaleIval, Func(self.loadingText.hide)) self.hideBlockerIval = Sequence(shrinkIval, Wait(0.5), Func(self.__hideBlocker), Func(self.__resetLoadingBar), Func(self.destroy)) self.hideBlockerIval.start()
def hide(self): if self.__hidden: return self.__hidden = True if not (self.__fading and self.__fadingDuration): NodePath.hide(self) self.removeFocus() if self.__mask: self.__mask.hide() if self.__bgPath: self.__bgPath.hide() if self.__hiddenFunc: self.__hiddenFunc(*self.__eventExtraArgs) else: #self.removeFocus() if self.__currentInterval: self.__currentInterval.pause() endpos = tuple( map(operator.add, self.__originPos, self.__fadingPositionOffset)) parallel = Parallel( LerpFunc(_modifyAlphaScale, self.__fadingDuration, 1, 0, blendType='easeIn', extraArgs=[self]), LerpPosInterval(self, self.__fadingDuration, endpos, self.__originPos, blendType='easeIn'), ) if self.__bgPath: parallel.append( LerpFunc(_modifyAlphaScale, self.__fadingDuration, 1, 0, blendType='easeIn', extraArgs=[self.__bgPath])) self.__currentInterval = Sequence( parallel, Func(NodePath.hide, self), Func(self.removeFocus), ) if self.__mask: self.__currentInterval.append(Func(self.__mask.hide)) if self.__bgPath: self.__currentInterval.append(Func(self.__bgPath.hide)) if self.__hiddenFunc: self.__currentInterval.append( Func(self.__hiddenFunc, *self.__eventExtraArgs)) self.__currentInterval.start()
def damage(self, amt): self.hp -= amt if self.hp < 0: self.world.garbage.add(self) return def update_color(scaleval): if self.node: self.node.set_color_scale(scaleval, scaleval, scaleval, 1.0) ramp_up = LerpFunc(update_color, fromData=3, toData=1, duration=.2, name=None) ramp_up.start()
def playMusic(self, music): curMusic = None nextMusic = None # get the current running music if self.musicAmbient.status() == self.musicAmbient.PLAYING: curMusic = self.musicAmbient if self.musicFight.status() == self.musicFight.PLAYING: curMusic = self.musicFight if self.musicGameOver.status() == self.musicGameOver.PLAYING: curMusic = self.musicGameOver # check which music we want to play next if music == "Fight": nextMusic = self.musicFight elif music == "Ambient": nextMusic = self.musicAmbient elif music == "GameOver": nextMusic = self.musicGameOver else: # stop all music self.musicFight.stop() self.musicAmbient.stop() self.musicGameOver.stop() fade = None if curMusic != None and nextMusic != None: # fade from cur to next # fade in the new music lerpAudioFadeOut = LerpFunc(self.audioFade, fromData=1, toData=0, duration=1.0, extraArgs=[curMusic]) lerpAudioFadeIn = LerpFunc(self.audioFade, fromData=0, toData=1, duration=1.0, extraArgs=[nextMusic]) fade = Sequence(lerpAudioFadeOut, Func(curMusic.stop), Func(nextMusic.play), lerpAudioFadeIn, name="FadeMusic") elif nextMusic != None: lerpAudioFadeIn = LerpFunc(self.audioFade, fromData=0, toData=1, duration=1.0, extraArgs=[nextMusic]) fade = Sequence(Func(nextMusic.play), lerpAudioFadeIn, name="FadeMusic") if fade != None: fade.start()
def show(self): if not self.__hidden: return self.__hidden = False if self.__mask or self.__bgPath: if self.__mask: self.__mask.reparentTo(aspect2d, sort=self.getSort()) self.__mask.show() if self.__bgPath: self.__bgPath.reparentTo(aspect2d, sort=self.getSort()) self.__bgPath.show() self.reparentTo(self.getParent(), sort=self.getSort()) if not (self.__fading and self.__fadingDuration): NodePath.show(self) self.requestFocus() if self.__shownFunc: self.__shownFunc(*self.__eventExtraArgs) else: NodePath.show(self) self.requestFocus() if self.__currentInterval: self.__currentInterval.pause() pos = tuple( map(operator.add, self.__originPos, self.__fadingPositionOffset)) parallel = Parallel( LerpFunc(_modifyAlphaScale, self.__fadingDuration, 0, 1, blendType='easeOut', extraArgs=[self]), LerpPosInterval(self, self.__fadingDuration, self.__originPos, pos, blendType='easeOut')) if self.__bgPath: parallel.append( LerpFunc(_modifyAlphaScale, self.__fadingDuration, 0, 1, blendType='easeOut', extraArgs=[self.__bgPath])) self.__currentInterval = Sequence(parallel) if self.__shownFunc: self.__currentInterval.append( Func(self.__shownFunc, *self.__eventExtraArgs)) self.__currentInterval.start()
def create_gun(self): """ Creates the gun timer """ # load image self.img = OnscreenImage(image=self.egg.find('**/gun-0'), pos=(1.05, 0, 0.75), scale=0.25) # interval self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME) self.interval.start() return
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main') self.visual = self.attachNewNode('visual') self.visual.setPos(-0.25, 0.0, 0.074999999999999997) goalTopLoc = self.model.find('**/locator_top') goalTopLoc.reparentTo(self.visual) goalBottomLoc = self.model.find('**/locator_bottom') goalBottomLoc.reparentTo(self.visual) self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self)) self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self) self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self) self.shipBackground = self.model.find('**/static_ship_background') self.shipBackground.reparentTo(self.visual) self.waterMeter = self.model.find('**/sprite_waterBottom') self.waterMeter.reparentTo(self.visual) self.waterTop = self.model.find('**/sprite_waterTop') self.waterTop.reparentTo(self.visual) self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater') self.pumpBackground = self.model.find('**/pumpBackground') self.pumpBackground.reparentTo(self.visual) self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop') self.pumpWaterTop.reparentTo(self.visual) self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom') self.pumpWaterBottom.reparentTo(self.visual) self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater') self.pumpHandle = self.model.find('**/sprite_handle') self.pumpHandle.reparentTo(self.visual) self.pumpBar = self.model.find('**/static_pump') self.pumpBar.reparentTo(self.visual) self.goalBox = self.model.find('**/sprite_clickField') self.goalBox.reparentTo(self.visual) self.goalBox.setTransparency(1) self.enableGoalBox() self.pumpLine = self.model.find('**/sprite_bar') self.pumpLine.reparentTo(self.visual) self.ghostLine = self.visual.attachNewNode('ghostLine') self.pumpLine.getChild(0).copyTo(self.ghostLine) self.ghostLine.setScale(self.pumpLine.getScale()) self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0) self.shipForground = self.model.find('**/static_ship_foreground') self.shipForground.reparentTo(self.visual) cm = CardMaker('cardMaker') cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0) self.goalBox.setZ(self.goalPositions[TOP].getZ()) self.goalBoxStartScale = self.goalBox.getSz() self.enableGoalBox() self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5) self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5) self.model.removeNode() del self.model
def looseGame(self, holeNP): toPos = holeNP.node().getShapePos(0) self.stopGame() Sequence( Parallel( LerpFunc(self.ballNP.setX, fromData = self.ballNP.getX(), toData = toPos.getX(), duration = .1), LerpFunc(self.ballNP.setY, fromData = self.ballNP.getY(), toData = toPos.getY(), duration = .1), LerpFunc(self.ballNP.setZ, fromData = self.ballNP.getZ(), toData = self.ballNP.getZ() - .9, duration = .2)), Wait(1), Func(self.startGame)).start()
def lose_game(self, holeNP): toPos = holeNP.node().get_shape_pos(0) self.stop_game() Sequence( Parallel( LerpFunc(self.ballNP.set_x, fromData = self.ballNP.get_x(), toData = toPos.get_x(), duration = .1), LerpFunc(self.ballNP.set_y, fromData = self.ballNP.get_y(), toData = toPos.get_y(), duration = .1), LerpFunc(self.ballNP.set_z, fromData = self.ballNP.get_z(), toData = self.ballNP.get_z() - .9, duration = .2)), Wait(1), Func(self.start_game)).start()
def create_moon(self): """ Creates the moon timer """ # load image self.img = OnscreenImage(image=self.egg.find('**/moon-quarter'), pos=(0, 0, 0), color=(1, 1, 1, 1), scale=0.25) # interval self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME) self.interval.start() return
def update_func(self, func, duration=0, extra=()): if settings.debug_jump: duration = 0 if duration == 0: func(duration, *extra) else: if self.current_interval != None: self.current_interval.pause() self.last_interval_time = globalClock.getRealTime() self.current_interval = LerpFunc(self.do_update_func, fromData=0, toData=1, duration=duration, extraArgs=[func, extra], name=None) self.current_interval.start()
def move_and_rotate_camera_to(self, new_pos, new_rot, absolute=True, duration=0): if settings.debug_jump: duration = 0 if duration == 0: if absolute: self.camera.set_camera_pos(new_pos) self.camera.set_camera_rot(new_rot) else: self.camera.set_rel_camera_pos(new_pos) self.camera.set_rel_camera_rot(new_rot) else: if self.current_interval != None: self.current_interval.pause() self.fake = NodePath('fake') if absolute: self.start_pos = self.camera.get_rel_camera_pos() self.end_pos = self.camera.get_rel_position_of(new_pos) #TODO #new_rot = self.camera.get_rel_rotation_of(new_pos) nodepath_lerp = LerpQuatInterval(self.fake, duration=duration, blendType='easeInOut', quat = LQuaternion(*new_rot), startQuat = LQuaternion(*self.camera.get_camera_rot()) ) func_lerp = LerpFunc(self.do_camera_move_and_rot, fromData=0, toData=1, duration=duration, blendType='easeInOut', name=None) parallel = Parallel(nodepath_lerp, func_lerp) self.current_interval = parallel self.current_interval.start()
def loadIntervals(self): def prepareHeightText(): self.heightText.node().setText(TTLocalizer.PartyTrampolineGetHeight % int(self.toon.getZ())) self.heightText.setZ(self.indicatorFactor * self.toon.getZ() + self.heightTextOffset) self.heightTextInterval = Sequence(Func(prepareHeightText), LerpFunc(self.heightText.setAlphaScale, fromData=1.0, toData=0.0, duration=1.0))
def enterDown(self): if self.oldState == 'Off': downAnimControl = self.actor.getAnimControl('down') self.actor.pose('down', downAnimControl.getNumFrames() - 1) return self.clearHitInterval() startScale = self.hole.getScale() endScale = Point3(5, 5, 5) self.hitInterval = Sequence( LerpFunc(self.setAlongSpline, duration=1.0, fromData=self.currentT, toData=0.0), LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel( SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'down', loop=0)), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut')) self.hitInterval.start()
def __init__(self, wheel_pos, radius, heading): self.radius = radius v_f = GeomVertexFormat.getV3() self.vdata = GeomVertexData('skid', v_f, Geom.UHDynamic) self.vdata.setNumRows(1) self.vertex = GeomVertexWriter(self.vdata, 'vertex') self.prim = GeomTriangles(Geom.UHStatic) self.cnt = 1 self.last_pos = wheel_pos geom = Geom(self.vdata) geom.addPrimitive(self.prim) node = GeomNode('gnode') node.addGeom(geom) nodePath = render.attachNewNode(node) nodePath.setTransparency(True) nodePath.setDepthOffset(1) self.__set_material(nodePath) nodePath.node().setBounds(OmniBoundingVolume()) self.add_vertices(radius, heading) self.add_vertices(radius, heading) self.remove_seq = Sequence( Wait(8), LerpFunc(nodePath.setAlphaScale, 8, 1, 0, 'easeInOut'), Func(nodePath.remove_node)) self.remove_seq.start()
def turnLeft(self): #turns left initial = self.camAngle final = self.camAngle - math.pi/2 #turn animation turnTime = 0.2 turnRightSeq = Sequence() turnRightSeq.append(LerpFunc(self.changeCamAngle, turnTime, initial, final, 'easeInOut')) turnRightSeq.start() self.setKey("left", 1) #notes that left key is pressed #changes the direction left, based on current direction if self.direction == "N": self.direction = "W" elif self.direction == "W": self.direction = "S" elif self.direction == "S": self.direction = "E" else: self.direction = "N" #when you turn, all the collision disablements should be True #just checking #self.enableAllWalls() #update the label self.updateDirectionText()
def __showSplat(self, position, direction, hot=False): if self.kaboomTrack is not None and self.kaboomTrack.isPlaying(): self.kaboomTrack.finish() self.clearHitInterval() splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splat.reparentTo(render) self.splat.setPos(self.root, position) self.splat.setAlphaScale(1.0) if not direction == 1.0: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0]) if self.currentFacing > 0.0: facing = 'HitFront' else: facing = 'HitBack' else: self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1]) if self.currentFacing > 0.0: facing = 'HitBack' else: facing = 'HitFront' if hot: targetscale = 0.75 part = 'head' else: targetscale = 0.5 part = 'body' def setSplatAlpha(amount): self.splat.setAlphaScale(amount) self.hitInterval = Sequence( ActorInterval(self.actor, part + facing, loop=0), Func(self.actor.loop, 'idle')) self.hitInterval.start() self.kaboomTrack = Parallel( SoundInterval(self.pieHitSound, volume=1.0, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), Sequence( Func(self.splat.showThrough), Parallel( Sequence( LerpScaleInterval(self.splat, duration=0.175, scale=targetscale, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Wait(0.175)), Sequence( Wait(0.1), LerpFunc(setSplatAlpha, duration=1.0, fromData=1.0, toData=0.0, blendType='easeOut'))), Func(self.splat.cleanup), Func(self.splat.removeNode))) self.kaboomTrack.start() return
def fadeOut(self, element, time): """ Example updating RCSS attributes from code by modifying the 'color' RCSS attribute to slowly change from solid to transparent. element: the Rocket element whose style to modify time: time in seconds for fadeout """ # get the current color from RCSS effective style color = element.style.color # convert to RGBA form prefix = color[:color.rindex(',')+1].replace('rgb(', 'rgba(') def updateAlpha(t): # another way of setting style on a specific element attr = 'color: ' + prefix + str(int(t)) +');' element.SetAttribute('style', attr) alphaInterval = LerpFunc(updateAlpha, duration=time, fromData=255, toData=0, blendType='easeIn') return alphaInterval
def __init__(self, whl_pos, whl_radius, car_h): GameObject.__init__(self) self.radius = whl_radius v_f = GeomVertexFormat.getV3() vdata = GeomVertexData('skid', v_f, Geom.UHDynamic) prim = GeomTriangles(Geom.UHStatic) self.vtx_cnt = 1 self.last_pos = whl_pos geom = Geom(vdata) geom.add_primitive(prim) self.node = GeomNode('gnode') self.node.add_geom(geom) nodepath = self.eng.gfx.root.attach_node(self.node) nodepath.set_transparency(True) nodepath.set_depth_offset(1) nodepath.node.set_two_sided(True) # for self-shadowing issues self.__set_material(nodepath) nodepath.p3dnode.set_bounds(OmniBoundingVolume()) self.add_vertices(whl_radius, car_h) self.add_vertices(whl_radius, car_h) def alpha(time, n_p): if not n_p.is_empty: n_p.node.set_shader_input('alpha', time) # this if seems necessary since, if there are skidmarks and you # exit from the race (e.g. back to the menu), then alpha is being # called from the interval manager even if the interval manager # correctly says that there are 0 intervals. self.remove_seq = Sequence( Wait(8), LerpFunc(alpha, 8, .5, 0, 'easeInOut', [nodepath]), Func(nodepath.remove_node)) self.remove_seq.start()
def contTunnel(self): # This line uses slices to take the front of the list and put it on the # back. For more information on slices check the Python manual self.tunnel = self.tunnel[1:] + self.tunnel[0:1] # Set the front segment (which was at TUNNEL_SEGMENT_LENGTH) to 0, which # is where the previous segment started self.tunnel[0].setZ(0) # Reparent the front to render to preserve the hierarchy outlined above self.tunnel[0].reparentTo(render) # Set the scale to be apropriate (since attributes like scale are # inherited, the rest of the segments have a scale of 1) self.tunnel[0].setScale(.155, .155, .305) # Set the new back to the values that the rest of teh segments have self.tunnel[3].reparentTo(self.tunnel[2]) self.tunnel[3].setZ(-TUNNEL_SEGMENT_LENGTH) self.tunnel[3].setScale(1) # Set up the tunnel to move one segment and then call contTunnel again # to make the tunnel move infinitely self.tunnelMove = Sequence( LerpFunc(self.tunnel[0].setZ, duration=TUNNEL_TIME, fromData=0, toData=TUNNEL_SEGMENT_LENGTH * .305), Func(self.contTunnel) ) self.tunnelMove.start()
def toggleScale(self) : '''a realistic scaling toggle : ''' if not self.realist_scale : init = 0 end = 1 else: init = 1 end = 0 scale = LerpFunc(self.scaleSystem, fromData=init, toData=end, duration=SCALELEN, blendType='easeIn', name='scaling') scale.start()
def _hideFlashMessage( self, duration=0.0 ): if self.isDisabled(): assert self.notify.debug("_hideFlashMessage we're disabled, but still hiding self.flashText") # return self.flashTextInterval = Sequence(Wait( duration ), LerpFunc( self.flashText.setAlphaScale, fromData=1.0, toData=0.0, duration=1.0 ), Func( self.flashText.stash ),) self.flashTextInterval.start()
def stopMusic(self, time): if (self.isPlaying): i = LerpFunc(self.stopMusicLerp, fromData=1, toData=0, duration=time, blendType='noBlend', extraArgs=[], name=None).start()
def loseGame(self, entry): toPos = entry.getInteriorPoint(render) taskMgr.remove("rollTask") Sequence( Parallel( LerpFunc(self.ballRoot.setX, fromData=self.ballRoot.getX(), toData=toPos.getX(), duration=0.1), LerpFunc(self.ballRoot.setY, fromData=self.ballRoot.getY(), toData=toPos.getY(), duration=0.1), LerpFunc(self.ballRoot.setZ, fromData=self.ballRoot.getZ(), toData=self.ballRoot.getZ() - .9, duration=0.2)), Wait(1), Func(self.start)).start()
def _hideFlashMessage(self, duration=0.0): if self.isDisabled(): pass self.flashTextInterval = Sequence( Wait(duration), LerpFunc(self.flashText.setAlphaScale, fromData=1.0, toData=0.0, duration=1.0), Func(self.flashText.stash)) self.flashTextInterval.start()
def play_audio(audio,fadein = 0, volume = 1, loop = False, manager = None): '''plays an AudioSound''' if manager is _voiceMgr: _currentVoices.append(audio) if loop: audio.setLoop(True) if not fadein: audio.setVolume(volume) audio.play() else: interval = LerpFunc(_lerpAdjust, duration = fadein, fromData = 0, toData = volume, extraArgs = [audio], blendType = 'easeOut') _fadeinIntervalTable[audio] = interval _intervals.append(interval) #save the interval in the table so if the audio stops during the interval it can stop the interval first audio.play() interval.start()
def fadeOutLevel(self,fadeTime=1): """ the level-falls-apart animation. """ tiles = self.levelNode.findAllMatches("=Pos") for tile in tiles: x,y,z = self.getPosFromTile(tile) self.stopAnimatedTile(x,y,True) tile.setPos(x,y,0) #tile.setHpr(random()*360,random()*360,random()*360) # seq = LerpPosHprInterval(tile,fadeTime+(0.3*fadeTime*random()),(x,y,-15),(random()*360 -180,random()*360-180,random()*360-180), blendType='easeIn') # seq.start() final_hpr = Vec3(random(), random(), random()) * 360.0 force = (Vec3(random(), random(), random())-0.5) * 5.0 force.z = 0 seq = LerpFunc(self.tileGravityAnimation, fromData=0, toData=1, duration=1.0, blendType='noBlend', extraArgs=[tile.get_pos(render), Vec3(0), final_hpr, tile, force]) tile.setPythonTag("Seq", seq) seq.start()
def appendStoredText(self,textprops, speed = 0, fadein = 0, fadeinType = 0): #append a text stored with appendText() or by loading self.recordedText text = textprops['text'] newLine = textprops['newLine'] custom = textprops['custom'] if custom: textMaker = TextNode('temptextmaker', self.textMaker) font = textprops['font'] if font: textMaker.setFont(font) textScale = textprops['textScale'] if textScale: textMaker.setTextScale(textScale) fg = textprops['fg'] if fg: self.setFg(fg, textMaker) shadow = textprops['shadow'] shadowOffset = textprops['shadowOffset'] if shadow: self.setShadow(shadow, shadowOffset, textMaker) #prepared to add more props here else: textMaker = self.textMaker if newLine or not self.lines: self.startLine() if not speed: for word in text: self.appendWord(word, tm = textMaker, fadein = fadein, fadeinType = fadeinType) #TYPER EFFECT else: self.__TextLerpInit() self.__currentLerpInterval = LerpFunc(self._appendTextLerpFunc,extraArgs = [text,textMaker,fadein,fadeinType], duration = len(text)/float(speed)) self.__currentLerpInterval.start()
def zoomOut(self): i = LerpFunc(self.setZoom, fromData = self.ZOOMLEVEL, toData = self.ZOOMLEVEL*1.3, duration = 1.0,blendType = "easeInOut") i.start()
class RepairPumpingGame(RepairMincroGame): pumpDownSounds = None pumpUpSounds = None pumpGoodSounds = None pumpBadSounds = None def __init__(self, repairGame): self.config = RepairGlobals.Pumping RepairMincroGame.__init__(self, repairGame, 'pumping', PLocalizer.Minigame_Repair_Pumping_Start) def _initVars(self): RepairMincroGame._initVars(self) self.pumpRate = 0.0 self.remainingWater = 1.0 self.chainCount = 0 self.barDirection = UP self.goalIndex = TOP self.currentBarRate = self.config.barStartRange[0] self.hitRange = self.config.hitRange[0] self.barPercent = 0.0 self.failedPercentAndDirection = (-1.0, UP) def _initAudio(self): RepairMincroGame._initAudio(self) if not self.pumpDownSounds: RepairPumpingGame.pumpDownSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN03)) RepairPumpingGame.pumpUpSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP03)) RepairPumpingGame.pumpGoodSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD03), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD04), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD05), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD06)) RepairPumpingGame.pumpBadSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_BAD),) def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main') self.visual = self.attachNewNode('visual') self.visual.setPos(-0.25, 0.0, 0.074999999999999997) goalTopLoc = self.model.find('**/locator_top') goalTopLoc.reparentTo(self.visual) goalBottomLoc = self.model.find('**/locator_bottom') goalBottomLoc.reparentTo(self.visual) self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self)) self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self) self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self) self.shipBackground = self.model.find('**/static_ship_background') self.shipBackground.reparentTo(self.visual) self.waterMeter = self.model.find('**/sprite_waterBottom') self.waterMeter.reparentTo(self.visual) self.waterTop = self.model.find('**/sprite_waterTop') self.waterTop.reparentTo(self.visual) self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater') self.pumpBackground = self.model.find('**/pumpBackground') self.pumpBackground.reparentTo(self.visual) self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop') self.pumpWaterTop.reparentTo(self.visual) self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom') self.pumpWaterBottom.reparentTo(self.visual) self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater') self.pumpHandle = self.model.find('**/sprite_handle') self.pumpHandle.reparentTo(self.visual) self.pumpBar = self.model.find('**/static_pump') self.pumpBar.reparentTo(self.visual) self.goalBox = self.model.find('**/sprite_clickField') self.goalBox.reparentTo(self.visual) self.goalBox.setTransparency(1) self.enableGoalBox() self.pumpLine = self.model.find('**/sprite_bar') self.pumpLine.reparentTo(self.visual) self.ghostLine = self.visual.attachNewNode('ghostLine') self.pumpLine.getChild(0).copyTo(self.ghostLine) self.ghostLine.setScale(self.pumpLine.getScale()) self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0) self.shipForground = self.model.find('**/static_ship_foreground') self.shipForground.reparentTo(self.visual) cm = CardMaker('cardMaker') cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0) self.goalBox.setZ(self.goalPositions[TOP].getZ()) self.goalBoxStartScale = self.goalBox.getSz() self.enableGoalBox() self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5) self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5) self.model.removeNode() del self.model def destroy(self): del self.goalPositions self.pumpBar.removeNode() self.pumpLine.removeNode() self.goalBox.removeNode() self.pumpHandle.removeNode() self.waterMeter.removeNode() self.waterTop.removeNode() self.ghostLine.removeNode() self.shipBackground.removeNode() self.shipForground.removeNode() def reset(self): RepairMincroGame.reset(self) self.remainingWater = WATER_LEVEL_START self.chainCount = 0 self.barDirection = UP self.goalIndex = TOP self.barPercent = 0.0 self.failedPercentAndDirection = (-1.0, UP) actualZ = self.goalPositions[BOTTOM].getZ() actualZ -= self.visual.getZ() self.pumpLine.setZ(actualZ) self.setGoalIndex(TOP) self.pumpHandle.setR(ROTATION_MIN) self.waterMeter.setSz(WATER_LEVEL_START) self.waterTop.setZ(self.waterMeterTopLoc.getZ(self.visual)) self.ghostLine.stash() self.setPumpWater(1.0) self.failLabel.stash() self.greatLabel.stash() self.repairGame.gui.setTutorial(self.name) self.repairGame.gui.setTitle(self.name) def setDifficulty(self, difficulty): RepairMincroGame.setDifficulty(self, difficulty) percent = difficulty / self.repairGame.difficultyMax dif = self.config.pumpPowerRange[0] - self.config.pumpPowerRange[1] self.pumpRate = self.config.pumpPowerRange[0] - dif * percent dif = self.config.barStartRange[0] - self.config.barStartRange[1] self.currentBarRate = self.config.barStartRange[0] - dif * percent dif = self.config.hitRange[0] - self.config.hitRange[1] self.hitRange = self.config.hitRange[0] - dif * percent self.goalBox.setSz((self.hitRange / 0.17999999999999999) * self.goalBoxStartScale) def setGoalIndex(self, goalIndex): self.goalIndex = goalIndex self.goalBox.setZ(self, self.goalPositions[goalIndex].getZ()) self.goalBox.setR(180 * (goalIndex - 1)) def resetFail(self): self.failedPercentAndDirection = (-1.0, UP) self.enableGoalBox() self.hideMarkers() def updateTask(self, task): dt = globalClock.getDt() percentTimeThisStep = dt / (self.currentBarRate + self.config.barSpeedMax) self.barPercent = self.barPercent + percentTimeThisStep * self.barDirection if self.failedPercentAndDirection[0] >= 0.0: if self.failedPercentAndDirection[1] != self.barDirection: if self.failedPercentAndDirection[0] * self.barDirection < self.barPercent * self.barDirection: self.resetFail() if self.barPercent >= 1.0: self.barPercent = 1.0 self.barDirection = DOWN if not self.isLineInBox(): self.chainCount = 0 if self.failedPercentAndDirection[0] < 0.5: self.resetFail() elif self.barPercent <= 0.0: self.barPercent = 0.0 self.barDirection = UP if not self.isLineInBox(): self.chainCount = 0 if self.failedPercentAndDirection[0] > 0.5: self.resetFail() actualZ = self.goalPositions[0].getZ() + (self.goalPositions[1].getZ() - self.goalPositions[0].getZ()) * self.barPercent actualZ -= self.visual.getZ() self.pumpLine.setZ(actualZ) return Task.cont def enableGoalBox(self): self.goalBox.setColor(0.20000000000000001, 1.0, 0.20000000000000001, 0.59999999999999998) self.goalBoxEnabled = 1 def disableGoalBox(self): self.goalBox.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 0.29999999999999999) self.goalBoxEnabled = 0 def isLineInBox(self): if self.goalIndex == TOP: return self.barPercent >= 1.0 - self.hitRange else: return self.barPercent <= self.hitRange def onMouseClick(self): if self.isLineInBox() and self.goalBoxEnabled == 1: actualPumpAmount = self.pumpRate + self.config.chainMultiplier * self.chainCount * self.pumpRate actualPumpAmount *= WATER_LEVEL_START - WATER_LEVEL_DONE self.remainingWater -= actualPumpAmount self.remainingWater = max(0.0, self.remainingWater) self.waterMeter.setSz(self.remainingWater) self.waterTop.setZ(self.waterMeterTopLoc.getZ(self.visual) - 0.001) if self.barPercent > 0.5: self.pumpWaterDownLerp.duration = self.currentBarRate self.pumpWaterDownLerp.start() self.barDirection = DOWN self.pumpHandle.setR(ROTATION_MAX) random.choice(self.pumpDownSounds).play() else: self.pumpWaterUpLerp.duration = self.currentBarRate self.pumpWaterUpLerp.start() self.barDirection = UP self.pumpHandle.setR(ROTATION_MIN) random.choice(self.pumpUpSounds).play() if self.barPercent > 0.5: self.setGoalIndex(BOTTOM) else: self.setGoalIndex(TOP) self.currentBarRate /= self.config.barSpeedIncrease self.chainCount += 1 self.setSuccessMarker() if self.remainingWater <= WATER_LEVEL_DONE and self.barDirection == DOWN: self.remainingWater = 0.0 self.request('Outro') return None totalRange = WATER_LEVEL_START - WATER_LEVEL_DONE current = WATER_LEVEL_START - self.remainingWater percent = min(100, int((current / totalRange) * 100)) self.repairGame.d_reportMincroGameProgress(percent, max(0, min(5, self.chainCount) - 1)) else: self.disableGoalBox() self.currentBarRate /= self.config.barSpeedDecrease self.currentBarRate += (1 - self.config.barSpeedDecrease) * self.config.barSpeedMin self.currentBarRate = min(self.currentBarRate, self.config.barSpeedMin) self.setFailMarker() self.chainCount = 0 self.failedPercentAndDirection = (self.barPercent, self.barDirection) def setPumpWater(self, value): self.pumpWaterBottom.setSz(value) self.pumpWaterTop.setZ(self.pumpWaterTopLoc.getZ(self.visual)) def setSuccessMarker(self): self.greatLabel.setZ(self.pumpLine.getZ()) self.greatLabel.unstash() pumpSoundIndex = min(len(self.pumpGoodSounds) - 1, self.chainCount / 2) self.pumpGoodSounds[pumpSoundIndex].play() def setFailMarker(self): self.hideMarkers() self.ghostLine.setPos(self.pumpLine.getPos()) self.ghostLine.unstash() self.failLabel.setZ(self.pumpLine.getZ()) self.failLabel.unstash() random.choice(self.pumpBadSounds).play() def hideMarkers(self): self.ghostLine.stash() self.greatLabel.stash() self.failLabel.stash() def enterGame(self): RepairMincroGame.enterGame(self) taskMgr.add(self.updateTask, 'RepairPumpingGame.updateTask') self.accept('mouse1', self.onMouseClick) self.enableGoalBox() def exitGame(self): RepairMincroGame.exitGame(self) taskMgr.remove('RepairPumpingGame.updateTask') self.ignore('mouse1') def enterOutro(self): RepairMincroGame.enterOutro(self) self.repairGame.d_reportMincroGameScore(150)
def rotateCube(self,direction): """ rotates the cube according to the direction passed as first argument. accepted values are "up" "down" "left" "right" """ #first check if we are allowed to move the block at all.. if self.isAnimated() : print "canceling rotation of cube" return #cleaning up from last rotation (we cant clean those up at the end of this function cause the interval needs the dummynode for rotation) self.cube.wrtReparentTo(render) try: dummy.remove_node() except: pass self.setAnimated(True) duration = 0.2 x1,y1,x2,y2 = self.getCubeTiles() self.level.animateTile(x1,y1) self.level.animateTile(x2,y2) dummy = render.attachNewNode("dummy") dummy.reparentTo(self.cube) dummy.setZ(render,0) dummy.wrtReparentTo(render) dummy.setHpr(0,0,0) dest_hpr = Vec3(0) if self.cube.getZ(render) > .7: #case1 : cube is standing upright #ok... since we rotate relative there are rounding errors... since there !might! be some uebernoob playing the game #needing one gazillion rotations to reach the goal it might happen those rounding errors actually get visible #so let him enjoy and reset the cube every-time it's standing straight-up. self.cube.setZ(render,1) #how comes this is one?.. well.. i know.. because of my learnings.. self.cube.setX(render, round(self.cube.getX(render),0) ) self.cube.setY(render, round(self.cube.getY(render),0) ) self.cube.setH(render, round(self.cube.getH(render),0) ) self.cube.setP(render, round(self.cube.getP(render),0) ) self.cube.setR(render, round(self.cube.getR(render),0) ) if direction == "right": dummy.setY(dummy,.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, -90, 0) self.setCubeTiles( x1, y1+1 ,x1 , y1+2 ) if direction == "left": dummy.setY(dummy,-.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 90, 0) self.setCubeTiles( x1, y1-2 ,x1 , y1-1 ) if direction == "up": dummy.setX(dummy,-.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, -90) self.setCubeTiles( x1-2, y1 ,x1-1 , y1 ) if direction == "down": dummy.setX(dummy,.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, 90) self.setCubeTiles( x1+1, y1 ,x1+2 , y1 ) elif x1 == x2 : #if aligned to y-axis if direction == "right": dummy.setY(dummy,1) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, -90, 0) self.setCubeTiles( x1, y1+2 ) if direction == "left": dummy.setY(dummy,-1) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 90, 0) self.setCubeTiles( x1, y1-1) if direction == "up": dummy.setX(dummy,-.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, -90) self.setCubeTiles( x1-1, y1, x2-1, y2 ) if direction == "down": dummy.setX(dummy,.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, 90) self.setCubeTiles( x1+1, y1, x2+1, y2 ) elif y1==y2 : #if it is alligned to x-axis.. if direction == "right": dummy.setY(dummy,.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, -90, 0) self.setCubeTiles( x1, y1+1, x2, y2+1 ) if direction == "left": dummy.setY(dummy,-.5) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 90, 0) self.setCubeTiles( x1, y1-1, x2, y2-1 ) if direction == "up": dummy.setX(dummy,-1) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, -90) self.setCubeTiles( x1-1, y1 ) if direction == "down": dummy.setX(dummy,1) self.cube.wrtReparentTo(dummy) dest_hpr = Vec3(0, 0, 90) self.setCubeTiles( x1+2, y1 ) else: print("Invalid move. Waiting ..") print("Rotating!") anim = self.animate( LerpHprInterval(dummy, duration, dest_hpr,(0,0,0) ) ) #this sorta.. doesnt belong here.. but i dunno where to put it yet. x1,y1,x2,y2 = self.getCubeTiles() # self.level.tintTile(x1,y1) #this is fun to play with if your cube is invisible... # self.level.tintTile(x2,y2) self.level.stopAnimatedTile(x1,y1) #stops the tile-animation for the tiles below the block self.level.stopAnimatedTile(x2,y2) #cheking what consequences your move had... muhahaa... if you get a 1 .. i've got bad news for you checkresult = checkMove(self.level.levelNode,self.getCubeTiles(),self.sounds) if checkresult == 1: self.falls +=1 self.moves +=1 # Force to the corner when the cuboid falls down side_force = 1.7 force = Vec3(0, 0, 0) if direction == "up": force = Vec3(-side_force, 0, 0) elif direction == "down": force = Vec3(side_force, 0, 0) elif direction == "left": force = Vec3(0, -side_force, 0) elif direction == "right": force = Vec3(0, side_force, 0) dummy.set_hpr(render, Vec3(0, 0, 0)) del anim self.setAnimated(True) final_hpr = dest_hpr * 3.0 + Vec3(random(), random(), random()) * 360.0 * 0.0 anim = LerpFunc(self.animateCube, fromData=0, toData=1, duration=1.3, blendType='noBlend', extraArgs=[dummy.get_pos(render), Vec3(0), final_hpr, dummy, force]) taskMgr.doMethodLater( anim.getDuration(), self.resetCube , "resetTask") elif checkresult == 2: #ok.. once reached the goal, move the block down, fading it out. thenload the new level etc. anim.pop() anim.append( Func(lambda: self.level.fadeOutLevel() ) ) Sequence(Wait(0.3), Func(lambda *args: self.cube.hide())).start() taskMgr.doMethodLater( anim.getDuration()+2 , self.levelUp , "lvlup") taskMgr.doMethodLater( anim.getDuration()+2 , lambda *args: self.cube.show(), "show cube") taskMgr.doMethodLater( anim.getDuration()+2 , lambda *args: self.shard_node.node().remove_all_children(), "clear shards") Sequence(Wait(0.2), Func(lambda *args: self.sounds.playSound("finish.wav"))).start() self.moves = 0 self.falls = 0 cube_min, cube_max = Vec3(-0.5, -0.5, -1), Vec3(0.5, 0.5, 1) self.shard_node.set_pos(dummy.get_pos(render) + Vec3(-0.5, 0, 0)) shard_size = (cube_max - cube_min) / 5.0 self.shard_node.hide() Sequence(Wait(0.22), Func(lambda *args: self.shard_node.show())).start() for i in range(5): for j in range(5): for k in range(5): shard = loader.loadModel("models/CubeShard.bam") shard.reparent_to(self.shard_node) shard.set_x(i * shard_size.x + 0.1) shard.set_y(j * shard_size.y + 0.1) shard.set_z(k * shard_size.z + 0.2) shard.set_scale(0.8 + random()) force = Vec3(i-2 - 0.15, j-2 - 0.15, k-2 + 2.6) force.normalize() force *= 12.0 * (1 + random() * 0.5) d_hpr = Vec3(random(), random(), random()) * 360.0 * (3.0 + random()) shard_anim = Sequence( Wait(0.22), LerpFunc(self.animateShard, fromData=0, toData=2, duration=2.0, blendType='noBlend', extraArgs=[shard.get_pos(), d_hpr, shard, force]), LerpHprInterval(shard, 1.0 + random(), d_hpr * 1.6, d_hpr, blendType='noBlend'), ) shard_anim.start() elif checkresult == 0: #how lame... just a ..move.. print "playing sound" self.moves += 1 self.sounds.playSound("stonerotate.wav") print "moves:",self.moves ," falls:",self.falls #last but not least.. we start the animation .. did you know that the pc knows you'r failing before you actually do? .. scary.. anim.start()
class SogalText(NodePath): ''' A text label, contains many TextLines ''' def __init__(self, parent = None, pos = (0,0,0), text = u'', wordwrap = None, maxRows = None, spacing = 0, lineSpacing = 0, minLineHeight = 0.5, font = None, fg = (1,1,1,1), scale = 0.07, shadow = None, shadowOffset = (0.04, 0.04), textScale = None, ): ''' Constructor :param parent: parent NodePath :param text: text :param font: font of the text :param wordwrap: set the width when wraping the word (note that ) :param maxRows: max row of the text :param spacing: spacing of words :param lineSpacing: spacing of lines :param minLineHeight: height of a line when it is empty :param fg: foreground color :param scale: scale of the text :param shadow: shadow color of the text :param shadowOffset: shadow offset of the text ''' self.destroyed = False self.__parent = parent or aspect2d self.__lerpLock = Lock() self.__font = font self.__currentLerpInterval = None self.wordwrap = wordwrap self.lines = [] self.spacing = spacing self.lineSpacing = lineSpacing self.minLineHeight = minLineHeight self.maxRows = maxRows self.recordedText = [] #recorder text sections used in backup NodePath.__init__(self,'') self.setScale(scale) self.setPos(pos) self.currentHeight = 0 self.reparentTo(self.__parent) # @UndefinedVariable self.textMaker = TextNode('textMaker') if font: self.setFont(font, specNode = None) if fg: self.setFg(fg, specNode = None) if shadow: self.setShadow(shadow, shadowOffset, specNode = None) if textScale: self.setTexScale(textScale,specNode = None) self.textMaker.setAlign(TextNode.ALeft) if shadow: pass if text: self.appendText(text) def destroy(self): if self.__currentLerpInterval: self.__currentLerpInterval.pause() self.clear() if not self.destroyed: self.destroyed = True self.textMaker = None self.recordedText = None self.removeNode() def clear(self): if self.__currentLerpInterval: self.__currentLerpInterval.pause() self.currentHeight = 0 for tl in self.lines: tl.removeNode() self.lines = [] self.recordedText = [] def setFg(self, fg, specNode = None): node = specNode or self.textMaker node.setTextColor(fg[0], fg[1], fg[2], fg[3]) def setFont(self,font, specNode = None): node = specNode or self.textMaker node.setFont(font) def setShadow(self, shadow, offset = (0.04, 0.04), specNode = None): node = specNode or self.textMaker if shadow[3] != 0: node.setShadowColor(shadow[0], shadow[1], shadow[2], shadow[3]) node.setShadow(offset) else: node.clearShadow() def setTextScale(self, scale , specNode = None): node = specNode or self.textMaker node.setTextScale(scale) def setMaxRows(self,maxrows): self.maxRows = maxrows def setWordwrap(self,wordwrap): self.wordwrap = wordwrap def setMinLineHeight(self,minLineHeight): self.minLineHeight = minLineHeight def appendText(self, text,speed = 0, fadein = 0, fadeinType = 0, newLine = False, custom = False, font = None, textScale = 1, fg = (1,1,1,1), shadow = None, shadowOffset = (0.04, 0.04), **kwargs): textprops = dict(text = text,newLine = newLine, custom = custom, font = font, textScale = textScale, fg = fg, shadow = shadow, shadowOffset = shadowOffset, **kwargs) self.recordedText.append(textprops) self.appendStoredText(textprops, speed, fadein, fadeinType) def appendStoredText(self,textprops, speed = 0, fadein = 0, fadeinType = 0): #append a text stored with appendText() or by loading self.recordedText text = textprops['text'] newLine = textprops['newLine'] custom = textprops['custom'] if custom: textMaker = TextNode('temptextmaker', self.textMaker) font = textprops['font'] if font: textMaker.setFont(font) textScale = textprops['textScale'] if textScale: textMaker.setTextScale(textScale) fg = textprops['fg'] if fg: self.setFg(fg, textMaker) shadow = textprops['shadow'] shadowOffset = textprops['shadowOffset'] if shadow: self.setShadow(shadow, shadowOffset, textMaker) #prepared to add more props here else: textMaker = self.textMaker if newLine or not self.lines: self.startLine() if not speed: for word in text: self.appendWord(word, tm = textMaker, fadein = fadein, fadeinType = fadeinType) #TYPER EFFECT else: self.__TextLerpInit() self.__currentLerpInterval = LerpFunc(self._appendTextLerpFunc,extraArgs = [text,textMaker,fadein,fadeinType], duration = len(text)/float(speed)) self.__currentLerpInterval.start() def __TextLerpInit(self): if self.__currentLerpInterval: self.__currentLerpInterval.finish() self.__lerpLock.acquire() self.__lastTextLerpValue = 0 self.__lerpLock.release() def _appendTextLerpFunc(self, lerp, text, tm, fadein, fadeinType): '''The function interval method for typer effect''' self.__lerpLock.acquire() tlen = len(text) start = int(math.floor(self.__lastTextLerpValue * tlen)) end = int(math.floor(lerp * tlen)) if end > start: appendingText = text[start:end] for word in appendingText: self.appendWord(word, tm, fadein = fadein, fadeinType = fadeinType) self.__lastTextLerpValue = lerp self.__lerpLock.release() def isWaiting(self): if self.__currentLerpInterval: return self.__currentLerpInterval.isPlaying() return False def quickFinish(self): if self.__currentLerpInterval: return self.__currentLerpInterval.finish() for l in self.lines: l.quickFinish() def appendWord(self,word,tm = None, fadein = 0, fadeinType = 0): if word == '\n': self.startLine() return textMaker = tm or self.textMaker if not self.lines: self.startLine() active_line = self.lines[-1] unicodeText = isinstance(word, types.UnicodeType) if unicodeText: textMaker.setWtext(word) else: textMaker.setText(word) width = textMaker.getWidth() height = textMaker.getHeight() node = textMaker.generate() textpath = NodePath('text_path') textpath.attachNewNode(node) if self.wordwrap: if active_line.getTotalWidth() + width > self.wordwrap: self.startLine() active_line = self.lines[-1] active_line.append(textpath, width, height,self.spacing, fadein = fadein, fadeinType = fadeinType) active_line.setPos(0,0,-(self.currentHeight + active_line.getLineHeight()) ) def startLine(self): if self.lines: self.currentHeight += self.lines[-1].getLineHeight() + self.lineSpacing line = TextLine(parent = self, height = self.minLineHeight) line.setPos(0,0,-self.currentHeight) self.lines.append(line) def removeNode(self, *args, **kwargs): return NodePath.removeNode(self, *args, **kwargs) def getCurrentText(self): return self.recordedText def getCopiedText(self): return copy.deepcopy(self.recordedText) def loadRecordedText(self,recorded): for section in recorded: self.appendStoredText(section) self.recordedText = copy.copy(recorded) def getNewText(self): if self.recordedText: return self.recordedText[0]['text'] return '' def getEndPos(self): if self.lines: return (self.lines[-1].getEndPos()[0],0 , -(self.currentHeight + self.lines[-1].getLineHeight())) else: return (0,0,0) def hasContent(self): "get if this text label empty" return bool(self.lines)