def setup(self):
# setting up sector entry plane
self.detection_plane_ = self.attachNewNode(BulletRigidBodyNode(self.getName() + 'entry-plane'))
box_shape = BulletBoxShape(SECTOR_PLANE_SIZE/2)
box_shape.setMargin(SECTOR_COLLISION_MARGIN)
self.detection_plane_.node().addShape(box_shape)
self.detection_plane_.node().setMass(0)
self.detection_plane_.setPos(self,SECTOR_PLANE_POS)
self.detection_plane_.node().setIntoCollideMask(SECTOR_ENTERED_BITMASK)
self.physics_world_.attach(self.detection_plane_.node())
self.detection_plane_.node().clearBounds()
self.detection_plane_.reparentTo(self.getParent())
# sector constraint plane
self.constraint_plane_ = self.attachNewNode(BulletRigidBodyNode(self.getName()+ 'constraint-plane'))
self.constraint_plane_.node().addShape(BulletPlaneShape(Vec3(0,1,0),0))
self.constraint_plane_.node().setMass(0)
self.constraint_plane_.setPos(Vec3.zero())
self.constraint_plane_.setHpr(Vec3.zero())
self.constraint_plane_.node().setIntoCollideMask(BitMask32.allOff())
self.physics_world_.attach(self.constraint_plane_.node())
self.constraint_plane_.reparentTo(self.getParent())
# setting up objects
self.setupBoxes()
self.setupPlatforms()
def __initToBox__(self,name, size,mass = 0,add_visual = True):
NodePath.__init__(self,BulletRigidBodyNode(name))
self.physics_world_ = None
# size
self.size_ = size
# set collision shape
collision_shape = BulletBoxShape(self.size_/2)
collision_shape.setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
self.node().addShape(collision_shape)
self.node().setMass(mass)
self.setCollideMask(CollisionMasks.GAME_OBJECT_RIGID_BODY)
# setting bounding volume
min_point = LPoint3(-0.5*size.getX(),-0.5*size.getY(),-0.5*size.getZ())
max_point = LPoint3(0.5*size.getX(),0.5*size.getY(),0.5*size.getZ())
self.node().setBoundsType(BoundingVolume.BT_box)
self.node().setBounds(BoundingBox(min_point ,max_point ))
# Frame of reference
self.reference_np_ = None
# visual properties
if add_visual:
visual_np = GameObject.createSimpleBoxVisualNode(self,self.size_, self.getName() + '-visual')
# setting ID
GameObject.setObjectID(self, self.getName())
def _add_sidewalk2bullet(self,
lane_start,
lane_end,
middle,
radius=0.0,
direction=0):
length = norm(lane_end[0] - lane_start[0], lane_end[1] - lane_start[1])
body_node = BulletRigidBodyNode(BodyName.Sidewalk)
body_node.setKinematic(False)
body_node.setStatic(True)
side_np = self.sidewalk_node_path.attachNewNode(body_node)
shape = BulletBoxShape(Vec3(1 / 2, 1 / 2, 1 / 2))
body_node.addShape(shape)
body_node.setIntoCollideMask(self.SIDEWALK_COLLISION_MASK)
self.dynamic_nodes.append(body_node)
if radius == 0:
factor = 1
else:
if direction == 1:
factor = (1 - self.SIDEWALK_LINE_DIST / radius)
else:
factor = (1 + self.SIDEWALK_WIDTH / radius) * (
1 + self.SIDEWALK_LINE_DIST / radius)
direction_v = lane_end - lane_start
vertical_v = Vector(
(-direction_v[1], direction_v[0])) / norm(*direction_v)
middle += vertical_v * (self.SIDEWALK_WIDTH / 2 +
self.SIDEWALK_LINE_DIST)
side_np.setPos(panda_position(middle, 0))
theta = -math.atan2(direction_v[1], direction_v[0])
side_np.setQuat(
LQuaternionf(math.cos(theta / 2), 0, 0, math.sin(theta / 2)))
side_np.setScale(
length * factor, self.SIDEWALK_WIDTH,
self.SIDEWALK_THICKNESS * (1 + 0.1 * np.random.rand()))
if self.render:
side_np.setTexture(self.ts_color, self.side_texture)
self.sidewalk.instanceTo(side_np)
def __init__(self, name, game, x, y, z, pos):
self.name = name
self.game = game
self.shape = BulletBoxShape(Vec3(x, y, z))
self.node = BulletRigidBodyNode(self.name)
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(pos)
self.game.world.attachRigidBody(self.node)
self.model = self.game.loader.loadModel("models/platform.egg")
self.model.reparentTo(self.np)
self.model.setScale(x * 2, y * 2, z * 2)
self.node.setCcdMotionThreshold(1e-7)
self.node.setCcdSweptSphereRadius(0.5)
#self.node.setFriction(5)
#self.debugOff()
self.speedVec = Vec3(0, 0, 0)
self.lastPos = Vec3(self.getPos())
self.slice_able = False
def reload(self, xml):
self.playernp = render.attachNewNode(BulletRigidBodyNode('Player'))
self.playernp.node().setMass(m)
self.playernp.node().addShape(BulletBoxShape(Vec3(1, 1, 2)))
#self.playernp.node().setLinearVelocity(Vec3(vR, 0, -v1))
self.playernp.setPos(0, 0, R)
self.playernp.node().setDeactivationEnabled(False)
manager.physics.getWorld().attachRigidBody(self.playernp.node())
manager.physics.registerPreFunc("playerController", self.update)
manager.physics.registerPostFunc("playerController", self.postUpdate)
#manager.controls.registerKeyAll("Forward", "w", self.forward, self)
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('left', 'a')
inputState.watchWithModifiers('reverse', 's')
inputState.watchWithModifiers('right', 'd')
inputState.watchWithModifiers('turnLeft', 'q')
inputState.watchWithModifiers('turnRight', 'e')
self.__currentPos = Vec3(0, 0, 0)
def _explode(self):
"""Play explosion sequence of effects and sounds.
Also includes explosion physics.
"""
self._explosion.play()
self._smoke.play()
self._rb_node = BulletRigidBodyNode(self.id + "_physics")
self._rb_node.setMass(100)
self._rb_node.addShape(BulletBoxShape(Vec3(0.06, 0.1, 0.028)))
self._rb_node.deactivation_enabled = False
phys_node = self.node.attachNewNode(self._rb_node) # noqa: F821
self.model.reparentTo(phys_node)
self.model.setPos(0, 0, -0.03)
base.world.phys_mgr.attachRigidBody(self._rb_node) # noqa: F821
# boom impulse
angle = round(self.model.getH(render)) # noqa: F821
x = 0
y = 0
if angle == 0:
y = random.randint(6500, 8500)
elif angle == 90:
x = -random.randint(6500, 8500)
elif angle == -90:
x = random.randint(6500, 8500)
self._rb_node.applyForce(Vec3(x, y, random.randint(1500, 2500)),
Point3(0, -0.1, 0))
self._rb_node.applyTorque(
Vec3(
random.randint(-30, 30),
random.randint(-30, 30),
random.randint(-30, 30),
))
def genBulletCDBoxes(obstaclecmlist, name='autogen'):
"""
generate a bullet cd obj using a list of AABB boxes generated from obstaclenplist
:param obstaclenplist: the AABB box of each obstaclenp in the list will be computed and used for cd
:return: bulletrigidbody
author: weiwei
date: 20180807, osaka
"""
bulletboxesnode = BulletRigidBodyNode(name)
for obstaclecm in obstaclecmlist:
if obstaclecm.type is not "box":
raise Exception("The type of obstaclecms must be box!")
cdsolid = obstaclecm.cdcn.getSolid(0)
bulletboxshape = BulletBoxShape.makeFromSolid(cdsolid)
bulletboxesnode.addShape(
bulletboxshape,
TransformState.makeMat3(
obstaclecm.getMat().getUpper3()).setPos(obstaclecm.getPos() +
cdsolid.getCenter()))
return bulletboxesnode
def make_box(self):
# make box and attach it to render
box_geom = make_cube_geom(geom_color=(1, 0, 0, 1))
box_geom_node = GeomNode('box')
box_geom_node.addGeom(box_geom)
box_geom_node_path = self.app.render.attachNewNode(box_geom_node)
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
# 1. Make and attach a new rigid bullet node
b_mesh_np = self.app.render.attachNewNode(
BulletRigidBodyNode('bullet-node'))
# 2. add a mass and shape to the node
b_mesh_np.node().setMass(1.0)
b_mesh_np.node().addShape(shape)
# 3. not sure what this is
b_mesh_np.node().setDeactivationEnabled(False)
box_geom_node_path.reparentTo(b_mesh_np)
b_mesh_np.setPos(self.ref_node.getPos())
self.app.bullet_world.attach(b_mesh_np.node())
def doShoot(self, ccd):
# Get from/to points from mouse click
pMouse = base.mouseWatcherNode.getMouse()
pFrom = Point3()
pTo = Point3()
base.camLens.extrude(pMouse, pFrom, pTo)
pFrom = render.getRelativePoint(base.cam, pFrom)
pTo = render.getRelativePoint(base.cam, pTo)
# Calculate initial velocity
v = pTo - pFrom
v.normalize()
v *= 10000.0
# Create bullet
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
body = BulletRigidBodyNode('Bullet')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(2.0)
bodyNP.node().setLinearVelocity(v)
bodyNP.setPos(pFrom)
bodyNP.setCollideMask(BitMask32.allOn())
if ccd:
bodyNP.node().setCcdMotionThreshold(1e-7)
bodyNP.node().setCcdSweptSphereRadius(0.50)
self.world.attachRigidBody(bodyNP.node())
# Remove the bullet again after 1 second
taskMgr.doMethodLater(1,
self.doRemove,
'doRemove',
extraArgs=[bodyNP],
appendTask=True)
def do_shoot(self, ccd):
# Get from/to points from mouse click
pMouse = base.mouseWatcherNode.get_mouse()
pFrom = LPoint3()
pTo = LPoint3()
base.camLens.extrude(pMouse, pFrom, pTo)
pFrom = render.get_relative_point(base.cam, pFrom)
pTo = render.get_relative_point(base.cam, pTo)
# Calculate initial velocity
v = pTo - pFrom
v.normalize()
v *= 10000.0
# Create bullet
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
body = BulletRigidBodyNode('Bullet')
bodyNP = self.worldNP.attach_new_node(body)
bodyNP.node().add_shape(shape)
bodyNP.node().set_mass(2.0)
bodyNP.node().set_linear_velocity(v)
bodyNP.set_pos(pFrom)
bodyNP.set_collide_mask(BitMask32.all_on())
if ccd:
bodyNP.node().set_ccd_motion_threshold(1e-7)
bodyNP.node().set_ccd_swept_sphere_radius(0.50)
self.world.attach(bodyNP.node())
# Remove the bullet again after 1 second
taskMgr.do_method_later(1,
self.do_remove,
'doRemove',
extraArgs=[bodyNP],
appendTask=True)
def load(self):
if self.autoPhysBox:
min = Point3(0)
max = Point3(0)
self.getUseableBounds(min, max)
min -= Point3(0.1, 0.1, 0.1)
max += Point3(0.1, 0.1, 0.1)
center = PhysicsUtils.centerFromMinMax(min, max)
extents = PhysicsUtils.extentsFromMinMax(min, max)
shape = BulletBoxShape(extents)
# Use the box as a trigger and collision geometry.
if self.hasPhysGeom:
bodyNode = BulletGhostNode('useableObject')
else:
bodyNode = BulletRigidBodyNode('useableObject')
bodyNode.setKinematic(True)
bodyNode.addShape(shape, TransformState.makePos(center))
self.setupPhysics(bodyNode)
if self.bodyNP:
self.bodyNP.setPythonTag('useableObject', self)
def genBulletCDBoxList(obstaclecmlist, name='autogen'):
"""
generate a bullet cd obj using the AABB boundaries stored in obstacle collision models
:param obstaclecmlist: a list of collision models (cmshare doesnt work!)
:return: bulletrigidbody
author: weiwei
date: 20190313, toyonaka
"""
bulletboxlistnode = BulletRigidBodyNode(name)
for obstaclecm in obstaclecmlist:
if obstaclecm.type is not "box":
raise Exception(
"Wrong obstaclecm type! Box is required to genBulletCDBox.")
cdsolid = obstaclecm.cdcn.getSolid(0)
bulletboxshape = BulletBoxShape.makeFromSolid(cdsolid)
rotmatpd4 = obstaclecm.getMat(base.render)
bulletboxlistnode.addShape(
bulletboxshape,
TransformState.makeMat(rotmatpd4).setPos(
rotmatpd4.xformPoint(cdsolid.getCenter())))
return bulletboxlistnode
def genBulletCDBox(obstaclecm, name='autogen'):
"""
generate a bullet cd obj using the AABB boundary of a obstacle collision model
:param obstaclecm: a collision model
:return: bulletrigidbody
author: weiwei
date: 20190313, toyonaka
"""
if obstaclecm.type is not "box":
raise Exception(
"Wrong obstaclecm type! Box is required to genBulletCDBox.")
bulletboxnode = BulletRigidBodyNode(name)
cdsolid = obstaclecm.cdcn.getSolid(0)
bulletboxshape = BulletBoxShape.makeFromSolid(cdsolid)
rotmat4_pd = obstaclecm.getMat(base.render)
bulletboxnode.addShape(
bulletboxshape,
TransformState.makeMat(rotmat4_pd).setPos(
rotmat4_pd.xformPoint(cdsolid.getCenter())))
return bulletboxnode
def load(self, physName='useableObject'):
if self.autoPhysBox:
min = Point3(0)
max = Point3(0)
self.getUseableBounds(min, max)
min -= Point3(0.1, 0.1, 0.1)
max += Point3(0.1, 0.1, 0.1)
extents = PhysicsUtils.extentsFromMinMax(min, max)
shape = BulletBoxShape(extents)
# Use the box as a trigger and collision geometry.
if self.hasPhysGeom:
bodyNode = BulletGhostNode(physName)
else:
bodyNode = BulletRigidBodyNode(physName)
bodyNode.setKinematic(True)
if not self.underneathSelf:
center = PhysicsUtils.centerFromMinMax(min, max)
bodyNode.addShape(shape, TransformState.makePos(center))
else:
bodyNode.addShape(shape)
self.setupPhysics(bodyNode)
else:
for np in self.findAllMatches("**/+BulletRigidBodyNode"):
if (np.getCollideMask() & CIGlobals.WallGroup) != 0:
np.setCollideMask(np.getCollideMask()
| CIGlobals.UseableGroup)
self.bodyNP = np
self.bodyNode = np.node()
if self.bodyNP:
self.bodyNP.setPythonTag('useableObject', self)
def load(self):
DistributedEntityAI.load(self)
self.setHpr(self.cEntity.getAngles())
self.setPos(self.cEntity.getOrigin())
self.setModel("phase_9/models/cogHQ/square_stomper.bam")
self.setModelScale(self.scale)
self.getModelNP().find("**/shaft").setSy(self.height / 16.0)
self.optimizeModel()
box = BulletBoxShape((self.scale[1], 1.0, self.scale[0]))
gh = BulletGhostNode('trigger_hurt')
gh.addShape(box, TransformState.makePos((0, -0.5, 0)))
self.floorColl = self.getModelNP().attachNewNode(gh)
self.floorColl.setCollideMask(CIGlobals.WallGroup
| CIGlobals.CharacterGroup)
self.enableModelCollisions()
for bNP in self.getModelNP().findAllMatches("**/+BulletRigidBodyNode"):
bNP.setSurfaceProp("metal")
self.b_setEntityState(self.StateUp)
def __init__(self,name,size,right_side_ledge = True, left_side_ledge = True):
'''
Creates a box shaped platform
SimplePlatform(String name, Vec3 size, Bool right_side_ledge, Bool left_side_ledge)
'''
# creating a static box
collision_shape = BulletBoxShape(size/2)
collision_shape.setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
bt_node = BulletRigidBodyNode(name)
bt_node.addShape(collision_shape)
bt_node.setMass(0)
# calling super constructor
super(SimplePlatform,self).__init__(bt_node)
self.size_ = size
self.setCollideMask(CollisionMasks.PLATFORM_RIGID_BODY)
visual_np = GameObject.createSimpleBoxVisualNode(self,self.size_, self.getName() + '-visual')
visual_np.setTexture(SimplePlatform.__DEFAULT_TEXTURE__,1)
# addding ledges
ledge_size = Vec3(SimplePlatform.__LEDGE_BOX_SIDE_LENGHT__,self.getSize().getY(),SimplePlatform.__LEDGE_BOX_SIDE_LENGHT__)
self.left_ledge_ = Ledge(name + 'left-ledge',False,ledge_size) if left_side_ledge else None
self.right_ledge_ = Ledge(name + 'right-ledge',True,ledge_size) if right_side_ledge else None
self.ledges_ = []
# ledge placement
half_width = 0.5*size.getX()
half_height = 0.5*size.getZ()
half_depth = 0.5*size.getY()
if left_side_ledge:
self.left_ledge_.reparentTo(self)
self.left_ledge_.setPos(Vec3(-half_width ,0,half_height))
self.ledges_.append(self.left_ledge_)
if right_side_ledge:
self.right_ledge_.reparentTo(self)
self.right_ledge_.setPos(Vec3(half_width ,0,half_height))
self.ledges_.append(self.right_ledge_)
# creating platform floor node
thickness = SimplePlatform.__PERIMETER_THICKNESS__
self.floor_ghost_np_ = self.attachNewNode(BulletGhostNode(name + 'floor'))
self.floor_ghost_np_.node().addShape(BulletBoxShape(Vec3((size.getX()-2*thickness)*0.5,size.getY()*0.5 ,thickness*0.5) ))
#self.floor_ghost_np_.node().getShape(0).setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
self.floor_ghost_np_.setPosHpr(self,Vec3(0,0,(size.getZ() - thickness)*0.5),Vec3.zero())
self.floor_ghost_np_.node().setIntoCollideMask(CollisionMasks.SURFACE)
# creating platform right wall node
self.rightwall_ghost_np_ = self.attachNewNode(BulletGhostNode(name + 'right-wall'))
self.rightwall_ghost_np_.node().addShape(BulletBoxShape(Vec3(thickness*0.5,size.getY()*0.5,size.getZ()*0.5 )))
#self.rightwall_ghost_np_.node().getShape(0).setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
self.rightwall_ghost_np_.setPosHpr(self,Vec3((size.getX() - thickness)*0.5,0,0),Vec3.zero())
self.rightwall_ghost_np_.node().setIntoCollideMask(CollisionMasks.WALL)
# creating platform left wall node
self.leftwall_ghost_np_ = self.attachNewNode(BulletGhostNode(name + 'left-wall'))
self.leftwall_ghost_np_.node().addShape(BulletBoxShape(Vec3(thickness*0.5,size.getY()*0.5,size.getZ()*0.5 )))
#self.leftwall_ghost_np_.node().getShape(0).setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
self.leftwall_ghost_np_.setPosHpr(self,Vec3(-(size.getX() - thickness)*0.5,0,0),Vec3.zero())
self.leftwall_ghost_np_.node().setIntoCollideMask(CollisionMasks.WALL)
# storing all ghost nodes in subclass list
self.bt_children_nodes_ = [self.leftwall_ghost_np_, self.rightwall_ghost_np_, self.floor_ghost_np_]
# setting id
self.setObjectID(self.getName())
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showNormals(True)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box (dynamic)
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(0, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.boxNP = np # For applying force & torque
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
# Heightfield (static)
height = 8.0
img = PNMImage(Filename('models/elevation.png'))
shape = BulletHeightfieldShape(img, height, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.hf = np.node() # To enable/disable debug visualisation
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(img)
self.terrain.setBlockSize(32)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNP = self.terrain.getRoot()
rootNP.reparentTo(render)
rootNP.setSz(8.0)
offset = img.getXSize() / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -height / 2.0)
self.terrain.generate()