def updatePlugIn(steerPlugIn, task):
"""custom update task for plug-ins"""
global steerVehicles, vehicleAnimCtls
# call update for plug-in
dt = ClockObject.get_global_clock().get_dt()
steerPlugIn.update(dt)
# handle vehicle's animation
for i in range(len(vehicleAnimCtls)):
# get current velocity size
currentVelSize = steerVehicles[i].get_speed()
if currentVelSize > 0.0:
if currentVelSize < 4.0:
animOnIdx = 0
else:
animOnIdx = 1
animOffIdx = (animOnIdx + 1) % 2
# Off anim (0:walk, 1:run)
if vehicleAnimCtls[i][animOffIdx].is_playing():
vehicleAnimCtls[i][animOffIdx].stop()
# On amin (0:walk, 1:run)
vehicleAnimCtls[i][animOnIdx].set_play_rate(
currentVelSize / animRateFactor[animOnIdx])
if not vehicleAnimCtls[i][animOnIdx].is_playing():
vehicleAnimCtls[i][animOnIdx].loop(True)
else:
# stop any animation
vehicleAnimCtls[i][0].stop()
vehicleAnimCtls[i][1].stop()
#
return task.cont
def updateNavMesh(navMesh, task):
"""custom path finding update task to correct panda's Z to stay on floor"""
global crowdAgent
# call update for navMesh
dt = ClockObject.get_global_clock().get_dt()
navMesh.update(dt)
# handle crowd agents' animation
for i in range(NUMAGENTS):
# get current velocity size
currentVelSize = crowdAgent[i].get_actual_velocity().length()
if currentVelSize > 0.0:
# walk
agentAnimCtls[i][0].set_play_rate(currentVelSize / rateFactor)
if not agentAnimCtls[i][0].is_playing():
agentAnimCtls[i][0].loop(True)
else:
# check if crowd agent is on off mesh connection
if crowdAgent[i].get_traversing_state(
) == RNCrowdAgent.STATE_OFFMESH:
# off-balance
if not agentAnimCtls[i][1].is_playing():
agentAnimCtls[i][1].loop(True)
else:
# stop any animation
agentAnimCtls[i][0].stop()
agentAnimCtls[i][1].stop()
#
return task.cont
def run_logic(self, task):
"""Run the logic for this camera manager."""
#Get delta time
dt = ClockObject.get_global_clock().get_dt()
#We only need to execute logic for the free camera here
if self.mode == CAM_MODE_FREE:
#Update rotation first
base.camera.set_hpr(base.camera.get_hpr() + self.rot_vec * dt)
#Now update position
pos = base.camera.get_pos()
vec = Vec3(self.move_vec.x, self.move_vec.y, 0) * dt
base.camera.set_pos(pos + base.camera.get_quat(render).xform(vec))
base.camera.set_z(base.camera.get_z() + self.move_vec.z * dt)
#Continue this task infinitely
return Task.cont
def updatePlugIn(steerPlugIn, task):
"""custom update task for plug-ins"""
global steerVehicles, vehicleAnimCtls
# call update for plug-in
dt = ClockObject.get_global_clock().get_dt()
steerPlugIn.update(dt)
# handle vehicle's animation
for i in range(len(vehicleAnimCtls)):
# get current velocity size
currentVelSize = steerVehicles[i].get_speed()
if currentVelSize > 0.0:
if currentVelSize < 4.0:
animOnIdx = 0
else:
animOnIdx = 1
animOffIdx = (animOnIdx + 1) % 2
# Off anim (0:walk, 1:run)
if vehicleAnimCtls[i][animOffIdx].is_playing():
vehicleAnimCtls[i][animOffIdx].stop()
# On amin (0:walk, 1:run)
vehicleAnimCtls[i][animOnIdx].set_play_rate(currentVelSize / animRateFactor[animOnIdx])
if not vehicleAnimCtls[i][animOnIdx].is_playing():
vehicleAnimCtls[i][animOnIdx].loop(True)
else:
# stop any animation
vehicleAnimCtls[i][0].stop()
vehicleAnimCtls[i][1].stop()
# make playerNP kinematic (ie stand on floor)
if playerNP.node().get_speed() > 0.0:
# get steer manager
steerMgr = OSSteerManager.get_global_ptr()
# correct panda's Z: set the collision ray origin wrt collision root
pOrig = steerMgr.get_collision_root().get_relative_point(
steerMgr.get_reference_node_path(), playerNP.get_pos()) + playerHeightRayCast * 2.0
# get the collision height wrt the reference node path
gotCollisionZ = steerMgr.get_collision_height(pOrig, steerMgr.get_reference_node_path())
if gotCollisionZ.get_first():
#updatedPos.z needs correction
playerNP.set_z(gotCollisionZ.get_second())
#
return task.cont
def update(self, task):
#
dt = ClockObject.get_global_clock().get_dt()
#handle mouse
if self.mMouseMove and (self.mMouseEnabledH or self.mMouseEnabledP):
md = self.mWin.get_pointer(0)
deltaX = md.get_x() - self.mCentX
deltaY = md.get_y() - self.mCentY
if self.mWin.move_pointer(0, self.mCentX, self.mCentY):
if self.mMouseEnabledH and (deltaX != 0.0):
self.mOwnerObjectNP.set_h(
self.mOwnerObjectNP.get_h() - deltaX * self.mSensX * self.mSignOfMouse)
if self.mMouseEnabledP and (deltaY != 0.0):
self.mOwnerObjectNP.set_p(
self.mOwnerObjectNP.get_p() - deltaY * self.mSensY * self.mSignOfMouse)
#if self.mMouseMoveKey is True we are controlling mouse movements
#so we need to reset self.mMouseMove to False
if self.mMouseMoveKey:
self.mMouseMove = False
#update position/orientation
self.mOwnerObjectNP.set_y(self.mOwnerObjectNP,
self.mActualSpeedXYZ.get_y() * dt * self.mSignOfTranslation)
self.mOwnerObjectNP.set_x(self.mOwnerObjectNP,
self.mActualSpeedXYZ.get_x() * dt * self.mSignOfTranslation)
self.mOwnerObjectNP.set_z(self.mOwnerObjectNP, self.mActualSpeedXYZ.get_z() * dt)
#head
if self.mHeadLimitEnabled:
head = self.mOwnerObjectNP.get_h() + self.mActualSpeedH * dt * self.mSignOfMouse
if head > self.mHLimit:
head = self.mHLimit
elif head < -self.mHLimit:
head = -self.mHLimit
self.mOwnerObjectNP.set_h(head)
else:
self.mOwnerObjectNP.set_h(
self.mOwnerObjectNP.get_h() + self.mActualSpeedH * dt * self.mSignOfMouse)
#pitch
if self.mPitchLimitEnabled:
pitch = self.mOwnerObjectNP.get_p() + self.mActualSpeedP * dt * self.mSignOfMouse
if pitch > self.mPLimit:
pitch = self.mPLimit
elif pitch < -self.mPLimit:
pitch = -self.mPLimit
self.mOwnerObjectNP.set_p(pitch)
else:
self.mOwnerObjectNP.set_p(
self.mOwnerObjectNP.get_p() + self.mActualSpeedP * dt * self.mSignOfMouse)
#update speeds
#y axis
if self.mForward and (not self.mBackward):
if self.mAccelXYZ.get_y() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_y(
self.mActualSpeedXYZ.get_y() - self.mAccelXYZ.get_y() * dt)
if self.mActualSpeedXYZ.get_y() < -self.mMaxSpeedXYZ.get_y():
#limit speed
self.mActualSpeedXYZ.set_y(-self.mMaxSpeedXYZ.get_y())
else:
#kinematic
self.mActualSpeedXYZ.set_y(-self.mMaxSpeedXYZ.get_y())
elif self.mBackward and (not self.mForward):
if self.mAccelXYZ.get_y() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_y(
self.mActualSpeedXYZ.get_y() + self.mAccelXYZ.get_y() * dt)
if self.mActualSpeedXYZ.get_y() > self.mMaxSpeedXYZ.get_y():
#limit speed
self.mActualSpeedXYZ.set_y(self.mMaxSpeedXYZ.get_y())
else:
#kinematic
self.mActualSpeedXYZ.set_y(self.mMaxSpeedXYZ.get_y())
elif self.mActualSpeedXYZ.get_y() != 0.0:
if self.mActualSpeedXYZ.get_y() * self.mActualSpeedXYZ.get_y() \
< self.mMaxSpeedSquaredXYZ.get_y() * self.mStopThreshold:
#stop
self.mActualSpeedXYZ.set_y(0.0)
else:
#decelerate
self.mActualSpeedXYZ.set_y(
self.mActualSpeedXYZ.get_y() * (1.0 - min(self.mFrictionXYZ * dt, 1.0)))
#x axis
if self.mStrafeLeft and (not self.mStrafeRight):
if self.mAccelXYZ.get_x() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_x(
self.mActualSpeedXYZ.get_x() + self.mAccelXYZ.get_x() * dt)
if self.mActualSpeedXYZ.get_x() > self.mMaxSpeedXYZ.get_x():
#limit speed
self.mActualSpeedXYZ.set_x(self.mMaxSpeedXYZ.get_x())
else:
#kinematic
self.mActualSpeedXYZ.set_x(self.mMaxSpeedXYZ.get_x())
elif self.mStrafeRight and (not self.mStrafeLeft):
if self.mAccelXYZ.get_x() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_x(
self.mActualSpeedXYZ.get_x() - self.mAccelXYZ.get_x() * dt)
if self.mActualSpeedXYZ.get_x() < -self.mMaxSpeedXYZ.get_x():
#limit speed
self.mActualSpeedXYZ.set_x(-self.mMaxSpeedXYZ.get_x())
else:
#kinematic
self.mActualSpeedXYZ.set_x(-self.mMaxSpeedXYZ.get_y())
elif self.mActualSpeedXYZ.get_x() != 0.0:
if self.mActualSpeedXYZ.get_x() * self.mActualSpeedXYZ.get_x() \
< self.mMaxSpeedSquaredXYZ.get_x() * self.mStopThreshold:
#stop
self.mActualSpeedXYZ.set_x(0.0)
else:
#decelerate
self.mActualSpeedXYZ.set_x(
self.mActualSpeedXYZ.get_x() * (1.0 - min(self.mFrictionXYZ * dt, 1.0)))
#z axis
if self.mUp and (not self.mDown):
if self.mAccelXYZ.get_z() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_z(
self.mActualSpeedXYZ.get_z() + self.mAccelXYZ.get_z() * dt)
if self.mActualSpeedXYZ.get_z() > self.mMaxSpeedXYZ.get_z():
#limit speed
self.mActualSpeedXYZ.set_z(self.mMaxSpeedXYZ.get_z())
else:
#kinematic
self.mActualSpeedXYZ.set_z(self.mMaxSpeedXYZ.get_z())
elif self.mDown and (not self.mUp):
if self.mAccelXYZ.get_z() != 0.0:
#accelerate
self.mActualSpeedXYZ.set_z(
self.mActualSpeedXYZ.get_z() - self.mAccelXYZ.get_z() * dt)
if self.mActualSpeedXYZ.get_z() < -self.mMaxSpeedXYZ.get_z():
#limit speed
self.mActualSpeedXYZ.set_z(-self.mMaxSpeedXYZ.get_z())
else:
#kinematic
self.mActualSpeedXYZ.set_z(-self.mMaxSpeedXYZ.get_z())
elif self.mActualSpeedXYZ.get_z() != 0.0:
if self.mActualSpeedXYZ.get_z() * self.mActualSpeedXYZ.get_z() \
< self.mMaxSpeedSquaredXYZ.get_z() * self.mStopThreshold:
#stop
self.mActualSpeedXYZ.set_z(0.0)
else:
#decelerate
self.mActualSpeedXYZ.set_z(
self.mActualSpeedXYZ.get_z() * (1.0 - min(self.mFrictionXYZ * dt, 1.0)))
#rotation h
if self.mHeadLeft and (not self.mHeadRight):
if self.mAccelHP != 0.0:
#accelerate
self.mActualSpeedH += self.mAccelHP * dt
if self.mActualSpeedH > self.mMaxSpeedHP:
#limit speed
self.mActualSpeedH = self.mMaxSpeedHP
else:
#kinematic
self.mActualSpeedH = self.mMaxSpeedHP
elif self.mHeadRight and (not self.mHeadLeft):
if self.mAccelHP != 0.0:
#accelerate
self.mActualSpeedH -= self.mAccelHP * dt
if self.mActualSpeedH < -self.mMaxSpeedHP:
#limit speed
self.mActualSpeedH = -self.mMaxSpeedHP
else:
#kinematic
self.mActualSpeedH = -self.mMaxSpeedHP
elif self.mActualSpeedH != 0.0:
if self.mActualSpeedH * self.mActualSpeedH < self.mMaxSpeedSquaredHP * self.mStopThreshold:
#stop
self.mActualSpeedH = 0.0
else:
#decelerate
self.mActualSpeedH = self.mActualSpeedH * (1.0 - min(self.mFrictionHP * dt, 1.0))
#rotation p
if self.mPitchUp and (not self.mPitchDown):
if self.mAccelHP != 0.0:
#accelerate
self.mActualSpeedP += self.mAccelHP * dt
if self.mActualSpeedP > self.mMaxSpeedHP:
#limit speed
self.mActualSpeedP = self.mMaxSpeedHP
else:
#kinematic
self.mActualSpeedP = self.mMaxSpeedHP
elif self.mPitchDown and (not self.mPitchUp):
if self.mAccelHP != 0.0:
#accelerate
self.mActualSpeedP -= self.mAccelHP * dt
if self.mActualSpeedP < -self.mMaxSpeedHP:
#limit speed
self.mActualSpeedP = -self.mMaxSpeedHP
else:
#kinematic
self.mActualSpeedP = -self.mMaxSpeedHP
elif self.mActualSpeedP != 0.0:
if self.mActualSpeedP * self.mActualSpeedP < self.mMaxSpeedSquaredHP * self.mStopThreshold:
#stop
self.mActualSpeedP = 0.0
else:
#decelerate
self.mActualSpeedP = self.mActualSpeedP * (1.0 - min(self.mFrictionHP * dt, 1.0))
#
return task.cont
print("reparent sceneNP to the reference node")
sceneNP.reparent_to(navMesMgr.get_reference_node_path())
print("get the agent model")
agentNP = app.loader.load_model("eve.egg")
agentNP.set_scale(0.40)
print(
"create the crowd agent (it is attached to the reference node) and set its position"
)
crowdAgentNP = navMesMgr.create_crowd_agent("crowdAgent")
crowdAgent = crowdAgentNP.node()
crowdAgentNP.set_pos(24.0, -20.4, -2.37)
crowdAgent.set_update_callback(crowdAgentCallback)
globalClock = ClockObject.get_global_clock()
print("attach the agent model to crowdAgent")
agentNP.reparent_to(crowdAgentNP)
print("attach the crowd agent to the nav mesh")
navMesh.add_crowd_agent(crowdAgentNP)
print(str(crowdAgent) + " added to: " + str(crowdAgent.get_nav_mesh()))
print("start the path finding default update task")
navMesMgr.start_default_update()
print(
"DEBUG DRAWING: make the debug reference node path sibling of the reference node"
)
navMesMgr.get_reference_node_path_debug().reparent_to(app.render)
