def letterboxOff(self, t=0.25, finishIval=None): """ Move black bars away over t seconds. """ self.noLetterbox() self.loadLetterbox() self.letterbox.unstash() if (t == 0): self.letterbox.stash() else: self.letterboxIval = Sequence( Parallel( LerpPosInterval( self.letterboxBottom, t, pos=Vec3(0, 0, -1.2), # startPos = Vec3(0, 0, -1), ), LerpPosInterval( self.letterboxTop, t, pos=Vec3(0, 0, 1), # startPos = Vec3(0, 0, 0.8), ), ), Func(self.letterbox.stash), Func(messenger.send, 'letterboxOff'), name=self.letterboxTaskName, ) if finishIval: self.letterboxIval.append(finishIval) self.letterboxIval.start()
def letterboxOn(self, t=0.25, finishIval=None): """ Move black bars in over t seconds. """ self.noLetterbox() self.loadLetterbox() self.letterbox.unstash() if (t == 0): self.letterboxBottom.setPos(0, 0, -1) self.letterboxTop.setPos(0, 0, 0.8) fut = AsyncFuture() fut.setResult(None) return fut else: self.__letterboxFuture = AsyncFuture() self.letterboxIval = Sequence(Parallel( LerpPosInterval(self.letterboxBottom, t, pos = Vec3(0, 0, -1), #startPos = Vec3(0, 0, -1.2), ), LerpPosInterval(self.letterboxTop, t, pos = Vec3(0, 0, 0.8), # startPos = Vec3(0, 0, 1), ), ), Func(self.__finishLetterbox), name = self.letterboxTaskName, ) if finishIval: self.letterboxIval.append(finishIval) self.letterboxIval.start() return self.__letterboxFuture
def on_button_press(self, button, cmd, event=None): self.last_button_pressed = button button['state'] = DGG.DISABLED pos = button.get_pos() Sequence(LerpPosInterval(button, 0.05, pos + _pos2d(0, 2)), LerpPosInterval(button, 0.05, pos), Func(button.configure, **{'state': DGG.NORMAL}), Func(_exec, cmd)).start()
def push(self): """Camera push caused by a kick/explosion.""" if self._move_int is not None: self._move_int.pause() if self._turn_int is not None: self._turn_int.pause() self._move_int = Sequence() self._target.setZ(base.cam.getZ() - random.uniform(-0.02, 0.02)) # noqa: F821 self._target.setX(base.cam.getX() + random.uniform(-0.03, 0.03)) # noqa: F821 self._target.setY(base.cam.getY() + random.uniform(-0.03, 0.03)) # noqa: F821 self._move_int.append( Parallel( LerpPosInterval( base.cam, 0.15, self._target, bakeInStart=False, # noqa: F821 ), LerpHprInterval( self._np, 0.15, ( self._np.getH() + random.uniform(-1, 1), self._np.getP() + random.uniform(-2, 2), self._np.getR() + random.uniform(-3, 3), ), ), )) self._target.setX(base.cam.getX()) # noqa: F821 self._target.setY(base.cam.getY()) # noqa: F821 self._target.setZ(base.cam.getZ()) # noqa: F821 self._move_int.append( Parallel( LerpPosInterval( base.cam, # noqa: F821 0.5, self._target, bakeInStart=False, blendType="easeOut", ), LerpHprInterval( self._np, 0.5, (self._np.getH(), 0, self._np.getR()), blendType="easeOut", ), )) self._move_int.start()
def animateTile(self,x,y): """ the floating animation of tiles. """ Time = 2 tile = self.getTileFromPos(x,y) if tile: if tile.getPythonTag("Seq").isPlaying() ==False: seq = Sequence( LerpPosInterval( tile, Time+(0.2*Time*random()),(x,y,.35),(x,y,0) , blendType="easeInOut") , LerpPosInterval( tile, Time+(0.2*Time*random()),(x,y, 0),(x,y,.35) , blendType="easeInOut") ) tile.setPythonTag("Seq", seq ) seq.loop()
def letterboxOn(self, t=0.25, finishIval=None): self.noLetterbox() self.loadLetterbox() self.letterbox.unstash() if t == 0: self.letterboxBottom.setPos(0, 0, -1) self.letterboxTop.setPos(0, 0, 0.8) else: self.letterboxIval = Sequence(Parallel( LerpPosInterval(self.letterboxBottom, t, pos=Vec3(0, 0, -1)), LerpPosInterval(self.letterboxTop, t, pos=Vec3(0, 0, 0.8))), name=self.letterboxTaskName) if finishIval: self.letterboxIval.append(finishIval) self.letterboxIval.start()
def changePosColorScale(self,key,pos = None,color = None, scale = None,time = 0): '''Change an item's position, color, and/or scale. params should be lists having a length of 3 (pos, scale) or 4 (color) floats ''' if pos: self.itemEntries[key].pos = pos if not time: self._sceneItems[key].setPos(pos) else: ival = LerpPosInterval(self._sceneItems[key],time,pos,self._sceneItems[key].getPos()) self._intervals.append(ival) ival.start() if color: self.itemEntries[key].color = color if not time: self._sceneItems[key].setColor(color) else: ival = LerpColorInterval(self._sceneItems[key],time,color,self._sceneItems[key].getColor()) self._intervals.append(ival) ival.start() if scale: self.itemEntries[key].scale = scale if not time: self._sceneItems[key].setScale(self._sceneItems[key].getSx()*scale[0], self._sceneItems[key].getSy()*scale[1], self._sceneItems[key].getSz()*scale[2]) else: targetscale = (self._sceneItems[key].getSx()*scale[0], self._sceneItems[key].getSy()*scale[1], self._sceneItems[key].getSz()*scale[2]) ival = LerpScaleInterval(self._sceneItems[key],time,targetscale,self._sceneItems[key].getScale()) self._intervals.append(ival) ival.start()
def think(self, curTic, curT, unwalkables): self.TX = self.nextTX self.TY = self.nextTY self.lastDirection = self.direction self.direction = self.__chooseNewWalkDirection(unwalkables) self.nextTX, self.nextTY = self.__applyDirection(self.direction, self.TX, self.TY) self.occupiedTiles = [(self.TX, self.TY), (self.nextTX, self.nextTY)] if curTic == self.lastTicBeforeRender: fromCoords = self.maze.tile2world(self.TX, self.TY) toCoords = self.maze.tile2world(self.nextTX, self.nextTY) self.fromPos.set(fromCoords[0], fromCoords[1], self.SUIT_Z) self.toPos.set(toCoords[0], toCoords[1], self.SUIT_Z) self.moveIval = LerpPosInterval(self.suit, self.cellWalkDuration, self.toPos, startPos=self.fromPos, name=self.uniqueName(self.MOVE_IVAL_NAME)) if self.direction != self.lastDirection: self.fromH = self.directionHs[self.lastDirection] toH = self.directionHs[self.direction] if self.fromH == 270 and toH == 0: self.fromH = -90 elif self.fromH == 0 and toH == 270: self.fromH = 360 self.fromHpr.set(self.fromH, 0, 0) self.toHpr.set(toH, 0, 0) turnIval = LerpHprInterval(self.suit, self.turnDuration, self.toHpr, startHpr=self.fromHpr, name=self.uniqueName('turnMazeSuit')) self.moveIval = Parallel(self.moveIval, turnIval, name=self.uniqueName(self.MOVE_IVAL_NAME)) else: self.suit.setH(self.directionHs[self.direction]) moveStartT = float(self.nextThinkTic) / float(self.ticFreq) self.moveIval.start(curT - (moveStartT + self.gameStartTime)) self.nextThinkTic += self.ticPeriod
def set_view(self, view='front', num=0): views = { 'front': (Vec3(90, 0, 0), Vec3(90, 0, 0)), 'back': (Vec3(-90, 0, 0), Vec3(-90, 0, 0)), 'left': (Vec3(0, 0, 0), Vec3(0, 0, 0)), 'right': (Vec3(180, 0, 0), Vec3(180, 0, 0)), 'top': (Vec3(90, 0, 0), Vec3(90, 90, 0)), 'bottom': (Vec3(90, 0, 0), Vec3(90, -90, 0)) } if view in views: if self.node.get_hpr(render).almost_equal( views[view][0]) and self.gimbal.get_hpr( render).almost_equal(views[view][1]): return else: if num > 3: self.node.set_hpr(render, views[view][0]) self.gimbal.set_hpr(render, views[view][1]) self.node.set_pos(render, (0, 0, 0)) return Sequence( Parallel( LerpHprInterval(self.gimbal, 0.21, views[view][1], other=render), LerpHprInterval(self.node, 0.21, views[view][0], other=render), LerpPosInterval(self.node, 0.21, Vec3(0, 0, 0), other=render)), Func(self.set_view, view, 1 + num)).start()
def letterboxOff(self, t=0.25, finishIval=None): self.noLetterbox() self.loadLetterbox() self.letterbox.unstash() if t == 0: self.letterbox.stash() else: self.letterboxIval = Sequence(Parallel( LerpPosInterval(self.letterboxBottom, t, pos=Vec3(0, 0, -1.2)), LerpPosInterval(self.letterboxTop, t, pos=Vec3(0, 0, 1))), Func(self.letterbox.stash), Func(messenger.send, 'letterboxOff'), name=self.letterboxTaskName) if finishIval: self.letterboxIval.append(finishIval) self.letterboxIval.start()
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 append(self,text,width,height,spacing = 0, fadein = 0, fadeinType = 0): '''Add a NodePath that contains a generated text geom This method is called by SogalText ''' self.__lock.acquire() self.items.append(text) text.reparentTo(self) textPos = self.currentPtr text.setPos(textPos) if fadein: interval = Parallel() if fadeinType == 0 or fadeinType == 'normal': interval.append(LerpFunc(_modifyAlphaScale,fadein,0,1,blendType = 'easeOut',extraArgs = [text])) if fadeinType == 1 or fadeinType == 'flyin': interval.append(LerpFunc(_modifyAlphaScale,fadein,0,1,blendType = 'easeOut',extraArgs = [text])) interval.append(LerpPosInterval(text,fadein, self.currentPtr, (self.currentPtr[0],self.currentPtr[1],self.currentPtr[2] -0.3), blendType = 'easeOut')) interval.start() self.__lerpIntervals.append(interval) self.lineWidth = self.currentPtr[0] + width self.lineHeight = max(height, self.lineHeight) self.currentPtr = (self.lineWidth + spacing, 0, 0) self.__lock.release()
def _move(self, x, y, time): """Start camera movement with an interval (on key press). Args: x (float): Translation along x axis. y (float): Translation along y axis. time (float): Interval length. """ if self._move_int is not None: self._move_int.pause() if x: # if camera moves forward, consider Z coordinate # to calibrate move limits when zoomed if x == 1: x -= MAX_Z - base.cam.getZ() # noqa: F821 self._target.setX(x) else: self._target.setY(y) self._move_int = LerpPosInterval( base.cam, time, self._target, other=self._np # noqa: F821 ) self._move_int.start()
def _stop(self, stop_x, stop_zoom=False, is_hard=False): """Stop moving and rotating camera (on key release). Args: stop_x (bool): True - movement along x axis should be stopped. False - movement along y axis should be stopped. stop_zoom (bool): True if camera stopped zoom movement. is_hard (bool): If False, camera will be stopped with an deceleration interval. If True, stopping will be immediate. """ if self._move_int is not None: self._move_int.pause() if self._turn_int is not None: self._turn_int.pause() if stop_zoom: self._target = base.cam.getPos() # noqa: F821 elif stop_x: self._target.setX(base.cam.getX()) # noqa: F821 else: self._target.setY(base.cam.getY()) # noqa: F821 if not is_hard: self._move_int = LerpPosInterval( base.cam, 0.75, self._target, other=self._np # noqa: F821 ) self._move_int.start()
def __init__(self): self.frameMain = DirectFrame(frameSize=(base.a2dLeft, base.a2dRight, base.a2dBottom, base.a2dTop), frameColor=(0.05, 0.05, 0.05, 1)) self.frameMain.setTransparency(1) tpBig = TextProperties() tpBig.setTextScale(1.5) tpSmall = TextProperties() tpSmall.setTextScale(0.75) tpUs = TextProperties() tpUs.setUnderscore(True) tpMgr = TextPropertiesManager.getGlobalPtr() tpMgr.setProperties("big", tpBig) tpMgr.setProperties("small", tpSmall) tpMgr.setProperties("us", tpUs) creditsText = "" with open("credits.txt") as f: creditsText = f.read() self.lblCredits = DirectLabel(text=creditsText, text_fg=(1, 1, 1, 1), text_bg=(0, 0, 0, 0), frameColor=(0, 0, 0, 0), text_align=TextNode.ACenter, scale=0.1, pos=(0, 0, base.a2dTop - 0.2)) self.lblCredits.setTransparency(1) self.lblCredits.reparentTo(self.frameMain) self.creditsScroll = LerpPosInterval(self.lblCredits, 12.0, (0, 0, base.a2dTop + 3.5), startPos=(0, 0, base.a2dBottom), name="CreditsScroll") self.btnBack = DirectButton(text="BACK", text_fg=(1, 1, 1, 1), text_align=TextNode.ALeft, scale=0.1, pad=(0.15, 0.15), pos=(base.a2dLeft + 0.08, 0, base.a2dBottom + 0.05), frameColor=( (0.2, 0.2, 0.2, 0.8), (0.4, 0.4, 0.4, 0.8), (0.4, 0.4, 0.4, 0.8), (0.1, 0.1, 0.1, 0.8), ), relief=1, command=base.messenger.send, extraArgs=["Credits-Back"], pressEffect=False, rolloverSound=None, clickSound=None) self.btnBack.setTransparency(1) self.btnBack.reparentTo(self.frameMain) self.hide()
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 startFloat( self ): # This function is for estate cannon popsicles, makes the popsicles appear as though they are floating. if self.treasureType == TreasureGlobals.TreasureE: defaultPos = self.nodePath.getPos() randPos = random.random() - 6 delayTime = random.uniform(0, 0.1) randChoice = random.choice([True, False]) if randChoice: # This either starts the icecream at the highest position, or the lowest position startPos = (defaultPos[0], defaultPos[1], defaultPos[2] - randPos) endPos = (defaultPos[0], defaultPos[1], defaultPos[2]) floatUp = LerpPosInterval(self.nodePath, 2, Point3(startPos), blendType='easeInOut') floatDown = LerpPosInterval(self.nodePath, 2, Point3(endPos), blendType='easeInOut') else: startPos = (defaultPos[0], defaultPos[1], defaultPos[2]) endPos = (defaultPos[0], defaultPos[1], defaultPos[2] + randPos) floatUp = LerpPosInterval(self.nodePath, 2, Point3(endPos), blendType='easeInOut') floatDown = LerpPosInterval(self.nodePath, 2, Point3(startPos), blendType='easeInOut') self.flyingSeq = Sequence(floatUp, Wait(delayTime), floatDown, Wait(delayTime), name=self.uniqueName('floatingIcecream')) self.flyingSeq.loop()
def transition_enter(self): self.update_texts() for wdg in self.widgets: pos = wdg.get_pos() start_pos = (pos[0] - 3.6, pos[1], pos[2]) wdg.set_pos(start_pos) Sequence(Wait(abs(pos[2] - 1) / 4), LerpPosInterval(wdg, .5, pos, blendType='easeInOut')).start() self.enable()
def attack(self, task): if self.attackTrig == True: speed = 1 turnSpeed = 0.5 attackPos, distance, direction = self.minotaurObj.attack(self.camera.getPos(), self.minotaur.getPos(), \ self.ptGrid, self.spacing, self.lstWalls) origPt = self.minotaur.getPos() if attackPos != None: attack = LerpPosInterval(self.minotaur, speed, Point3(attackPos)) turnToPlayer = LerpHprInterval(self.minotaur, turnSpeed, self.minotaurObj.facePlayer(direction)) if distance == 'short': retract = LerpPosInterval(self.minotaur, speed, origPt) attackSeq = Sequence(turnToPlayer, attack, retract, name = 'attack') attackSeq.start() else: attackSeq = Sequence(turnToPlayer, attack, name = 'attack') attackSeq.start() self.attackTrig = False
def stab(self, task): timer = globalClock.getFrameTime() speed = 0.2 stabIn = LerpPosInterval(self.sword, speed, Point3(0,4,0.2)) stabOut = LerpPosInterval(self.sword, speed, Point3(0.5,1,0.2)) stab = Sequence(stabIn, stabOut, name = 'stab') stab.start() self.stabbing = True if self.hit == True: self.minotaurObj.hit() self.hurtTime = globalClock.getFrameTime() self.hurtShow(task) self.hit = False self.stabbing = False
def enterFinalBackToSea(self): self.fish.setPosHpr(self.fish.myData['goodbyePosHpr'][0], self.fish.myData['goodbyePosHpr'][1]) self.fish.actor.changeAnimationTo('swimIdle') self.farewellInterval = LerpPosInterval( self.fish, FishingGlobals.waveToLegendaryFishDuration, pos=self.fish.myData['swimmingDistance'], startPos=self.fish.getPos(), name='%s_farewellInterval' % self.fish.getName()) self.farewellInterval.start()
def __process_player_info(self, data_lst, sender): from racing.car.car import NetworkCar pos = (data_lst[1], data_lst[2], data_lst[3]) hpr = (data_lst[4], data_lst[5], data_lst[6]) velocity = (data_lst[7], data_lst[8], data_lst[9]) self.server_info[sender] = (pos, hpr, velocity) car_name = eng.car_mapping[sender] for car in [car for car in game.cars if car.__class__ == NetworkCar]: if car_name in car.path: LerpPosInterval(car.gfx.nodepath, .2, pos).start() LerpHprInterval(car.gfx.nodepath, .2, hpr).start()
def transition_exit(self, destroy=True): for wdg in self.widgets: pos = wdg.get_pos() end_pos = (pos[0] + 3.6, pos[1], pos[2]) seq = Sequence( Wait(abs(pos[2] - 1) / 4), LerpPosInterval(wdg, .5, end_pos, blendType='easeInOut'), Func(wdg.destroy if destroy else wdg.hide)) if not destroy: seq.append(Func(wdg.set_pos, pos)) seq.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 __process_game_packet(data_lst): from racing.car.car import NetworkCar for i in range(1, len(data_lst), 10): car_name = data_lst[i] car_pos = (data_lst[i + 1], data_lst[i + 2], data_lst[i + 3]) car_hpr = (data_lst[i + 4], data_lst[i + 5], data_lst[i + 6]) cars = self.mdt.logic.cars netcars = [car for car in cars if car.__class__ == NetworkCar] for car in netcars: if car_name in car.path: LerpPosInterval(car.gfx.nodepath, .2, car_pos).start() LerpHprInterval(car.gfx.nodepath, .2, car_hpr).start()
def letterboxOff(self, t=0.25, finishIval=None, blendType='noBlend'): """ Move black bars away over t seconds. """ self.noLetterbox() self.loadLetterbox() self.letterbox.unstash() if t == 0: self.letterbox.stash() fut = AsyncFuture() fut.setResult(None) return fut else: self.__letterboxFuture = AsyncFuture() self.letterboxIval = Sequence(Parallel( LerpPosInterval(self.letterboxBottom, t, pos = Vec3(0, 0, -1.2), # startPos = Vec3(0, 0, -1), blendType=blendType ), LerpPosInterval(self.letterboxTop, t, pos = Vec3(0, 0, 1), # startPos = Vec3(0, 0, 0.8), blendType=blendType ), ), Func(self.letterbox.stash), Func(self.__finishLetterbox), Func(messenger.send, 'letterboxOff'), name = self.letterboxTaskName, ) if finishIval: self.letterboxIval.append(finishIval) self.letterboxIval.start() return self.__letterboxFuture
def stopChase(self): #self.AIbehaviors.pauseAi("pursue") if not self._is_dead: self.AIbehaviors.removeAi("pursue") p1 = LerpHprInterval(self.npc, 4, Point3(180, 0, 0)) p2 = LerpPosInterval( self.npc, 4, Point3(self.anchorx, self.anchory, self.anchorz)) animInterval = self.npc.actorInterval("walk", loop=1, duration=4) p2.start() p1.start() animInterval.start() self.isMoving = False self.target = None self.isCurrentUser = False
def animateArrival(self): """ Cheesy animation introducing viewer to the DESK and TYPEWRITER :return: """ camMoveInterval = LerpPosInterval(self.base.camera, 2, self.cameraTarget) camHprInterval = LerpHprInterval(self.base.camera, 2, self.cameraHprTarget) dropKeyboardInterval = LerpPosInterval(self.typewriterNP, 2, self.typewriterTarget, startPos=self.typewriterStart, blendType='easeOut') sequence = Parallel(camMoveInterval, camHprInterval, dropKeyboardInterval) sequence.setDoneEvent('arrivalFinished') def arrivalFinished(): self.activateTypewriter() self.base.ignore('enter') self.base.ignore('esc') self.base.accept('arrivalFinished', arrivalFinished) sequence.start() # for the impatient... def cancelStartupSequence(): sequence.finish() self.base.acceptOnce('enter', cancelStartupSequence) self.base.acceptOnce('esc', cancelStartupSequence)
def fadeInCube(self, duration=2.5): """ spawn cube from the top to the floor """ self.setAnimated(True) x1, y1 = self.cube.getPythonTag("TilePos") # animate the cube, once finished clear the animation tag self.cube.setZ(render, 15) self.cube.wrtReparentTo(render) print("Starting fade in sequence") Sequence( LerpPosInterval(self.cube, duration, (x1, y1, 0.6), blendType="easeOut"), Func(self.setAnimated, False)).start()
def moveCameraAtPoint(self, x, y): #blocking scripting engine from executing the next code block self.lock() script.addOneCustomLock(self) cameraLerp = LerpPosInterval(base.camera, 2, Point3(x, base.camera.getY(), y), startPos=Point3(base.camera.getX(), base.camera.getY(), base.camera.getZ()), other=None, blendType='easeInOut', bakeInStart=1, fluid=0, name=None) Sequence(cameraLerp, Func(self.unlock)).start()