def enterReload(self):
self.gui.deleteNoAmmoLabel()
if self.weaponName == "pistol":
self.track = Parallel(Sequence(Wait(0.3), Func(self.reload.play), Func(self.resetAmmo)),
ActorInterval(self.v_model, 'preload', playRate = 1.5), name = 'reloadTrack')
elif self.weaponName == "shotgun":
self.track = Sequence(Func(self.draw.play), LerpQuatInterval(self.v_model, duration = 0.5,
quat = (70, -50, 0), startHpr = (0, 0, 0), blendType = 'easeIn'),
SoundInterval(self.cockBack),
SoundInterval(self.cockFwd),
Func(self.resetAmmo),
Func(self.draw.play),
LerpQuatInterval(self.v_model, duration = 0.5, quat = (0, 0, 0), startHpr = (70, -50, 0),
blendType = 'easeOut'), name = 'reloadTrack')
elif self.weaponName == "sniper":
self.track = Sequence(Func(self.draw.play), LerpQuatInterval(self.v_model, duration = 0.5,
quat = (70, -50, 0), startHpr = (0, 0, 0), blendType = 'easeIn'),
SoundInterval(self.cockBack),
SoundInterval(self.cockFwd),
Func(self.resetAmmo),
Func(self.draw.play),
LerpQuatInterval(self.v_model, duration = 0.5, quat = (0, 0, 0), startHpr = (70, -50, 0),
blendType = 'easeOut'), name = 'reloadTrack')
self.track.setDoneEvent('reloadTrack')
self.acceptOnce(self.track.getDoneEvent(), self.aliveFSM.request, ['idle'])
self.track.start()
def enterWestToEast(self, ts=0):
moPath = Mopath.Mopath()
moPath.loadFile(self.westEast)
moIval = MopathInterval(moPath, self.boat)
self.track = Parallel(
SoundInterval(self.soundShipBell, node=self.boat),
SoundInterval(self.soundDockCreak, node=self.westPier), moIval,
LerpQuatInterval(self.westPier,
duration=5.0,
quat=(-90, self.pierDownP, 0),
startHpr=(-90, self.pierUpP, 0)),
Sequence(
Wait(15.0),
Parallel(
LerpQuatInterval(self.eastPier,
duration=5.0,
quat=(90, self.pierUpP, 0),
startHpr=(90, self.pierDownP, 0)),
Sequence(
Wait(2.0),
SoundInterval(self.soundDockCreak,
node=self.eastPier))),
SoundInterval(self.soundFogHorn, node=self.boat)))
self.track.start(ts)
def enterShoot(self):
self.shoot.play()
if self.weaponName == "pistol":
self.track = ActorInterval(self.v_model, 'pshoot', playRate = 2, name = 'shootTrack')
elif self.weaponName == "shotgun":
self.track = Parallel(
Sequence(
LerpQuatInterval(self.v_model, duration = 0.05, quat = (0, 3, 0), startHpr = (0, 0, 0)),
LerpQuatInterval(self.v_model, duration = 0.1, quat = (0, 0, 0), startHpr = (0, 3, 0))
),
Sequence(
LerpPosInterval(self.v_model, duration = 0.05, pos = (0, -0.3, 0), startPos = (0, 0, 0)),
LerpPosInterval(self.v_model, duration = 0.1, pos = (0, 0, 0), startPos = (0, -0.3, 0)),
Wait(0.1)
),
)
elif self.weaponName == "sniper":
self.track = Parallel(
Sequence(
LerpQuatInterval(self.v_model, duration = 0.05, quat = (0, 3, 0), startHpr = (0, 0, 0)),
LerpQuatInterval(self.v_model, duration = 0.1, quat = (0, 0, 0), startHpr = (0, 3, 0))
),
Sequence(
LerpPosInterval(self.v_model, duration = 0.05, pos = (0, -0.3, 0), startPos = (0, 0, 0)),
LerpPosInterval(self.v_model, duration = 0.1, pos = (0, 0, 0), startPos = (0, -0.3, 0)),
Wait(0.1)
),
)
self.track.setDoneEvent('shootTrack')
self.acceptOnce(self.track.getDoneEvent(), self.aliveFSM.request, ['idle'])
self.track.start()
self.ammo -= 1
self.gui.adjustAmmoGui()
self.mg.makeSmokeEffect(self.weapon.find('**/joint_nozzle').getPos(render))
self.traverse()
def buildScanTrack(self, ts=None):
if self.track:
self.track.pause()
self.track = None
self.track = Parallel(
Sequence(
LerpQuatInterval(self.cannon.find('**/cannon'),
duration=3,
quat=(60, 0, 0),
startHpr=Vec3(-60, 0, 0),
blendType='easeInOut'),
LerpQuatInterval(self.cannon.find('**/cannon'),
duration=3,
quat=(-60, 0, 0),
startHpr=Vec3(60, 0, 0),
blendType='easeInOut'),
),
Sequence(
LerpQuatInterval(self.cannon.find('**/square_drop_shadow'),
duration=3,
quat=(60, 0, 0),
startHpr=Vec3(-60, 0, 0),
blendType='easeInOut'),
LerpQuatInterval(self.cannon.find('**/square_drop_shadow'),
duration=3,
quat=(-60, 0, 0),
startHpr=Vec3(60, 0, 0),
blendType='easeInOut'),
))
if ts:
self.track.loop(ts)
else:
self.track.loop()
def enterDraw(self):
self.draw.play()
if self.weaponName == 'pistol':
self.track = ActorInterval(self.v_model,
'pdraw',
playRate=1.6,
name='drawTrack')
else:
if self.weaponName == 'shotgun':
self.v_model.pose('sidle', 15)
self.track = LerpQuatInterval(self.v_model,
duration=0.5,
quat=(0, 0, 0),
startHpr=(70, -50, 0),
blendType='easeOut',
name='drawTrack')
else:
if self.weaponName == 'sniper':
self.v_model.pose('sidle', 15)
self.track = LerpQuatInterval(self.v_model,
duration=0.5,
quat=(0, 0, 0),
startHpr=(70, -50, 0),
blendType='easeOut',
name='drawTrack')
self.track.setDoneEvent(self.track.getName())
self.acceptOnce(self.track.getDoneEvent(), self.aliveFSM.request,
['idle'])
self.track.start()
def __reset_front_view(self, view_id=None, transition=True, reset_roll=True):
""" Realigns the Front view to the world (or original user view space) """
if view_id:
current_view_id = GlobalData["view"]
GlobalData["view"] = view_id
if not self.is_front_custom:
if view_id:
GlobalData["view"] = current_view_id
return
cam = self.cam
ref_node = NodePath("ref_node")
def_front_quat = self.default_front_quat
ref_node.set_quat(def_front_quat)
hpr = cam.target.get_hpr(ref_node)
quat = Quat()
if reset_roll:
forward_vec = ref_node.get_relative_vector(cam.target, Vec3.forward())
look_at(quat, forward_vec, Vec3.up())
else:
quat.set_hpr(hpr)
if transition and (not view_id or view_id == current_view_id):
cam.target.set_hpr(hpr)
cam.pivot.set_quat(def_front_quat)
self._transition_done = False
interval1 = LerpQuatInterval(cam.target, .5, quat, blendType="easeInOut")
interval2 = LerpQuatInterval(Mgr.get("view_gizmo_root"), .5,
def_front_quat, blendType="easeInOut")
lerp_interval = Parallel(interval1, interval2)
Mgr.do("start_view_gizmo_transition")
self._lerp_interval = lerp_interval
lerp_interval.start()
Mgr.add_task(self.__transition_view, "transition_view", sort=30,
uponDeath=self.__adjust_transition_hpr)
self._dest_view = ""
else:
cam.target.set_quat(quat)
cam.pivot.set_quat(def_front_quat)
if not view_id or view_id == current_view_id:
Mgr.do("update_view_gizmo", False, True)
if GlobalData["coord_sys_type"] == "screen":
Mgr.get("selection").update_transform_values()
self.is_front_custom = False
if view_id:
GlobalData["view"] = current_view_id
def __start_view_transition(self, dest_view, quat):
self._dest_view = dest_view
lerp_interval = LerpQuatInterval(self.cam.target, .5, quat,
blendType="easeInOut")
self._lerp_interval = lerp_interval
lerp_interval.start()
self._transition_done = False
Mgr.add_task(self.__transition_view, "transition_view", sort=30,
uponDeath=self.__adjust_transition_hpr)
Mgr.do("start_view_gizmo_transition")
def enterScan(self, ts = 0, afterShooting = 0):
if afterShooting:
self.track = Parallel(
LerpQuatInterval(self.cannon.find('**/cannon'), duration = 3, quat = (-60, 0, 0),
startHpr = self.cannon.find('**/cannon').getHpr(), blendType = 'easeInOut'),
LerpQuatInterval(self.cannon.find('**/square_drop_shadow'), duration = 3, quat = (-60, 0, 0),
startHpr = self.cannon.find('**/square_drop_shadow').getHpr(), blendType = 'easeInOut'),
name = "afterShootTrack" + str(id(self))
)
self.track.setDoneEvent(self.track.getName())
self.acceptOnce(self.track.getDoneEvent(), self._afterShootTrackDone)
self.track.start(ts)
else:
self.buildScanTrack(ts)
def enterFrozen(self):
self.releaseSnowball()
self.vModel.hide()
base.localAvatar.getGeomNode().show()
camera.wrtReparentTo(self.camPivotNode)
camHeight = max(base.localAvatar.getHeight(), 3.0)
nrCamHeight = base.localAvatar.getHeight()
heightScaleFactor = camHeight * 0.3333333333
defLookAt = Point3(0.0, 1.5, camHeight)
idealData = (Point3(0.0, -12.0 * heightScaleFactor,
camHeight), defLookAt)
self.camTrack = Parallel(
LerpPosInterval(camera,
duration=1.0,
pos=idealData[0],
startPos=camera.getPos(),
blendType='easeOut'),
LerpQuatInterval(camera,
duration=1.0,
hpr=idealData[1],
startHpr=camera.getHpr(),
blendType='easeOut'))
self.camTrack.start()
self.max_camerap = 0.0
self.disableMouse()
def __get_reset_interval(self):
interval1 = LerpPosInterval(self.cam.pivot,
.5,
self.home_pos,
blendType="easeInOut")
if self.cam.lens_type == "persp":
interval2 = LerpQuatInterval(self.cam.target,
.5,
self.home_quat,
blendType="easeInOut")
interval3 = LerpPosInterval(self.cam.origin,
.5,
Point3(0., self.home_zoom, 0.),
blendType="easeInOut")
lerp_interval = Parallel(interval1, interval2, interval3)
else:
interval2 = LerpQuatScaleInterval(self.cam.target,
.5,
self.home_quat,
self.home_zoom,
blendType="easeInOut")
lerp_interval = Parallel(interval1, interval2)
return lerp_interval
def enterGuideIntroSpeech(self):
base.localAvatar.attachCamera()
renderPos = base.camera.getPos(render)
renderHpr = base.camera.getHpr(render)
base.localAvatar.detachCamera()
endPos = base.localAvatar.getPos(render) + (0, 0, 4)
base.camera.setPos(endPos)
base.camera.lookAt(self.guide, 0, 0, 3)
endHpr = base.camera.getHpr(render)
base.camera.setPos(renderPos)
base.camera.setHpr(renderHpr)
self.__prepareTutChat()
self.__doTutChat(DistributedTutorial.GUIDE_INTRO_SPEECH)
self.camMoveTrack = Sequence(
Parallel(
LerpPosInterval(base.camera,
duration=3.0,
pos=endPos,
startPos=renderPos,
blendType='easeOut'),
LerpQuatInterval(base.camera,
duration=3.0,
hpr=endHpr,
startHpr=renderHpr,
blendType='easeOut')),
Func(base.localAvatar.getGeomNode().hide))
self.camMoveTrack.start()
def enterGuideIntroSpeech(self):
base.localAvatar.attachCamera()
renderPos = base.camera.getPos(render)
renderHpr = base.camera.getHpr(render)
base.localAvatar.detachCamera()
endPos = base.localAvatar.getPos(render) + (0, 0, 4)
base.camera.setPos(endPos)
base.camera.lookAt(self.guide, 0, 0, 3)
endHpr = base.camera.getHpr(render)
base.camera.setPos(renderPos)
base.camera.setHpr(renderHpr)
self.chatIndex = -1
self.doNextIntroSpeech()
self.camMoveTrack = Sequence(
Parallel(
LerpPosInterval(base.camera,
duration=3.0,
pos=endPos,
startPos=renderPos,
blendType='easeOut'),
LerpQuatInterval(base.camera,
duration=3.0,
hpr=endHpr,
startHpr=renderHpr,
blendType='easeOut')),
Func(base.localAvatar.getGeomNode().hide))
self.camMoveTrack.start()
def enterIdle(self):
if self.weaponName == "pistol":
self.v_model.loop('pidle')
elif self.weaponName == "shotgun":
self.track = Sequence(LerpQuatInterval(self.v_model, duration = 2.0, quat = (0, 1, 0), startHpr = (0, 0, 0), blendType = 'easeInOut'),
LerpQuatInterval(self.v_model, duration = 2.0, quat = (0, 0, 0), startHpr = (0, 1, 0), blendType = 'easeInOut'))
self.track.loop()
elif self.weaponName == "sniper":
self.track = Sequence(LerpQuatInterval(self.v_model, duration = 2.0, quat = (0, 1, 0), startHpr = (0, 0, 0), blendType = 'easeInOut'),
LerpQuatInterval(self.v_model, duration = 2.0, quat = (0, 0, 0), startHpr = (0, 1, 0), blendType = 'easeInOut'))
self.track.loop()
self.accept('mouse1', self.requestShoot)
if self.ammo <= 0:
self.gui.notifyNoAmmo()
if self.ammo < 14:
self.accept('r', self.aliveFSM.request, ['reload'])
def enterRightDoorClosing(self, ts = 0):
if self.rightTrack:
self.rightTrack.finish()
self.rightTrack = None
self.rightTrack = Sequence(LerpQuatInterval(self.rightDoor, duration = 1.0, quat = (self.getRightDoorClosedH(), 0, 0),
startHpr = (self.getRightDoorOpenH(), 0, 0), blendType = 'easeIn'),
Func(base.playSfx, self.doorShutSound, 0, 1, None, 0.0, self.rightDoor))
self.rightTrack.start()
def _afterShootTrackDone(self):
self.track = None
self.track = Parallel(
Sequence(
LerpQuatInterval(self.cannon.find('**/cannon'), duration = 3, quat = (60, 0, 0),
startHpr = Vec3(-60, 0, 0), blendType = 'easeInOut'),
LerpQuatInterval(self.cannon.find('**/cannon'), duration = 3, quat = (-60, 0, 0),
startHpr = Vec3(60, 0, 0), blendType = 'easeInOut'),
),
Sequence(
LerpQuatInterval(self.cannon.find('**/square_drop_shadow'), duration = 3, quat = (60, 0, 0),
startHpr = Vec3(-60, 0, 0), blendType = 'easeInOut'),
LerpQuatInterval(self.cannon.find('**/square_drop_shadow'), duration = 3, quat = (-60, 0, 0),
startHpr = Vec3(60, 0, 0), blendType = 'easeInOut'),
)
)
self.track.loop()
def enterLeftDoorOpening(self, ts = 0):
self.toggleDoorHole('Left', show = True)
self.leftDoor.show()
if self.leftTrack:
self.leftTrack.finish()
self.leftTrack = None
self.leftTrack = Sequence(Wait(0.5), Parallel(LerpQuatInterval(self.leftDoor, duration = 0.7, quat = (self.getLeftDoorOpenH(), 0, 0),
startHpr = (self.getLeftDoorClosedH(), 0, 0), blendType = 'easeInOut'), SoundInterval(self.doorOpenSound, node = self.leftDoor)))
self.leftTrack.start()
def avatarEnter(self, slot, avId, x, y):
toon = self.cr.doId2do.get(avId)
if toon:
toon.stopSmooth()
def doTurn():
turn = Sequence(
NPCLookInterval(toon,
self.sign,
fluid=1,
durationFactor=0.0035),
Func(toon.loop, 'neutral'))
turn.start()
circle2Run2 = self.circles[slot - 1]
if avId == base.localAvatar.doId:
self.mySlot = slot
localAvatar.stopSmartCamera()
oPos = camera.getPos(render)
oHpr = camera.getHpr(render)
localAvatar.detachCamera()
camPos = self.numPlayers2CamPos[len(self.circles)]
camera.setPos(self, camPos)
camPos = camera.getPos(render)
camera.lookAt(self)
camHpr = camera.getHpr()
self.camIval = Sequence(
Parallel(
LerpPosInterval(camera,
duration=1.5,
pos=camPos,
startPos=oPos,
blendType='easeOut'),
LerpQuatInterval(camera,
duration=1.5,
hpr=camHpr,
startHpr=oHpr,
blendType='easeOut')),
Func(self.createStationAbortGui))
self.camIval.start()
runTrack = Sequence(
Func(toon.loop, 'run'),
NPCWalkInterval(toon,
circle2Run2.getPos(render),
0.1,
startPos=(x, y, toon.getZ())), Func(doTurn))
runTrack.start()
def fillSlot(self, index, avId):
toon = self.cr.doId2do.get(avId)
toon.stopSmooth()
if toon:
toon.wrtReparentTo(self.trolleyCar)
if index <= 3:
slotPos = Point3(-5, -4.5 + index * 3, 1.4)
sitStartDuration = toon.getDuration('start-sit')
toon.headsUp(slotPos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon, 0.75,
Point3(-5, -4.5 + index * 3, 1.4)),
LerpHprInterval(toon, 0.25, Point3(90, 0, 0)),
Parallel(
ActorInterval(toon, 'start-sit'),
Sequence(
Wait(sitStartDuration * 0.25),
LerpPosInterval(
toon, sitStartDuration * 0.25,
Point3(-3.9, -4.5 + index * 3, 3.0)))),
Func(toon.loop, 'sit'))
else:
slotPos = self.STAND_POSITIONS[index]
toon.headsUp(slotPos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
duration=1.0,
pos=slotPos,
startPos=toon.getPos()),
Func(toon.setAnimState, 'neutral'),
Func(toon.setHpr, 90, 0, 0))
track.start()
if avId == base.localAvatar.doId:
self.localAvOnTrolley = True
base.localAvatar.stopSmartCamera()
base.camera.wrtReparentTo(self.trolleyCar)
camTrack = Sequence(
Parallel(
LerpPosInterval(base.camera,
duration=1.5,
pos=self.CAM_POS,
startPos=base.camera.getPos(),
blendType='easeOut'),
LerpQuatInterval(base.camera,
duration=1.5,
hpr=self.CAM_HPR,
startHpr=base.camera.getHpr(),
blendType='easeOut')),
Func(self.enableExitButton))
camTrack.start()
def enterRightDoorOpening(self, ts=0):
if self.rightTrack:
self.rightTrack.finish()
self.rightTrack = None
self.rightTrack = Sequence(
Wait(0.5),
Parallel(
Func(self.toggleDoorHole, 'right', True),
LerpQuatInterval(self.rightDoor,
duration=0.7,
quat=(self.getRightDoorOpenH(), 0, 0),
startHpr=(self.getRightDoorClosedH(), 0, 0),
blendType='easeInOut'),
SoundInterval(self.doorOpenSound, node=self.rightDoor)))
self.rightTrack.start()
def doCameraNPCInteraction(self):
currCamPos = camera.getPos()
currCamHpr = camera.getHpr()
camera.setX(camera.getX() + 5)
camera.setY(camera.getY() + 5)
camera.headsUp(self)
newCamPos = camera.getPos()
newCamHpr = camera.getHpr()
camera.setPos(currCamPos)
camera.setHpr(currCamHpr)
self.cameraTrack = Parallel(
LerpPosInterval(camera, duration = 1.0, pos = newCamPos, startPos = currCamPos, blendType = 'easeOut'),
LerpQuatInterval(camera, duration = 1.0, quat = newCamHpr, startHpr = currCamHpr, blendType = 'easeOut')
)
self.cameraTrack.start()
def getAvatarEnterTrack(self, av):
track = Sequence(name = av.uniqueName('avatarEnterDoorTrack'))
track.append(Func(av.setAnimState, 'walkBack'))
track.append(
ParallelEndTogether(
LerpPosInterval(
av,
duration = 0.5,
blendType = 'easeInOut',
pos = self.enterWalkBackPos,
startPos = av.getPos(render)
),
LerpQuatInterval(
av,
duration = 0.5,
hpr = self.doorNode.getHpr(render),
startHpr = av.getHpr(render)
)
)
)
track.append(Func(av.setPlayRate, 1.0, 'walk'))
track.append(Func(av.loop, 'neutral'))
track.append(Wait(1.0))
track.append(Func(av.loop, 'walk'))
parallel = Parallel()
parallel.append(
LerpPosInterval(
av,
duration = 1.0,
blendType = 'easeInOut',
pos = self.enterWalkInPos,
startPos = self.enterWalkBackPos
)
)
if base.localAvatar.doId == av.doId:
parallel.append(LerpPosHprInterval(nodePath = camera, other = av, duration = 1.0,
pos = (0, -8, av.getHeight()), hpr = (0, 0, 0),
blendType = 'easeInOut'))
parallel.append(Sequence(Wait(0.5), Func(self.sendGoingIn), Wait(1.0)))
track.append(parallel)
if base.localAvatar.doId == av.doId:
track.append(Func(self.sendWentInDoor))
track.setDoneEvent(track.getName())
track.delayDelete = DelayDelete.DelayDelete(av, track.getName())
self.acceptOnce(track.getDoneEvent(), self.__avatarTrackDone, [track])
return track
def enterIntroSpeech2Training(self):
startCamPos = base.camera.getPos(render)
startCamHpr = base.camera.getHpr(render)
base.camera.setPosHpr(0, 0, 0, 0, 0, 0)
base.localAvatar.attachCamera()
endCamPos = base.camera.getPos(render)
endCamHpr = base.camera.getHpr(render)
base.localAvatar.detachCamera()
startHpr = self.guide.getHpr(render)
self.guide.headsUp(self.GUIDE_WATCH_POS)
endHpr = self.guide.getHpr(render)
self.guide.loop('run')
self.camMoveIval = Parallel(
LerpPosInterval(base.camera,
duration=2.0,
pos=endCamPos,
startPos=startCamPos,
blendType='easeOut'),
LerpQuatInterval(base.camera,
duration=2.0,
hpr=endCamHpr,
startHpr=startCamHpr,
blendType='easeOut'),
Sequence(
LerpPosInterval(self.guide,
duration=2.0,
pos=self.GUIDE_WATCH_POS,
startPos=self.guide.getPos(render)),
Func(self.guide.loop, 'walk'),
LerpHprInterval(self.guide,
duration=1.0,
hpr=self.GUIDE_WATCH_HPR,
startHpr=endHpr),
Func(self.guide.loop, 'neutral')),
LerpHprInterval(self.guide,
duration=1.0,
hpr=endHpr,
startHpr=startHpr))
self.camMoveIval.setDoneEvent('introSpeech2TrainingDone')
self.acceptOnce('introSpeech2TrainingDone', self.__handleIS2TDone)
self.camMoveIval.start()
def getAvatarEnterTrack(self, av):
track = Sequence(name=av.uniqueName('avatarEnterDoorTrack'))
track.append(Func(av.setAnimState, 'walkBack'))
track.append(
ParallelEndTogether(
LerpPosInterval(av,
duration=0.5,
pos=self.enterDoorWalkBackNode.getPos(render),
startPos=av.getPos(render)),
LerpQuatInterval(av,
duration=0.5,
quat=self.enterDoorWalkInNode.getHpr(render),
startHpr=av.getHpr(render))))
track.append(Func(av.setPlayRate, 1.0, 'walk'))
track.append(Func(av.loop, 'neutral'))
track.append(Wait(1.0))
track.append(Func(av.loop, 'walk'))
parallel = Parallel()
parallel.append(
LerpPosInterval(
av,
duration=1.0,
pos=self.enterDoorWalkInNode.getPos(render),
startPos=self.enterDoorWalkBackNode.getPos(render)))
if base.localAvatar.doId == av.doId:
parallel.append(
Sequence(
Wait(0.5),
Func(messenger.send,
'DistributedDoor_localAvatarGoingInDoor'), Wait(1.0)))
track.append(parallel)
if base.localAvatar.doId == av.doId:
track.append(
Func(messenger.send, 'DistributedDoor_localAvatarWentInDoor'))
track.setDoneEvent(track.getName())
track.delayDelete = DelayDelete.DelayDelete(av, track.getName())
self.acceptOnce(track.getDoneEvent(), self.__avatarTrackDone, [track])
return track
def getQuatInterval(self):
duration = abs((self.quatB.getHpr()-self.quatA.getHpr())[0]) / self.speed
return LerpQuatInterval(
self.avatar, duration, quat=self.quatB, startQuat=self.quatA
)
def enterFaceOff(self, suitId, tauntIndex, ts):
suit = self.cr.doId2do.get(suitId)
if self.isTopFloor():
song = self.topFloorMusic
taunt = DistributedCogOfficeBattle.TOP_FLOOR_TAUNT
else:
song = self.bottomFloorsMusic
taunt = CIGlobals.SuitFaceoffTaunts[
suit.suitPlan.getName()][tauntIndex]
base.playMusic(song, looping=1, volume=0.8)
base.camLens.setMinFov(30.0 / (4.0 / 3.0))
camera.reparentTo(suit)
height = suit.getHeight()
offsetPnt = Point3(0, 0, height)
MidTauntCamHeight = height * 0.66
MidTauntCamHeightLim = height - 1.8
if MidTauntCamHeight < MidTauntCamHeightLim:
MidTauntCamHeight = MidTauntCamHeightLim
TauntCamY = 18
TauntCamX = 0
TauntCamHeight = random.choice((MidTauntCamHeight, 1, 11))
camera.setPos(TauntCamX, TauntCamY, TauntCamHeight)
camera.lookAt(suit, offsetPnt)
def setCamRunY():
camera.setY(camera.getY() + 5)
self.faceOffTrack = Sequence()
self.faceOffTrack.append(Func(suit.setAutoClearChat, False))
self.faceOffTrack.append(Func(suit.setChat, taunt))
self.faceOffTrack.append(Wait(3.5))
self.faceOffTrack.append(Func(suit.nametag.clearChatText))
self.faceOffTrack.append(Func(suit.setAutoClearChat, True))
self.faceOffTrack.append(
Func(base.camLens.setMinFov,
CIGlobals.DefaultCameraFov / (4.0 / 3.0)))
self.faceOffTrack.append(Func(base.localAvatar.attachCamera))
self.faceOffTrack.append(
Func(camera.lookAt, base.localAvatar.smartCamera.getLookAtPoint()))
self.faceOffTrack.append(Func(setCamRunY))
runTrack = Parallel()
for i in xrange(len(self.avatars)):
avId = self.avatars[i]
toon = self.cr.doId2do.get(avId)
if toon:
toon.stopSmooth()
toon.wrtReparentTo(render)
points = self.getPoints('faceoff')
point = points[i]
pos = Point3(point[0], point[1], point[2])
hpr = Vec3(point[3], point[4], point[5])
toon.headsUp(pos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
duration=1.0,
pos=pos,
startPos=toon.getPos(render)),
Func(toon.setAnimState, 'walk'),
LerpQuatInterval(
toon,
duration=1.0,
hpr=hpr,
startHpr=lambda toon=toon: toon.getHpr(render)),
Func(toon.setAnimState, 'neutral'))
runTrack.append(track)
self.faceOffTrack.append(runTrack)
self.faceOffTrack.start(ts)
def __center_view_on_objects(self, transition=True, obj_to_align_to=None, obj_id=None):
if self._lerp_interval:
return
from math import tan, radians
if obj_to_align_to:
objs = [obj_to_align_to]
elif obj_id:
obj = Mgr.get("object", obj_id)
objs = [obj]
else:
pixel_color = Mgr.get("pixel_under_mouse")
obj = Mgr.get("object", pixel_color=pixel_color)
if obj:
objs = [obj]
else:
selection = Mgr.get("selection_top")
if selection:
objs = selection
else:
objs = Mgr.get("objects")
if not objs:
return
obj_root = Mgr.get("object_root")
cam = self.cam
bounds_np = cam.origin.attach_new_node("cam_aligned_node")
tmp_np = bounds_np.attach_new_node("tmp_node")
if obj_to_align_to:
bounds_np.set_hpr(obj_to_align_to.get_pivot(), 0., 0., 0.)
parents = {}
parent_copies = {}
bboxes = dict((obj, obj.get_bbox()) for obj in objs if obj.get_type() == "model")
for bbox in bboxes.values():
bbox.get_origin().detach_node()
for obj in objs:
orig = obj.get_origin()
parent = orig.get_parent()
parents[orig] = parent
if parent in parent_copies:
parent_copy = parent_copies[parent]
else:
parent_copy = NodePath("parent_copy")
parent_copy.set_transform(parent.get_transform(self.world))
parent_copy.wrt_reparent_to(tmp_np)
parent_copies[parent] = parent_copy
orig.reparent_to(parent_copy)
bounds = tmp_np.get_tight_bounds()
for orig, parent in parents.items():
orig.reparent_to(parent)
for obj, bbox in bboxes.items():
bbox.get_origin().reparent_to(obj.get_origin())
centers = {}
for obj in objs:
center = obj.get_center_pos(tmp_np)
if centers:
centers["min"].x = min(centers["min"].x, center.x)
centers["min"].y = min(centers["min"].y, center.y)
centers["min"].z = min(centers["min"].z, center.z)
centers["max"].x = max(centers["max"].x, center.x)
centers["max"].y = max(centers["max"].y, center.y)
centers["max"].z = max(centers["max"].z, center.z)
else:
centers = {"min": center, "max": VBase3(center)}
if bounds:
point_min, point_max = bounds
point_min.x = min(point_min.x, centers["min"].x)
point_min.y = min(point_min.y, centers["min"].y)
point_min.z = min(point_min.z, centers["min"].z)
point_max.x = max(point_max.x, centers["max"].x)
point_max.y = max(point_max.y, centers["max"].y)
point_max.z = max(point_max.z, centers["max"].z)
else:
point_min, point_max = centers["min"], centers["max"]
if cam.lens.is_perspective():
vec = (point_min - point_max) * .5
center_pos = self.world.get_relative_point(tmp_np, point_max + vec)
else:
vec = point_max - point_min
center_pos = self.world.get_relative_point(tmp_np, point_min + vec * .5)
bounds_np.remove_node()
if cam.lens.is_perspective():
fov_h, fov_v = cam.lens.get_fov()
x, y, z = vec
x = min(-.01, x)
y = min(-.01, y)
z = min(-.01, z)
if vec.length_squared() < .000001:
zoom = None
else:
zoom = y + ((x / tan(radians(fov_h * .5))) if x / z > fov_h / fov_v
else (z / tan(radians(fov_v * .5))))
zoom = max(-1000000., min(-cam.lens.get_near(), zoom))
if transition:
if zoom is None:
interval1 = None
else:
interval1 = LerpPosInterval(cam.origin, .3, Point3(0., zoom, 0.),
blendType="easeInOut")
else:
set_zoom = lambda: None if zoom is None else cam.origin.set_y(zoom)
else:
size_h, size_v = cam.lens.get_film_size()
x, y, z = vec
x = max(.01, x)
y = max(.01, y)
z = max(.01, z)
if vec.length_squared() < .000001:
zoom = None
else:
zoom = (x / size_h) if x / z > size_h / size_v else (z / size_v)
zoom *= cam.target.get_sx()
zoom = min(100000., max(.0004, zoom))
if transition:
if zoom is None:
interval1 = None
else:
interval1 = LerpScaleInterval(cam.target, .3, zoom, blendType="easeInOut")
else:
set_zoom = lambda: None if zoom is None else cam.target.set_scale(zoom)
if transition:
interval2 = LerpPosInterval(cam.pivot, .3, center_pos, blendType="easeInOut")
lerp_interval = Parallel(interval2)
if interval1 is not None:
lerp_interval.append(interval1)
if obj_to_align_to:
quat = obj_to_align_to.get_pivot().get_quat(self.world)
interval3 = LerpQuatInterval(cam.pivot, .3, quat, blendType="easeInOut")
interval4 = LerpQuatInterval(cam.target, .3, Quat(), blendType="easeInOut")
interval5 = LerpQuatInterval(Mgr.get("view_gizmo_root"), .5,
quat, blendType="easeInOut")
lerp_interval.append(interval3)
lerp_interval.append(interval4)
lerp_interval.append(interval5)
self._lerp_interval = lerp_interval
lerp_interval.start()
Mgr.add_task(self.__transition_view, "transition_view", sort=30)
Mgr.do("start_view_gizmo_transition")
self._dest_view = "obj_extents"
self._transition_done = False
else:
cam.pivot.set_pos(center_pos)
set_zoom()
Mgr.do("update_transf_gizmo")
Mgr.do("update_coord_sys")
Mgr.do("update_zoom_indicator")
if obj_to_align_to:
Mgr.do("update_view_gizmo", False, True)
if GlobalData["coord_sys_type"] == "screen":
Mgr.get("selection").update_transform_values()
if obj_to_align_to:
self.is_front_custom = True
quat = Quat()
zoom = cam.zoom if zoom is None else zoom
self.custom_home_default_pos = center_pos
self.custom_home_default_quat = quat
self.custom_home_default_zoom = zoom
self.home_pos = center_pos
self.home_quat = quat
self.home_zoom = zoom
def goThroughTunnel(self, toZone, inOrOut, requestStatus=None):
# inOrOut: 0 = in; 1 = out
if self.tunnelTrack:
self.ignore(self.tunnelTrack.getDoneEvent())
self.tunnelTrack.finish()
self.tunnelTrack = None
linkTunnel = LinkTunnel.getTunnelThatGoesToZone(toZone)
if not linkTunnel:
return
self.tunnelTrack = Parallel(
name=self.uniqueName('Place.goThroughTunnel'))
if inOrOut == 0:
# Going in a tunnel!
pivotPoint = linkTunnel.inPivotPoint
pivotPointNode = linkTunnel.tunnel.attachNewNode(
'tunnelPivotPoint')
pivotPointNode.setPos(pivotPoint)
pivotPointNode.setHpr(linkTunnel.inPivotStartHpr)
x, y, z = self.getPos(render)
surfZ = PhysicsUtils.getNearestGroundSurfaceZ(
self,
self.getHeight() + self.getHeight() / 2.0)
if not surfZ == -1:
# Let's use the ray-tested surface z-point instead so we don't come out of the tunnel hovering.
# This is just in case the user jumped into the tunnel, which in that case would mean that they are
# airborne and we can't depend on their current Z value.
z = surfZ
if base.localAvatar.doId == self.doId:
doneMethod = self._handleWentInTunnel
extraArgs = [requestStatus]
base.localAvatar.walkControls.setCollisionsActive(
0, andPlaceOnGround=1)
self.resetHeadHpr(override=True)
camera.wrtReparentTo(linkTunnel.tunnel)
currCamPos = camera.getPos()
currCamHpr = camera.getHpr()
tunnelCamPos = linkTunnel.camPos
tunnelCamHpr = linkTunnel.camHpr
camera.setPos(tunnelCamPos)
camera.setHpr(tunnelCamHpr)
self.tunnelTrack.append(
LerpPosInterval(camera,
duration=0.7,
pos=tunnelCamPos,
startPos=currCamPos,
blendType='easeOut'))
self.tunnelTrack.append(
LerpQuatInterval(camera,
duration=0.7,
quat=tunnelCamHpr,
startHpr=currCamHpr,
blendType='easeOut'))
self.wrtReparentTo(pivotPointNode)
self.setPos(x, y, z)
self.resetTorsoRotation()
self.stopLookAround()
if linkTunnel.__class__.__name__ == "SafeZoneLinkTunnel":
self.setHpr(180, 0, 0)
else:
self.setHpr(0, 0, 0)
exitSeq = Sequence(Func(self.loop, 'run'))
if base.localAvatar.doId == self.doId:
exitSeq.append(Wait(2.0))
exitSeq.append(Func(base.transitions.irisOut))
self.tunnelTrack.append(exitSeq)
self.tunnelTrack.append(
Sequence(
LerpHprInterval(
pivotPointNode,
duration=2.0,
hpr=linkTunnel.inPivotEndHpr,
startHpr=linkTunnel.inPivotStartHpr,
),
LerpPosInterval(pivotPointNode,
duration=1.0,
pos=(linkTunnel.inPivotEndX,
pivotPointNode.getY(),
pivotPointNode.getZ()),
startPos=(linkTunnel.inPivotStartX,
pivotPointNode.getY(),
pivotPointNode.getZ())),
Func(self.reparentTo, hidden)))
elif inOrOut == 1:
# Going out!
pivotPoint = linkTunnel.outPivotPoint
pivotPointNode = linkTunnel.tunnel.attachNewNode(
'tunnelPivotPoint')
pivotPointNode.setPos(pivotPoint)
pivotPointNode.setHpr(linkTunnel.outPivotStartHpr)
exitSeq = Sequence()
if base.localAvatar.doId == self.doId:
base.localAvatar.walkControls.setCollisionsActive(
0, andPlaceOnGround=1)
base.localAvatar.detachCamera()
camera.reparentTo(linkTunnel.tunnel)
tunnelCamPos = linkTunnel.camPos
tunnelCamHpr = linkTunnel.camHpr
camera.setPos(tunnelCamPos)
camera.setHpr(tunnelCamHpr)
doneMethod = self._handleCameOutTunnel
extraArgs = []
exitSeq.append(Func(base.transitions.irisIn))
else:
self.stopSmooth()
self.reparentTo(pivotPointNode)
self.setHpr(linkTunnel.toonOutHpr)
self.setPos(linkTunnel.toonOutPos)
seq = Sequence(
Func(self.loop, 'run'),
LerpPosInterval(pivotPointNode,
duration=1.0,
pos=(linkTunnel.outPivotEndX,
pivotPointNode.getY(),
pivotPointNode.getZ()),
startPos=(linkTunnel.outPivotStartX,
pivotPointNode.getY(),
pivotPointNode.getZ())),
LerpHprInterval(
pivotPointNode,
duration=2.0,
hpr=linkTunnel.outPivotEndHpr,
startHpr=linkTunnel.outPivotStartHpr,
))
if base.localAvatar.doId != self.doId:
seq.append(Func(self.startSmooth))
seq.append(Func(self.wrtReparentTo, render))
exitSeq.append(seq)
self.tunnelTrack.append(exitSeq)
if base.localAvatar.doId == self.doId:
self.tunnelTrack.setDoneEvent(self.tunnelTrack.getName())
self.acceptOnce(self.tunnelTrack.getDoneEvent(), doneMethod,
extraArgs)
self.tunnelTrack.start()
def enterOnStage(self):
dna = self.choice.dna
name = self.choice.name
self.stageToon.setName(name)
self.stageToon.setDNAStrand(dna)
self.stageToon.nametag.setNametagColor(
NametagGlobals.NametagColors[NametagGlobals.CCLocal])
self.stageToon.nametag.setActive(0)
self.stageToon.nametag.nametag3d.request('Rollover')
self.stageToon.nametag.unmanage(base.marginManager)
self.stageToon.nametag.updateAll()
self.stageToon.animFSM.request('neutral')
self.stageToon.setPosHpr(0, 0, 0, 10, 0, 0)
self.stageToon.show()
dat = HOOD_STAGE_DATA[self.choice.lastHood]
self.stageToonRoot.setPos(dat[2])
self.stageToonRoot.setHpr(dat[3])
camera.reparentTo(self.stageToonRoot)
camera.setPos(dat[0])
camera.lookAt(self.stageToonRoot, 0, 0, 3)
startHpr = camera.getHpr()
camera.setPos(dat[1])
camera.lookAt(self.stageToonRoot, 0, 0, 3)
endHpr = camera.getHpr()
self.camIval = Parallel(
LerpPosInterval(camera,
5.0,
dat[1] - (1.6, 0, 0),
dat[0] - (1.6, 0, 0),
blendType='easeInOut'),
LerpQuatInterval(camera,
5.0,
hpr=endHpr,
startHpr=startHpr,
blendType='easeInOut'),
LerpFunc(self.__changeCamFOV,
duration=5.0,
fromData=80.0,
toData=CIGlobals.DefaultCameraFov,
blendType='easeInOut'))
if self.isNewToon:
self.camIval.append(
Sequence(
Func(self.stageToon.hide), Func(base.stopMusic),
SoundInterval(self.newToonAnnounceSfx,
startTime=1.674,
duration=4.047),
SoundInterval(self.newToonDrumrollSfx),
Func(self.stageToon.pose, 'tele',
self.stageToon.getNumFrames('tele')),
Func(self.newToonAppear), Func(self.stageToon.show),
SoundInterval(self.newToonRevealSfx),
Func(base.cr.playTheme)))
else:
self.camIval.append(
Sequence(Func(self.showActionButtons),
Func(self.enableAllCharButtons), Wait(5.0),
Func(self.beginRandomAnims)))
self.camIval.start()
def enterFaceOff(self, tauntIndex, ts):
tauntSuit = self.suits.get(self.tauntSuitId)
if self.isTopFloor():
song = self.topFloorMusic
taunt = DistributedCogOfficeBattle.TOP_FLOOR_TAUNT
else:
song = self.bottomFloorsMusic
taunt = SuitGlobals.FaceoffTaunts[
tauntSuit.suitPlan.getName()][tauntIndex]
base.playMusic(song, looping=1)
base.camLens.setMinFov(30.0 / (4. / 3.))
def posCamera_run():
pos, lookAt = base.localAvatar.walkControls.fpsCam.getThirdPersonBattleCam(
)
base.camera.setPos(pos)
base.camera.lookAt(lookAt)
camera.reparentTo(tauntSuit)
height = tauntSuit.getHeight()
offsetPnt = Point3(0, 0, height)
MidTauntCamHeight = height * 0.66
MidTauntCamHeightLim = height - 1.8
if MidTauntCamHeight < MidTauntCamHeightLim:
MidTauntCamHeight = MidTauntCamHeightLim
TauntCamY = 18
TauntCamX = 0
TauntCamHeight = random.choice((MidTauntCamHeight, 1, 11))
camera.setPos(TauntCamX, TauntCamY, TauntCamHeight)
camera.lookAt(tauntSuit, offsetPnt)
self.faceOffTrack = Sequence()
self.faceOffTrack.append(Func(tauntSuit.setAutoClearChat, False))
self.faceOffTrack.append(Func(tauntSuit.setChat, taunt))
self.faceOffTrack.append(Wait(3.5))
self.faceOffTrack.append(Func(tauntSuit.nametag.clearChatText))
self.faceOffTrack.append(Func(tauntSuit.setAutoClearChat, True))
self.faceOffTrack.append(
Func(base.camLens.setMinFov,
CIGlobals.DefaultCameraFov / (4. / 3.)))
self.faceOffTrack.append(Func(base.localAvatar.attachCamera))
self.faceOffTrack.append(Func(posCamera_run))
faceoffs = base.bspLoader.findAllEntities("cogoffice_faceoff_point")
runTrack = Parallel()
for i in xrange(len(self.avIds)):
avId = self.avIds[i]
toon = self.cr.doId2do.get(avId)
if toon:
toon.stopSmooth()
toon.wrtReparentTo(render)
faceoff = faceoffs[i]
pos = faceoff.cEntity.getOrigin()
hpr = faceoff.cEntity.getAngles()
toon.headsUp(pos)
track = Sequence(
Func(toon.setAnimState, 'run'),
LerpPosInterval(toon,
duration=1.5,
pos=pos,
startPos=toon.getPos(render)),
Func(toon.setAnimState, 'walk'),
LerpQuatInterval(
toon,
duration=1.0,
hpr=hpr,
startHpr=lambda toon=toon: toon.getHpr(render)),
Func(toon.setAnimState, 'neutral'))
if avId != base.localAvatar.doId:
track.append(Func(toon.startSmooth))
runTrack.append(track)
#for suit in self.suits.values():
# if suit.hangoutPoint[0]:
# track = Sequence(
# Func(suit.setAnimState, 'walk'),
# NPCWalkInterval(
# suit, Point3(suit.guardPoint[0][0], suit.guardPoint[0][1], suit.guardPoint[0][2]), durationFactor = 0.19),
# Func(suit.setHpr, Vec3(suit.guardPoint[1], 0, 0)),
# Func(suit.setAnimState, 'neutral'))
# runTrack.append(track)
self.faceOffTrack.append(runTrack)
self.faceOffTrack.start(ts)
def __reset_view(self, to_default=True, transition=False):
""" Make the Home view the current view """
cam = self.cam
lerp_view_gizmo = False
if to_default:
if transition and self.is_front_custom:
lerp_view_gizmo = True
gizmo_root = Mgr.get("view_gizmo_root")
hpr = gizmo_root.get_hpr()
self.__reset_front_view(transition=False, reset_roll=False)
self.__reset_home_view()
Mgr.update_app("active_grid_plane", self.default_grid_plane)
GlobalData["render_mode"] = self.default_render_mode
Mgr.update_app("render_mode")
if lerp_view_gizmo:
gizmo_root.set_hpr(hpr)
current_quat = cam.target.get_quat()
pos = self.home_pos
quat = self.home_quat
zoom = self.home_zoom
almost_same_zoom = Vec3(0., zoom, 0.) == Vec3(0., cam.zoom, 0.)
def_front_quat = self.default_front_quat
if current_quat.almost_same_direction(quat, .000001) \
and cam.pivot.get_pos() == pos and almost_same_zoom:
if lerp_view_gizmo:
gizmo_interval = LerpQuatInterval(gizmo_root, .5, def_front_quat, blendType="easeInOut")
self._lerp_interval = gizmo_interval
gizmo_interval.start()
Mgr.add_task(self.__transition_view, "transition_view", sort=30,
uponDeath=self.__adjust_transition_hpr)
Mgr.do("start_view_gizmo_transition")
self._dest_view = "home"
self._transition_done = False
return
if transition:
lerp_interval = self.reset_interval
if lerp_view_gizmo:
gizmo_interval = LerpQuatInterval(gizmo_root, .5, def_front_quat, blendType="easeInOut")
lerp_interval.append(gizmo_interval)
self._lerp_interval = lerp_interval
lerp_interval.start()
Mgr.add_task(self.__transition_view, "transition_view", sort=30,
uponDeath=self.__adjust_transition_hpr)
Mgr.do("start_view_gizmo_transition")
self._dest_view = "home"
self._transition_done = False
else:
cam.pivot.set_pos(pos)
cam.target.set_quat(quat)
cam.zoom = zoom
Mgr.do("update_transf_gizmo")
Mgr.do("update_coord_sys")
Mgr.do("update_zoom_indicator")
Mgr.do("update_view_gizmo")
if GlobalData["coord_sys_type"] == "screen":
Mgr.get("selection").update_transform_values()
