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