def createCtfVehicle(data, vehicleType):
"""creates a generic vehicle for ctf plug-in"""
global steerVehicles
maxForce = 1.0
maxSpeed = 5.0
# set vehicle's type == ctf_enemy
typeStr = "ctf_enemy"
speed = 1.0
if vehicleType == OSSteerVehicle.CTF_SEEKER:
typeStr = "ctf_seeker"
speed = 0.0
OSSteerManager.get_global_ptr().set_parameter_value(
OSSteerManager.STEERVEHICLE, "vehicle_type", typeStr)
oldPlayerNum = len(steerVehicles)
# handle vehicle
handleVehicles(data)
if len(steerVehicles) > oldPlayerNum:
# set vehicle's parameters
steerVehicles[-1].set_max_force(maxForce)
steerVehicles[-1].set_max_speed(maxSpeed)
steerVehicles[-1].set_speed(speed)
steerVehicles[-1].set_up_axis_fixed(True)
return True
return False
def createSoccerVehicle(data, vehicleType):
"""creates a generic vehicle for soccer plug-in"""
global steerVehicles
# set vehicle's type == player
typeStr = "player"
maxForce = 3000.7
maxSpeed = 10.0
speed = 0.0
if vehicleType == OSSteerVehicle.BALL:
typeStr = "ball"
maxForce = 9.0
maxSpeed = 9.0
speed = 1.0
OSSteerManager.get_global_ptr().set_parameter_value(
OSSteerManager.STEERVEHICLE, "vehicle_type", typeStr)
oldPlayerNum = len(steerVehicles)
# handle vehicle
handleVehicles(data)
if len(steerVehicles) > oldPlayerNum:
# set vehicle's parameters
steerVehicles[-1].set_max_force(maxForce)
steerVehicles[-1].set_max_speed(maxSpeed)
steerVehicles[-1].set_speed(speed)
steerVehicles[-1].set_up_axis_fixed(True)
return True
return False
def writeToBamFileAndExitBoid(fileName):
"""override writeToBamFileAndExit"""
for i in range(OSSteerManager.get_global_ptr().get_num_steer_vehicles()):
vehicle = OSSteerManager.get_global_ptr().get_steer_vehicle(i)
print(str(i) + "th OSSteerVehicle's settings: ")
print(vehicle.get_settings())
print(vehicle.get_flock_settings())
#
writeToBamFileAndExit(fileName)
def addPursuer(data=None):
"""adds a pursuer"""
if data == None:
return
# set vehicle's type == mp_pursuer
OSSteerManager.get_global_ptr().set_parameter_value(
OSSteerManager.STEERVEHICLE, "vehicle_type", "mp_pursuer")
# handle vehicle
handleVehicles(data)
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"map_drive")
# set vehicle's type, mass, speed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "vehicle_type",
"map_driver")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_speed",
"20.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_force",
"8.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "up_axis_fixed",
"true")
# set vehicle throwing events
valueList.clear()
valueList.add_value(
"avoid_obstacle@[email protected]:path_following@[email protected]")
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE, "thrown_events",
valueList)
#
printCreationParameters()
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"boid")
# set vehicle's type, max force, max speed, speed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "vehicle_type",
"boid")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_force",
"5.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_speed",
"10.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "speed", "3.0")
# set vehicle throwing events
valueList.clear()
valueList.add_value("avoid_obstacle@avoid_obstacle@")
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE, "thrown_events",
valueList)
#
printCreationParameters()
def getCollisionEntryFromCamera():
"""throws a ray and returns the first collision entry or nullptr"""
global app
# get steer manager
steerMgr = OSSteerManager.get_global_ptr()
# get the mouse watcher
mwatcher = app.mouseWatcherNode
if mwatcher.has_mouse():
# Get to and from pos in camera coordinates
pMouse = mwatcher.get_mouse()
#
pFrom, pTo = (LPoint3f(), LPoint3f())
if app.camLens.extrude(pMouse, pFrom, pTo):
# Transform to global coordinates
pFrom = app.render.get_relative_point(app.cam, pFrom)
pTo = app.render.get_relative_point(app.cam, pTo)
direction = (pTo - pFrom).normalized()
steerMgr.get_collision_ray().set_origin(pFrom)
steerMgr.get_collision_ray().set_direction(direction)
steerMgr.get_collision_traverser().traverse(app.render)
# check collisions
if steerMgr.get_collision_handler().get_num_entries() > 0:
# Get the closest entry
steerMgr.get_collision_handler().sort_entries()
return steerMgr.get_collision_handler().get_entry(0)
return None
def getVehicleModelAnims(meanScale, vehicleFileIdx, moveType, sceneNP, steerPlugIn,
steerVehicles, vehicleAnimCtls, pos = None):
"""get a vehicle, model and animations"""
global app, vehicleAnimFiles
# get some models, with animations, to attach to vehicles
# get the model
vehicleNP = app.loader.load_model(vehicleFile[vehicleFileIdx])
# set random scale
scale = meanScale * (1 + 0.2 * (2 * random.uniform(0.0, 1.0) - 1))
vehicleNP.set_scale(scale)
# associate an anim with a given anim control
tmpAnims = AnimControlCollection()
vehicleAnimNP = [None, None]
vehicleAnimCtls.append([None, None])
if(len(vehicleAnimFiles[vehicleFileIdx][0]) != 0) and \
(len(vehicleAnimFiles[vehicleFileIdx][1]) != 0):
# first anim -> modelAnimCtls[i][0]
vehicleAnimNP[0] = app.loader.load_model(vehicleAnimFiles[vehicleFileIdx][0])
vehicleAnimNP[0].reparent_to(vehicleNP)
auto_bind(vehicleNP.node(), tmpAnims,
PartGroup.HMF_ok_part_extra |
PartGroup.HMF_ok_anim_extra |
PartGroup.HMF_ok_wrong_root_name)
vehicleAnimCtls[-1][0] = tmpAnims.get_anim(0)
tmpAnims.clear_anims()
vehicleAnimNP[0].detach_node()
# second anim -> modelAnimCtls[i][1]
vehicleAnimNP[1] = app.loader.load_model(vehicleAnimFiles[vehicleFileIdx][1])
vehicleAnimNP[1].reparent_to(vehicleNP)
auto_bind(vehicleNP.node(), tmpAnims,
PartGroup.HMF_ok_part_extra |
PartGroup.HMF_ok_anim_extra |
PartGroup.HMF_ok_wrong_root_name)
vehicleAnimCtls[-1][1] = tmpAnims.get_anim(0)
tmpAnims.clear_anims()
vehicleAnimNP[1].detach_node()
# reparent all node paths
vehicleAnimNP[0].reparent_to(vehicleNP)
vehicleAnimNP[1].reparent_to(vehicleNP)
# set parameter for vehicle's move type (OPENSTEER or OPENSTEER_KINEMATIC)
steerMgr = OSSteerManager.get_global_ptr()
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "mov_type",
moveType)
# create the steer vehicle (attached to the reference node)
steerVehicleNP = steerMgr.create_steer_vehicle("vehicle" + str(len(steerVehicles)))
steerVehicles.append(steerVehicleNP.node())
randPos = pos
if randPos == None:
# set the position randomly
randPos = getRandomPos(sceneNP)
steerVehicleNP.set_pos(randPos)
# attach some geometry (a model) to steer vehicle
vehicleNP.reparent_to(steerVehicleNP)
# add the steer vehicle to the plug-in
steerPlugIn.add_steer_vehicle(steerVehicleNP)
def getPlayerModelAnims(name, scale, vehicleFileIdx, steerPlugIn,
steerVehicles, vehicleAnimCtls, pos):
"""get the player, model and animations"""
global app, vehicleAnimFiles
# get some models, with animations, to attach to vehicles
# get the model
vehicleNP = app.loader.load_model(vehicleFile[vehicleFileIdx])
# associate an anim with a given anim control
tmpAnims = AnimControlCollection()
vehicleAnimNP = [None, None]
vehicleAnimCtls.append([None, None])
if(len(vehicleAnimFiles[vehicleFileIdx][0]) != 0) and \
(len(vehicleAnimFiles[vehicleFileIdx][1]) != 0):
# first anim -> modelAnimCtls[i][0]
vehicleAnimNP[0] = app.loader.load_model(vehicleAnimFiles[vehicleFileIdx][0])
vehicleAnimNP[0].reparent_to(vehicleNP)
auto_bind(vehicleNP.node(), tmpAnims,
PartGroup.HMF_ok_part_extra |
PartGroup.HMF_ok_anim_extra |
PartGroup.HMF_ok_wrong_root_name)
vehicleAnimCtls[-1][0] = tmpAnims.get_anim(0)
tmpAnims.clear_anims()
vehicleAnimNP[0].detach_node()
# second anim -> modelAnimCtls[i][1]
vehicleAnimNP[1] = app.loader.load_model(vehicleAnimFiles[vehicleFileIdx][1])
vehicleAnimNP[1].reparent_to(vehicleNP)
auto_bind(vehicleNP.node(), tmpAnims,
PartGroup.HMF_ok_part_extra |
PartGroup.HMF_ok_anim_extra |
PartGroup.HMF_ok_wrong_root_name)
vehicleAnimCtls[-1][1] = tmpAnims.get_anim(0)
tmpAnims.clear_anims()
vehicleAnimNP[1].detach_node()
# reparent all node paths
vehicleAnimNP[0].reparent_to(vehicleNP)
vehicleAnimNP[1].reparent_to(vehicleNP)
#
steerMgr = OSSteerManager.get_global_ptr()
# create the steer vehicle (attached to the reference node)
# note: vehicle's move type is ignored
steerVehicleNP = steerMgr.create_steer_vehicle("PlayerVehicle")
steerVehicles.append(steerVehicleNP.node())
# set the name
steerVehicleNP.set_name(name)
# set scale
steerVehicleNP.set_scale(scale)
# set the position
steerVehicleNP.set_pos(pos)
# attach some geometry (a model) to steer vehicle
vehicleNP.reparent_to(steerVehicleNP)
# add the steer vehicle to the plug-in
steerPlugIn.add_steer_vehicle(steerVehicleNP)
# return the steerVehicleNP
return steerVehicleNP
def handleObstacles(data):
"""handle add/remove obstacles"""
global app
if data == None:
return
obstacleData = data
addObstacle = obstacleData.addObstacle
sceneNP = obstacleData.sceneNP
steerPlugIn = obstacleData.steerPlugIn
scale = obstacleData.scale
# get the collision entry, if any
entry0 = getCollisionEntryFromCamera()
if entry0:
# get the hit object
hitObject = entry0.get_into_node_path()
print("hit " + str(hitObject) + " object")
# check if we want add obstacle and
# if sceneNP is the hitObject or an ancestor thereof
if addObstacle and ((sceneNP == hitObject) or sceneNP.is_ancestor_of(hitObject)):
# the hit object is the scene: add an obstacle to the scene
# get a model as obstacle
obstacleNP = app.loader.load_model(obstacleFile)
obstacleNP.set_collide_mask(mask)
# set random scale
scale = scale * (1 + 0.2 * (2 * random.uniform(0.0, 1.0) - 1))
obstacleNP.set_scale(scale)
# set obstacle position
pos = entry0.get_surface_point(sceneNP)
obstacleNP.set_pos(sceneNP, pos)
# try to add to plug-in
if steerPlugIn.add_obstacle(obstacleNP, "box") < 0:
# something went wrong remove from scene
obstacleNP.remove_node()
return
print("added " + str(obstacleNP) + " obstacle at " +
str(obstacleNP.get_pos()))
# check if we want remove obstacle
elif not addObstacle:
# cycle through the local obstacle list
for index in range(steerPlugIn.get_num_obstacles()):
# get the obstacle's NodePath
ref = steerPlugIn.get_obstacle(index)
obstacleNP = OSSteerManager.get_global_ptr().get_obstacle_by_ref(ref)
# check if obstacleNP is the hitObject or an ancestor thereof
if (obstacleNP == hitObject) or obstacleNP.is_ancestor_of(hitObject):
# try to remove from plug-in
if not steerPlugIn.remove_obstacle(ref).is_empty():
# all ok remove from scene
print("removed " + str(obstacleNP) + " obstacle.")
obstacleNP.remove_node()
break
def writeToBamFileAndExit(fileName):
"""write scene to a file (and exit)"""
OSSteerManager.get_global_ptr().write_to_bam_file(fileName)
# # this is for testing explicit removal and destruction of all elements
steerMgr = OSSteerManager.get_global_ptr()
# remove steer vehicles from steer plug-ins
for plugInTmp in steerMgr.get_steer_plug_ins():
for vehicleTmp in plugInTmp:
# remove vehicleTmp
plugInTmp.remove_steer_vehicle(NodePath.any_path(vehicleTmp))
# destroy steer vehicles
for vehicleTmp in steerMgr.get_steer_vehicles():
# destroy vehicleTmp
steerMgr.destroy_steer_vehicle(NodePath.any_path(vehicleTmp))
# destroy steer plug-ins
for plugInTmp in steerMgr.get_steer_plug_ins():
# destroy vehicleTmp
steerMgr.destroy_steer_plug_in(NodePath.any_path(plugInTmp))
# #
#
sys.exit(0)
def loadTerrain(name, widthScale = 0.5, heightScale = 10.0):
"""load terrain stuff"""
global app, terrain, terrainRootNetPos
steerMgr = OSSteerManager.get_global_ptr()
terrain = GeoMipTerrain("terrain")
heightField = PNMImage(Filename(dataDir + "/heightfield.png"))
terrain.set_heightfield(heightField)
# sizing
environmentWidthX = (heightField.get_x_size() - 1) * widthScale
environmentWidthY = (heightField.get_y_size() - 1) * widthScale
environmentWidth = (environmentWidthX + environmentWidthY) / 2.0
terrain.get_root().set_sx(widthScale)
terrain.get_root().set_sy(widthScale)
terrain.get_root().set_sz(heightScale)
# set other terrain's properties
blockSize, minimumLevel = (64, 0)
nearPercent, farPercent = (0.1, 0.7)
terrainLODmin = min(minimumLevel, terrain.get_max_level())
flattenMode = GeoMipTerrain.AFM_off
terrain.set_block_size(blockSize)
terrain.set_near(nearPercent * environmentWidth)
terrain.set_far(farPercent * environmentWidth)
terrain.set_min_level(terrainLODmin)
terrain.set_auto_flatten(flattenMode)
# terrain texturing
textureStage0 = TextureStage("TextureStage0")
textureImage = TexturePool.load_texture(Filename("terrain.png"))
terrain.get_root().set_tex_scale(textureStage0, 1.0, 1.0)
terrain.get_root().set_texture(textureStage0, textureImage, 1)
# reparent this Terrain node path to the object node path
terrain.get_root().reparent_to(steerMgr.get_reference_node_path())
terrain.get_root().set_collide_mask(mask)
terrain.get_root().set_name(name)
# brute force generation
bruteForce = True
terrain.set_bruteforce(bruteForce)
# Generate the terrain
terrain.generate()
# check if terrain needs update or not
if not bruteForce:
# save the net pos of terrain root
terrainRootNetPos = terrain.get_root().get_net_transform().get_pos()
# Add a task to keep updating the terrain
app.taskMgr.add(terrainUpdate, "terrainUpdate", appendTask=True)
#
return terrain.get_root()
def getFlag(name):
"""load the flag"""
global app
flag = app.loader.load_model("flag_oga.egg")
flag.set_two_sided(True)
flag.set_scale(1.5)
flag.set_name(name)
flag.reparent_to(OSSteerManager.get_global_ptr().get_reference_node_path())
flagWave = app.loader.load_model("flag_oga-wave.egg")
flagWave.reparent_to(flag)
auto_bind(flag.node(), flagAnims)
flagAnims.get_anim(0).loop(True)
return flag
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"soccer")
# set vehicle throwing events
valueList.clear()
valueList.add_value("avoid_neighbor@avoid_neighbor@")
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE, "thrown_events",
valueList)
#
printCreationParameters()
def printCreationParameters():
"""print creation parameters"""
steerMgr = OSSteerManager.get_global_ptr()
#
valueList = steerMgr.get_parameter_name_list(OSSteerManager.STEERPLUGIN)
print("\n" + "OSSteerPlugIn creation parameters:")
for name in valueList:
print ("\t" + name + " = " +
steerMgr.get_parameter_value(OSSteerManager.STEERPLUGIN, name))
#
valueList = steerMgr.get_parameter_name_list(OSSteerManager.STEERVEHICLE)
print("\n" + "OSSteerVehicle creation parameters:")
for name in valueList:
print ("\t" + name + " = " +
steerMgr.get_parameter_value(OSSteerManager.STEERVEHICLE, name))
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"multiple_pursuit")
# set vehicle's max force, max speed, up axis fixed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_force",
"1.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "max_speed",
"2.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "up_axis_fixed",
"true")
#
printCreationParameters()
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 getRandomPos(modelNP):
"""return a random point on the facing upwards surface of the model"""
# collisions are made wrt render
steerMgr = OSSteerManager.get_global_ptr()
# get the bounding box of scene
modelDims, modelDeltaCenter = (LVecBase3f(), LVector3f())
# modelRadius not used
steerMgr.get_bounding_dimensions(modelNP, modelDims, modelDeltaCenter)
# throw a ray downward from a point with z = double scene's height
# and x,y randomly within the scene's (x,y) plane
# set the ray origin at double of maximum height of the model
zOrig = ((-modelDeltaCenter.get_z() + modelDims.get_z() / 2.0) + modelNP.get_z()) * 2.0
while True:
x = modelDims.get_x() * (random.uniform(0.0, 1.0) - 0.5) - modelDeltaCenter.get_x() + modelNP.get_x()
y = modelDims.get_y() * (random.uniform(0.0, 1.0) - 0.5) - modelDeltaCenter.get_y() + modelNP.get_y()
gotCollisionZ = steerMgr.get_collision_height(LPoint3f(x, y, zOrig))
if gotCollisionZ.get_first():
break
return LPoint3f(x, y, gotCollisionZ.get_second())
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set vehicle's mass, speed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "external_update",
"false")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "mass",
"2.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "speed",
"0.01")
# set vehicle throwing events
valueList.clear()
valueList.add_value("avoid_obstacle@[email protected]:"
"avoid_close_neighbor@[email protected]:"
"avoid_neighbor@[email protected]")
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE,
"thrown_events", valueList)
#
printCreationParameters()
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"low_speed_turn")
# set vehicle type, mass, speed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "vehicle_type",
"low_speed_turn")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "mass", "2.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "speed", "0.01")
# set vehicle throwing events
valueList.clear()
valueList.add_value("move@[email protected]")
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE, "thrown_events",
valueList)
#
printCreationParameters()
def setParametersBeforeCreation():
"""set parameters as strings before plug-ins/vehicles creation"""
steerMgr = OSSteerManager.get_global_ptr()
valueList = ValueList_string()
# set plug-in type
steerMgr.set_parameter_value(OSSteerManager.STEERPLUGIN, "plugin_type",
"pedestrian")
# set vehicle's type, mass, speed
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "vehicle_type",
"pedestrian")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "mass", "2.0")
steerMgr.set_parameter_value(OSSteerManager.STEERVEHICLE, "speed", "0.01")
# set vehicle throwing events
valueList.clear()
valueList.add_value(
"avoid_obstacle@[email protected]:avoid_close_neighbor@avoid_close_neighbor@"
)
steerMgr.set_parameter_values(OSSteerManager.STEERVEHICLE, "thrown_events",
valueList)
#
printCreationParameters()
global globalClock
print(plugIn.get_name() + " real time and dt: " +
str(globalClock.get_real_time()) + str(globalClock.get_dt()))
if __name__ == '__main__':
app = startFramework("'one turning'")
# # here is room for your own code
print(
"create a steer manager; set root and mask to manage 'kinematic' vehicles"
)
steerMgr = OSSteerManager(app.render, mask)
print("reparent the reference node to render")
steerMgr.get_reference_node_path().reparent_to(app.render)
print("get a sceneNP and reparent to the reference node")
sceneNP = loadPlane("SceneNP")
sceneNP.reparent_to(steerMgr.get_reference_node_path())
print("set sceneNP's collide mask")
sceneNP.set_collide_mask(mask)
print(
"create the default plug-in (attached to the reference node): 'one turning'"
)
plugInNP = steerMgr.create_steer_plug_in()
# print some help to screen
text = TextNode("Help")
text.set_text(
msg + "\n\n"
"- press \"d\" to toggle debug drawing\n"
"- press \"w\" to add 'wanderer' vehicle\n"
"- press \"p\" to add 'pursuer' vehicle\n"
"- press \"s\"/\"shift-s\" to increase/decrease last inserted vehicle's max speed\n"
"- press \"f\"/\"shift-f\" to increase/decrease last inserted vehicle's max force\n"
)
textNodePath = app.aspect2d.attach_new_node(text)
textNodePath.set_pos(-1.25, 0.0, -0.5)
textNodePath.set_scale(0.035)
# create a steer manager; set root and mask to manage 'kinematic' vehicles
steerMgr = OSSteerManager(app.render, mask)
# print creation parameters: defult values
print("\n" + "Default creation parameters:")
printCreationParameters()
# load or restore all scene stuff: if passed an argument
# try to read it from bam file
if (not len(sys.argv) > 1) or (not readFromBamFile(sys.argv[1])):
# no argument or no valid bamFile
# reparent the reference node to render
steerMgr.get_reference_node_path().reparent_to(app.render)
# get a sceneNP, naming it with "SceneNP" to ease restoring from bam
# file
sceneNP = loadTerrain("SceneNP")
text = TextNode("Help")
text.set_text(
msg + "\n\n"
"- press \"d\" to toggle debug drawing\n"
"- press \"up\"/\"left\"/\"down\"/\"right\" arrows to move the player\n"
"- press \"a\"/\"k\" to add 'opensteer'/'kinematic' vehicle\n"
"- press \"s\"/\"shift-s\" to increase/decrease last inserted vehicle's max speed\n"
"- press \"f\"/\"shift-f\" to increase/decrease last inserted vehicle's max force\n"
"- press \"t\" to toggle last inserted vehicle's wander behavior\n"
"- press \"o\"/\"shift-o\" to add/remove obstacle\n")
textNodePath = app.aspect2d.attach_new_node(text)
textNodePath.set_pos(-1.25, 0.0, 0.8)
textNodePath.set_scale(0.035)
# create a steer manager set root and mask to manage 'kinematic' vehicles
steerMgr = OSSteerManager(app.render, mask)
# print creation parameters: defult values
print("\n" + "Default creation parameters:")
printCreationParameters()
# load or restore all scene stuff: if passed an argument
# try to read it from bam file
if (not len(sys.argv) > 1) or (not readFromBamFile(sys.argv[1])):
# no argument or no valid bamFile
# reparent the reference node to render
steerMgr.get_reference_node_path().reparent_to(app.render)
# get a sceneNP, naming it with "SceneNP" to ease restoring from bam
# file
sceneNP = loadTerrain("SceneNP")
def readFromBamFile(fileName):
"""read scene from a file"""
return OSSteerManager.get_global_ptr().read_from_bam_file(fileName)
