def createPlayerCollisions(self):
""" create a collision solid and ray for the player """
cn = CollisionNode('player')
cn.setFromCollideMask(COLLISIONMASKS['geometry'])
cn.setIntoCollideMask(COLLISIONMASKS['portals'] | COLLISIONMASKS['exit'] | COLLISIONMASKS['lava'])
cn.addSolid(CollisionSphere(0,0,0,3))
solid = self.node.attachNewNode(cn)
# TODO : find a way to remove that, it's the cause of the little
# "push me left" effect we see sometime when exiting a portal
self.base.cTrav.addCollider(solid,self.base.pusher)
self.base.pusher.addCollider(solid,self.node, self.base.drive.node())
# init players floor collisions
ray = CollisionRay()
ray.setOrigin(0,0,-.2)
ray.setDirection(0,0,-1)
cn = CollisionNode('playerRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.nodeGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init players ceil collisions
ray = CollisionRay()
ray.setOrigin(0,0,.2)
ray.setDirection(0,0,1)
cn = CollisionNode('playerUpRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.ceilGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.ceilGroundHandler)
def addRalph(self, pos):
ralphStartPos = pos
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def CreateCollisionGeoms(self):
self.collisionNode = self.pNode.attachNewNode('CollisionNode')
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("legsPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 0.35, 0.3))
collisionGeom.node().setFromCollideMask(Globals.ITEM_BITMASK)
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
#collisionGeom.show()
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_LEG)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("bodyPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 0.9, 0.3))
collisionGeom.node().setFromCollideMask(BitMask32.allOff())
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
#collisionGeom.show()
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_BODY)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("headPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 1.45, 0.35))
collisionGeom.node().setFromCollideMask(BitMask32.allOff())
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_HEAD)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
def initializeSmartCameraCollisions(self):
if self.initialized:
return
self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav')
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode)
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.camCollisionQueue = CollisionHandlerQueue()
self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue)
self.ccSphere = CollisionSphere(0, 0, 0, 1)
self.ccSphereNode = CollisionNode('ccSphereNode')
self.ccSphereNode.addSolid(self.ccSphere)
self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode)
self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode.setIntoCollideMask(BitMask32.allOff())
self.camPusher = CollisionHandlerPusher()
self.camPusher.addCollider(self.ccSphereNodePath, base.camera)
self.camPusher.setCenter(base.localAvatar)
self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav')
self.ccSphere2 = self.ccSphere
self.ccSphereNode2 = CollisionNode('ccSphereNode2')
self.ccSphereNode2.addSolid(self.ccSphere2)
self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2)
self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff())
self.camPusher2 = CollisionHandlerPusher()
self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2)
self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera)
self.camPusher2.setCenter(base.localAvatar)
self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode')
self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRayNode = CollisionNode('ccRayNode')
self.ccRayNode.addSolid(self.ccRay)
self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode)
self.ccRayBitMask = CIGlobals.FloorBitmask
self.ccRayNode.setFromCollideMask(self.ccRayBitMask)
self.ccRayNode.setIntoCollideMask(BitMask32.allOff())
self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor')
self.camFloorCollisionQueue = CollisionHandlerQueue()
self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue)
self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor')
self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRay2Node = CollisionNode('ccRay2Node')
self.ccRay2Node.addSolid(self.ccRay2)
self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node)
self.ccRay2BitMask = CIGlobals.FloorBitmask
self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask)
self.ccRay2Node.setIntoCollideMask(BitMask32.allOff())
self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode')
self.camFloorCollisionBroadcaster = CollisionHandlerFloor()
self.camFloorCollisionBroadcaster.setInPattern('on-floor')
self.camFloorCollisionBroadcaster.setOutPattern('off-floor')
self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath)
self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster)
self.initialized = True
def setUpCamera(self):
""" puts camera behind the player in third person """
# Set up the camera
# Adding the camera to actor is a simple way to keep the camera locked
# in behind actor regardless of actor's movement.
base.camera.reparentTo(self.actor)
# We don't actually want to point the camera at actors's feet.
# This value will serve as a vertical offset so we can look over the actor
self.cameraTargetHeight = 0.5
# How far should the camera be from the actor
self.cameraDistance = 10
# Initialize the pitch of the camera
self.cameraPitch = 45
# The mouse moves rotates the camera so lets get rid of the cursor
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
#set up FOV
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
# A CollisionRay beginning above the camera and going down toward the
# ground is used to detect camera collisions and the height of the
# camera above the ground. A ray may hit the terrain, or it may hit a
# rock or a tree. If it hits the terrain, we detect the camera's
# height. If it hits anything else, the camera is in an illegal
# position.
"""
TODO:: This will need to be changed to bullet
"""
self.cTrav = CollisionTraverser()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0,0,1000)
self.groundRay.setDirection(0,0,-1)
self.groundCol = CollisionNode('camRay')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setFromCollideMask(BitMask32.bit(1))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = base.camera.attachNewNode(self.groundCol)
self.groundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.groundColNp, self.groundHandler)
# We will detect anything obstructing the camera's view of the player
self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(0,5,5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.actor.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
self.chassisNode = BulletRigidBodyNode('Vehicle')
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.setPosHpr(self.pos[0], self.pos[1], self.pos[2], self.pos[3], self.pos[4], self.pos[5])
# self.chassisNP.setPos(-5.34744, 114.773, 6)
# self.chassisNP.setPos(49.2167, 64.7968, 10)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
# np.node().setCcdSweptSphereRadius(1.0)
# np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
self.carNP = loader.loadModel('models/swiftstar-chassis')
tex = loader.loadTexture("models/tex/Futuristic_Car_C.jpg")
self.carNP.setTexture(tex)
self.carNP.setScale(1, 1, .9)
self.carNP.setCollideMask(BitMask32.allOn())
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/swiftstar-fr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, 1), True, np)
# Left front wheel
np = loader.loadModel('models/swiftstar-fl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, 1), True, np)
# Right rear wheel
np = loader.loadModel('models/swiftstar-rr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1.2, -2, .8), False, np)
# Left rear wheel
np = loader.loadModel('models/swiftstar-rl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1.2, -2, .8), False, np)
def setup_interactiongeometries(self):
"""
set up collision rays, spheres, and planes for mouse manipulation
:return: None
author: weiwei
date: 20161110
"""
# create a trackball ray and set its bitmask to 8
# the trackball ray must be a subnode of cam since we will
# transform the clicked point (in the view of the cam) to the world coordinate system
# using the ray
self.tracker_cn = CollisionNode("tracker")
self.tracker_ray = CollisionRay()
self.tracker_cn.addSolid(self.tracker_ray)
self.tracker_cn.setFromCollideMask(BitMask32.bit(8))
self.tracker_cn.setIntoCollideMask(BitMask32.allOff())
self.tracker_np = self.base.cam.attachNewNode(self.tracker_cn)
# create an inverted collision sphere and puts it into a collision node
# its bitmask is set to 8, and it will be the only collidable object at bit 8
self.trackball_cn = CollisionNode("trackball")
self.trackball_cn.addSolid(
CollisionSphere(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1],
self.lookatpos_pdv3[2], self.camdist))
self.trackball_cn.setFromCollideMask(BitMask32.allOff())
self.trackball_cn.setIntoCollideMask(BitMask32.bit(8))
self.trackball_np = self.base.render.attachNewNode(self.trackball_cn)
# self.trackball_np.show()
# This creates a collision plane for mouse track
self.trackplane_cn = CollisionNode("trackplane")
self.trackplane_cn.addSolid(
CollisionPlane(
Plane(
Point3(-self.base.cam.getMat().getRow3(1)),
Point3(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1],
0.0))))
self.trackplane_cn.setFromCollideMask(BitMask32.allOff())
self.trackplane_cn.setIntoCollideMask(BitMask32.bit(8))
self.trackplane_np = self.base.render.attachNewNode(self.trackplane_cn)
# self.trackplane_np.show()
# creates a traverser to do collision testing
self.ctrav = CollisionTraverser()
# creates a queue type handler to receive the collision event info
self.chandler = CollisionHandlerQueue()
# register the ray as a collider with the traverser,
# and register the handler queue as the handler to be used for the collisions.
self.ctrav.addCollider(self.tracker_np, self.chandler)
# create a pickerray
self.picker_cn = CollisionNode('picker')
self.picker_ray = CollisionRay()
self.picker_cn.addSolid(self.picker_ray)
self.picker_cn.setFromCollideMask(BitMask32.bit(7))
self.picker_cn.setIntoCollideMask(BitMask32.allOff())
self.picker_np = self.base.cam.attachNewNode(self.picker_cn)
self.ctrav.addCollider(self.picker_np, self.chandler)
def createWallCollider(self):
self.__colliderSideWalls = self.__board.attachNewNode(CollisionNode('boardSideWallsCNode'))
point1, point2, point3, point4 = self.getWallVertices('left')
self.__colliderSideWalls.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
point1, point2, point3, point4 = self.getWallVertices('right')
self.__colliderSideWalls.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
self.__colliderSideWalls.node().setIntoCollideMask(self.WALL_MASK)
self.__colliderSideWalls.node().setFromCollideMask(BitMask32.allOff())
self.__colliderBackWall = self.__board.attachNewNode(CollisionNode('boardBackWallCNode'))
point1, point2, point3, point4 = self.getWallVertices('back')
self.__colliderBackWall.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
self.__colliderBackWall.node().setIntoCollideMask(self.WALL_MASK)
self.__colliderBackWall.node().setFromCollideMask(BitMask32.allOff())
def createCollider(self):
self.__wallCollider = self.__ball.attachNewNode(CollisionNode('ballWallCNode'))
radius = self.getBallRadius()
self.__wallCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__wallCollider.node().setFromCollideMask(Board.WALL_MASK)
self.__wallCollider.node().setIntoCollideMask(BitMask32.allOff())
self.__blockCollider = self.__ball.attachNewNode(CollisionNode('ballBlockCNode'))
self.__blockCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__blockCollider.node().setFromCollideMask(Block.BLOCK_MASK)
self.__blockCollider.node().setIntoCollideMask(BitMask32.allOff())
self.__paddleCollider = self.__ball.attachNewNode(CollisionNode('ballPaddleCNode'))
self.__paddleCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__paddleCollider.node().setFromCollideMask(Paddle.PADDLE_MASK)
self.__paddleCollider.node().setIntoCollideMask(BitMask32.allOff())
def startPhysics(self):
#self.actorNode = ActorNode("playerPhysicsControler")
#base.physicsMgr.attachPhysicalNode(self.actorNode)
#self.actorNode.getPhysicsObject().setMass(self.player_mass)
#self.mainNode = render.attachNewNode(self.actorNode)
self.mainNode = render.attachNewNode("CharacterColliders")
self.reparentTo(self.mainNode)
charCollisions = self.mainNode.attachNewNode(
CollisionNode(self.char_collision_name))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0, self.player_height/4.0))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0*3.05, self.player_height/4.0))
charCollisions.node().addSolid(
CollisionSphere(0, 0, self.player_height / 2.0,
self.player_height / 4.0))
charCollisions.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000
if self.show_collisions:
charCollisions.show()
self.pusher.addCollider(charCollisions, self.mainNode)
base.cTrav.addCollider(charCollisions, self.pusher)
charFFootCollisions = self.attachNewNode(CollisionNode("floor_ray"))
charFFootCollisions.node().addSolid(CollisionRay(0, 0, 0.5, 0, 0, -1))
#charFFootCollisions.node().addSolid(CollisionSegment((0, 0, 0.2), (0, 0, -1)))
charFFootCollisions.node().setIntoCollideMask(BitMask32.allOff())
charFFootCollisions.node().setFromCollideMask(
BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
charFFootCollisions.show()
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(charFFootCollisions, self.mainNode)
#self.floor_handler.setOffset(0)
self.floor_handler.setMaxVelocity(5)
base.cTrav.addCollider(charFFootCollisions, self.floor_handler)
self.accept("{}-in".format(self.char_collision_name),
self.checkCharCollisions)
self.raytest_segment = CollisionSegment(0, 1)
self.raytest_np = render.attachNewNode(CollisionNode("testRay"))
self.raytest_np.node().addSolid(self.raytest_segment)
self.raytest_np.node().setIntoCollideMask(BitMask32.allOff())
self.raytest_np.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
self.raytest_np.show()
self.raytest_queue = CollisionHandlerQueue()
self.rayCTrav.addCollider(self.raytest_np, self.raytest_queue)
def __init__(self, render, objid, start_pos, gameclient):
self.client = gameclient
self.id = objid
self.motion_controller = None
self.is_player = False
# state management
self.isAnimating = False
self.state = state.IDLE
self.render = render # scene graph root
# create the panda3d actor: just load a default model for now
self.actor = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.actor.reparentTo(render)
self.actor.setScale(.2)
self.actor.setPos(start_pos)
# prepare collision handling
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0, 0, 1000)
self.GroundRay.setDirection(0, 0, -1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def setupCollisions(self):
#make a collision traverser, set it to default
base.cTrav = CollisionTraverser()
#self.cHandler = CollisionHandlerEvent()
self.cHandler = CollisionHandlerPusher()
#set the pattern for the event sent on collision
# "%in" is substituted with the name of the into object
#self.cHandler.setInPattern("hit-%in")
cSphere = CollisionSphere((0,0,0), 10) #panda is scaled way down!
cNode = CollisionNode("vtol")
cNode.addSolid(cSphere)
#panda is *only* a from object
cNode.setFromCollideMask(BitMask32.bit(0))
cNode.setIntoCollideMask(BitMask32.allOff())
cNodePath = self.vtol.attachNewNode(cNode)
# cNodePath.show()
base.cTrav.addCollider(cNodePath, self.cHandler)
self.cHandler.addCollider(cNodePath, self.vtol)
#for b1 in self.house2:
cTube1 = CollisionTube((-0.4,3,3), (-0.4,3,20), 6.8)
cTube2 = CollisionTube((-0.4,-3,3), (-0.4,-3,20), 6.8)
cNode = CollisionNode("models/houses/building")
cNode.addSolid(cTube1)
cNode.addSolid(cTube2)
cNodePath = self.house2.attachNewNode(cNode)
cTube1 = CollisionTube((-0.4,3,3), (-0.4,3,20), 6.8)
cTube2 = CollisionTube((-0.4,-3,3), (-0.4,-3,20), 6.8)
cNode = CollisionNode("models/houses/church")
cNode.addSolid(cTube1)
cNode.addSolid(cTube2)
cNodePath = self.house1.attachNewNode(cNode)
def placeCollectibles(self):
self.placeCol = render.attachNewNode("Collectible-Placeholder")
self.placeCol.setPos(0,0,0)
# Add the health items to the placeCol node
for i in range(self.numObjects):
# Load in the health item model
self.collect = loader.loadModel("models/trex")
self.collect.setPos(0,0,0)
self.collect.reparentTo(self.placeCol)
self.collect.setScale(0.1)
self.tex3= loader.loadTexture("models/Face.jpg")
self.collect.setTexture(self.tex3,1)
self.placeItem(self.collect)
# Add spherical collision detection
colSphere = CollisionSphere(0,0,0,1)
sphereNode = CollisionNode('colSphere')
sphereNode.addSolid(colSphere)
sphereNode.setFromCollideMask(BitMask32.allOff())
sphereNode.setIntoCollideMask(BitMask32.bit(0))
sphereNp = self.collect.attachNewNode(sphereNode)
sphereColHandler = CollisionHandlerQueue()
def placeHealthItems(self):
self.placeholder = render.attachNewNode("HealthItem-Placeholder")
self.placeholder.setPos(0,0,0)
# Add the health items to the placeholder node
for i in range(5):
# Load in the health item model
self.foodchick = loader.loadModel("models/chicken2")
self.foodchick.setPos(0,0,0)
self.foodchick.reparentTo(self.placeholder)
#self.tex2=self.setTexture("models/orange.jpg")
#self.foodchick.setTexture(self.tex2,1)
#self.tex2= loader.loadTexture("models/orange.jpg")
#self.foodchick.setTexture(self.tex1,1)
self.placeItem(self.foodchick)
# Add spherical collision detection
healthSphere = CollisionSphere(0,0,0,1)
sphereNode = CollisionNode('healthSphere')
sphereNode.addSolid(healthSphere)
sphereNode.setFromCollideMask(BitMask32.allOff())
sphereNode.setIntoCollideMask(BitMask32.bit(0))
sphereNp = self.foodchick.attachNewNode(sphereNode)
sphereColHandler = CollisionHandlerQueue()
def setupCoins2(self):
# display coins = 0
textN = TextNode('coin-score')
textN.setText(str("Coins: " + str(self.coinsCollected2)))
textN.setSlant(0.1)
textNodePath = self.aspect2d.attachNewNode(textN)
textNodePath.setPos(0, 0.95, 0.9)
textNodePath.setScale(0.08)
randNum = random.sample(range(0, 1500, 200), 6)
# coins
for i in range(6):
randX = random.uniform(-3.0, 3.2)
randY = float(randNum[i])
shape = BulletSphereShape(0.3)
coinNode = BulletGhostNode('Coin-' + str(i))
coinNode.addShape(shape)
np = self.render.attachNewNode(coinNode)
np.setCollideMask(BitMask32.allOff())
np.setPos(randX, randY, 2)
# Adding sphere model
sphereNp = loader.loadModel('models/smiley.egg')
sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
sphereNp.setTexture(sphereNp_tex, 1)
sphereNp.reparentTo(np)
sphereNp.setScale(0.45)
sphereNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()
self.world2.attachGhost(coinNode)
self.coins2.append(coinNode)
print "node name:" + str(coinNode.getName())
def __init__(self, render, objid, start_pos, gameclient):
self.client = gameclient
self.id = objid
self.motion_controller = None
self.is_player = False
# state management
self.isAnimating = False
self.state = state.IDLE
self.render = render # scene graph root
# create the panda3d actor: just load a default model for now
self.actor = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.actor.reparentTo(render)
self.actor.setScale(.2)
self.actor.setPos(start_pos)
# prepare collision handling
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0,0,1000)
self.GroundRay.setDirection(0,0,-1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def InitCollision(self):
#
ray = CollisionRay(0, 0, 5, 0, 0, -1)
self.HeroC = self.Hero.attachNewNode(CollisionNode('cnode'))
self.HeroC.node().addSolid(ray)
self.HeroC.show()
self.HeroC.node().setIntoCollideMask(BitMask32.allOff())
self.HeroC.node().setFromCollideMask(BitMask32.bit(2))
plane1 = CollisionPolygon(Point3(-10, -10, 0.1), Point3(-2, -10, 0.1),
Point3(-2, 10, 0.1), Point3(-10, 10, 0.1))
plane2 = CollisionPolygon(Point3(-2, -10, 0.1), Point3(1, -10, -0.9),
Point3(1, 10, -0.9), Point3(-2, 10, 0.1))
plane3 = CollisionPolygon(Point3(1, -10, -0.9), Point3(5, -10, -0.9),
Point3(5, 10, -0.9), Point3(1, 10, -0.9))
self.LevelCP = self.dummy.attachNewNode(CollisionNode('cnodeLevel'))
self.LevelCP.node().addSolid(plane1)
self.LevelCP.node().addSolid(plane2)
self.LevelCP.node().addSolid(plane3)
self.LevelCP.show()
self.LevelCP.node().setIntoCollideMask(BitMask32.bit(2))
self.Handlernya = CollisionHandlerQueue()
# self.HandlerCS = CollisionHandlerEvent()
# self.HandlerCS.addInPattern('into-g')
traverser.addCollider(self.HeroC, self.Handlernya)
# traverser.addCollider(self.HeroCS,self.HandlerCS)
traverser.traverse(render)
def setupCollisions(self):
self.collTrav = CollisionTraverser()
# rapid collisions detected using below plus FLUID pos
self.collTrav.setRespectPrevTransform(True)
self.playerGroundSphere = CollisionSphere(0, 1.5, -1.5, 1.5)
self.playerGroundCol = CollisionNode('playerSphere')
self.playerGroundCol.addSolid(self.playerGroundSphere)
# bitmasks
self.playerGroundCol.setFromCollideMask(BitMask32.bit(0))
self.playerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.world.setGroundMask(BitMask32.bit(0))
self.world.setWaterMask(BitMask32.bit(0))
# and done
self.playerGroundColNp = self.player.attach(self.playerGroundCol)
self.playerGroundHandler = CollisionHandlerQueue()
self.collTrav.addCollider(self.playerGroundColNp,
self.playerGroundHandler)
# DEBUG as per video:
if (self.debug == True):
self.playerGroundColNp.show()
self.collTrav.showCollisions(self.render)
def __init__(self, fulcrum, terrain):
TerrainCamera.__init__(self)
self.terrain = terrain
self.fulcrum = fulcrum
# in behind Ralph regardless of ralph's movement.
self.camNode.reparentTo(fulcrum)
# How far should the camera be from Ralph
self.cameraDistance = 30
# Initialize the pitch of the camera
self.cameraPitch = 10
self.focus = self.fulcrum.attachNewNode("focus")
self.maxDistance = 500.0
self.minDistance = 2
self.maxPitch = 80
self.minPitch = -70
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.cameraRay = CollisionSegment(self.fulcrum.getPos(), (0, 5, 5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.fulcrum.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def placeItem(self, item):
# Add ground collision detector to the health item
self.collectGroundRay = CollisionRay()
self.collectGroundRay.setOrigin(0,0,300)
self.collectGroundRay.setDirection(0,0,-1)
self.collectGroundCol = CollisionNode('colRay')
self.collectGroundCol.addSolid(self.collectGroundRay)
self.collectGroundCol.setFromCollideMask(BitMask32.bit(0))
self.collectGroundCol.setIntoCollideMask(BitMask32.allOff())
self.collectGroundColNp = item.attachNewNode(self.collectGroundCol)
self.collectGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.collectGroundColNp, self.collectGroundHandler)
placed = False;
while placed == False:
# re-randomize position
item.setPos(-random.randint(0,140),-random.randint(0,40),0)
base.cTrav.traverse(render)
# Get Z position from terrain collision
entries = []
for j in range(self.collectGroundHandler.getNumEntries()):
entry = self.collectGroundHandler.getEntry(j)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
item.setZ(entries[0].getSurfacePoint(render).getZ()+1)
placed = True
# remove placement collider
self.collectGroundColNp.removeNode()
def SetupCollision(self, collisionString):
radius = 0.2
collisionGeom = self.itemNode.attachNewNode(CollisionNode('itemCollision'))
collisionGeom.node().addSolid(CollisionSphere(0, 0, radius/2.0, radius))
collisionGeom.node().setFromCollideMask(BitMask32.allOff())
collisionGeom.node().setIntoCollideMask(Globals.ITEM_BITMASK)
collisionGeom.node().setTag('item', collisionString)
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 setObjectGoal(self, name, flag):
if flag:
self.getObject(name).setCollideMask(BitMask32(0x002),
BitMask32(0x002))
else:
self.getObject(name).setCollideMask(BitMask32.allOff(),
BitMask32(0x002))
def __init__(self, render, player):
self.username = player.getUsername()
self.isMoving = False
self.render = render
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
#self.actor = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"})
self.actor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.actor.reparentTo(render)
self.actor.setScale(0.002, 0.002, 0.002)
self.actor.setPos(player.getX(), player.getY(), player.getZ())
self.actor.setH(player.getH())
#self.actor.loop("walk")
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0,0,1000)
self.GroundRay.setDirection(0,0,-1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def __init__(self, widget, axis):
NodePath.__init__(self, "transformWidgetAxis")
self.reparentTo(widget)
self.widget = widget
vec = Vec3(0)
vec[axis] = 1.0
self.direction = vec
self.defaultColor = Vec4(vec[0], vec[1], vec[2], 1.0)
self.rolloverColor = Vec4(vec + 0.5, 1.0)
self.downColor = Vec4(vec - 0.5, 1.0)
self.lookAt(vec)
self.setTransparency(1)
self.axisIdx = axis
box = CollisionBox(*self.getClickBox())
cnode = CollisionNode("pickBox")
cnode.addSolid(box)
cnode.setIntoCollideMask(LEGlobals.ManipulatorMask)
cnode.setFromCollideMask(BitMask32.allOff())
self.pickNp = self.attachNewNode(cnode)
self.pickNp.setPythonTag("widgetAxis", self)
self.state = Ready
self.setState(Ready)
def generate(self):
data = CIGlobals.SuitBodyData[self.SUIT]
type = data[0]
team = data[1]
self.team = team
self.level = 12
self.suit = type
Suit.generate(self, SuitBank.MrHollywood, 0, hideFirst=False)
self.suit = type
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def __init__(self, fulcrum, terrain):
TerrainCamera.__init__(self)
self.terrain = terrain
self.fulcrum = fulcrum
# in behind Ralph regardless of ralph's movement.
self.camNode.reparentTo(fulcrum)
# How far should the camera be from Ralph
self.cameraDistance = 30
# Initialize the pitch of the camera
self.cameraPitch = 10
self.focus = self.fulcrum.attachNewNode("focus")
self.maxDistance = 500.0
self.minDistance = 2
self.maxPitch = 80
self.minPitch = -70
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.cameraRay = CollisionSegment(self.fulcrum.getPos(), (0, 5, 5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.fulcrum.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def getObjectsInBox(self, mins, maxs):
objects = []
# Create a one-off collision box, traverser, and queue to test against all MapObjects
box = CollisionBox(mins, maxs)
node = CollisionNode("selectToolCollBox")
node.addSolid(box)
node.setFromCollideMask(self.Mask)
node.setIntoCollideMask(BitMask32.allOff())
boxNp = self.doc.render.attachNewNode(node)
queue = CollisionHandlerQueue()
base.clickTraverse(boxNp, queue)
queue.sortEntries()
key = self.Key
entries = queue.getEntries()
# Select every MapObject our box intersected with
for entry in entries:
np = entry.getIntoNodePath().findNetPythonTag(key)
if not np.isEmpty():
obj = np.getPythonTag(key)
actual = self.getActualObject(obj, entry)
if isinstance(actual, list):
for a in actual:
if not any(a == x[0] for x in objects):
objects.append((a, entry))
else:
objects.append((actual, entry))
boxNp.removeNode()
return objects
def generate(self):
self.level = 12
self.maxHealth = 200
self.health = 200
Suit.generate(self,
FactorySneakGuardSuit.SUIT,
FactorySneakGuardSuit.VARIANT,
hideFirst=False)
self.setName(self.suitPlan.getName(), None)
self.cleanupPropeller()
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4. / 3.))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def createHitCollider(self, blockId):
self._hitCollider = self._block.attachNewNode(CollisionNode('blockCNode' + str(blockId)))
minPos, maxPos = self._block.getTightBounds()
sizes = (maxPos - minPos)/(2*self.SCALE)
self._hitCollider.node().addSolid(CollisionBox(LPoint3f(0, 0, 0), sizes.getX(), sizes.getY(), sizes.getZ()))
self._hitCollider.node().setIntoCollideMask(self.BLOCK_MASK)
self._hitCollider.node().setFromCollideMask(BitMask32.allOff())
def createHood(self, loadStorage = 1, AI = 0):
if loadStorage:
loadDNAFile(self.dnaStore, "phase_4/dna/storage.dna")
loadDNAFile(self.dnaStore, "phase_4/dna/storage_TT.dna")
loadDNAFile(self.dnaStore, "phase_4/dna/storage_TT_sz.dna")
loadDNAFile(self.dnaStore, "phase_5/dna/storage_town.dna")
loadDNAFile(self.dnaStore, "phase_5/dna/storage_TT_town.dna")
self.node = loadDNAFile(self.dnaStore, "phase_4/dna/toontown_central_sz.dna")
if self.node.getNumParents() == 1:
self.geom = NodePath(self.node.getParent(0))
self.geom.reparentTo(hidden)
else:
self.geom = hidden.attachNewNode(self.node)
gsg = base.win.getGsg()
if gsg:
self.geom.prepareScene(gsg)
self.geom.setName('toontown_central')
self.geom.find('**/hill').setTransparency(TransparencyAttrib.MBinary, 1)
self.createSky("tt")
base.hoodBGM = base.loadMusic("phase_4/audio/bgm/TC_nbrhood.ogg")
base.hoodBGM.setVolume(0.25)
base.hoodBGM.setLoop(True)
base.hoodBGM.play()
self.clerk_node = render.attach_new_node('clerk_node')
self.clerk_node.set_pos(-80, -85.57, 0.5)
self.clerk_node.set_h(165.07)
self.geom.find('**/toontown_central').setCollideMask(BitMask32.allOff())
self.geom.find('**/coll_sidewalk').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/collision_1').node().setIntoCollideMask(CIGlobals.WallBitmask)
self.geom.find('**/coll_mainFoolr').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/left_ear').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/right_ear').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_bridge_floor').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_bridge').node().setIntoCollideMask(CIGlobals.WallBitmask)
self.geom.find('**/coll_r_stair').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_l_stair_2').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_l_stairend_1').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_r_satirend_1').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_plaza').node().setIntoCollideMask(CIGlobals.FloorBitmask)
self.geom.find('**/coll_hedges').node().setIntoCollideMask(CIGlobals.WallBitmask)
self.coll_list = ['coll_sidewalk', 'collision_1', 'coll_mainFoolr', 'left_ear', 'right_ear', 'coll_bridge_floor', 'coll_bridge', 'coll_r_stair',
'coll_l_stair_2', 'coll_l_stairend_1', 'coll_r_stairend_1', 'coll_plaza', 'coll_hedges']
self.geom.reparentTo(render)
self.telescope = Actor(self.geom.find('**/*animated_prop_HQTelescopeAnimatedProp*'),
{"chan": "phase_3.5/models/props/HQ_telescope-chan.bam"}, copy=0)
self.telescope.reparentTo(self.geom.find('**/*toon_landmark_hqTT*'))
self.createLights(1, 1, 1)
#if AI:
# self.createTrolley()
taskMgr.add(self.telescopeTask, "telescopeTask")
self.isLoaded = 1
messenger.send("loadedHood")
def createCollider(self):
self.__ballCollider = self.__paddle.attachNewNode(CollisionNode('paddleBallCNode'))
minimum, maximum = self.__paddle.getTightBounds()
center = (maximum - minimum)/2
center = LPoint3f(center/self.SCALE)
self.__ballCollider.node().addSolid(CollisionTube(-center[0]*0.85, 0, 0, center[0]*0.85, 0, 0, 1))
self.__ballCollider.node().setIntoCollideMask(self.PADDLE_MASK)
self.__ballCollider.node().setFromCollideMask(BitMask32.allOff())
self.__wallCollider = self.__paddle.attachNewNode(CollisionNode('paddleWallCNode'))
self.__wallCollider.node().addSolid(CollisionSphere(0, 0, 0, max(center)))
self.__wallCollider.node().setIntoCollideMask(BitMask32.allOff())
self.__wallCollider.node().setFromCollideMask(Board.WALL_MASK)
self.__gameEngine.setColliderHandler(self.__ballCollider)
self.__gameEngine.setColliderHandler(self.__wallCollider)
self.__gameEngine.defineIntoCollisionEventHandling('paddleWallCNode', 'boardSideWallsCNode', self.collideEvent)
def __init__(self):
# значение шага перемещения клавиатурой
self.key_step = 0.2
# значение шага поворота мышкой
self.mouse_step = 0.2
# координаты центра экрана
self.x_center = base.win.getXSize() // 2
self.y_center = base.win.getYSize() // 2
# перемещаем указатель мышки в центр экрана
base.win.movePointer(0, self.x_center, self.y_center)
# отключаем стандартное управление мышкой
base.disableMouse()
# устанавливаем поле зрения объектива
base.camLens.setFov(80)
# устанавливаем ближайшую границу отрисовки
base.camLens.setNear(0.2)
# устанавливаем текущие значения ориентации камеры
self.heading = 0
self.pitch = 0
# запускаем задачу контроля камеры
taskMgr.doMethodLater(0.02, self.controlCamera, "camera-task")
# регистрируем на нажатие клавиши "Esc"
# событие закрытия приложения
base.accept("escape", base.userExit)
# устанавливаем клавиши управления перемещением камеры
# словарь, хранящий флаги нажатия клавиш
self.keys = dict()
# заполняем словарь
for key in ['a', 'd', 'w', 's', 'q', 'e']:
# создаём запись в словаре
self.keys[key] = 0
# регистрируем событие на нажатие клавиши
base.accept(key, self.setKey, [key, 1])
# регистрируем событие на отжатие клавиши
base.accept(key + '-up', self.setKey, [key, 0])
# создание обходчика столкновений
self.traverser = CollisionTraverser()
# очередь обработки столкновений
self.collisQueue = CollisionHandlerQueue()
# узел для сферы столкновений
self.collisNode = CollisionNode('CameraSphere')
# устанавливаем маску проверки столкновений ОТ
self.collisNode.setFromCollideMask(BitMask32.bit(1))
# сбрасываем маску проверки столкновений ДО
self.collisNode.setIntoCollideMask(BitMask32.allOff())
# создайте сферу столкновения
# ...
# и прикрепите к созданному ранее узлу self.collisNode
# ...
# закрепляем узел на камере
self.collisCamNode = base.camera.attachNewNode(self.collisNode)
# уведомляем обходчик о новом «объекте ОТ»
self.traverser.addCollider(self.collisCamNode, self.collisQueue)
def __init__(self):
self.pNode = render.attachNewNode('playerRoot') # The root node of the player
self.eyeHeight = 1.5 # The z height of the camera
self.selectedBlock = 0
self.adjacentBlock = 0
self.selectedPlayer = None
self.playerState = PlayerState(self)
self.inputBuffer = InputBuffer()
self.currentItem = None
self.itemModels = {}
self.playerModel = None
# The bounding box of the player for collision with environment geometry
self.boundingBoxCenterNode = self.pNode.attachNewNode('bboxCenter')
self.boundingBoxCenterNode.setPos(0, 0, 0.9)
self.boundingBox = BoundingBox(self.boundingBoxCenterNode, [0.2, 0.2, 0.9])
self.animFSM = PlayerAnimationFSM(self)
self.animFSM.request('Idle')
self.camNode = self.pNode.attachNewNode('cam') # The position of the player's eyes
self.camNode.setPos(0, 0, self.eyeHeight)
self.playerParent = self.pNode.attachNewNode('playerParent')
# Change this back so items follow player turning
#self.itemNode = self.playerParent.attachNewNode('3rdPersonItem')
self.itemNode = self.pNode.attachNewNode('3rdPersonItem')
self.itemNode.setPos(0, 0, 1.2)
self.camItemNode = self.camNode.attachNewNode('1stPersonItem')
# Node for name text
self.nameText = None
self.nameNode = self.pNode.attachNewNode('NameNode')
self.nameNode.setPos(0, 0, 1.97)
self.lookingRayNode = self.pNode.attachNewNode('lookingRayNode')
self.lookingRayNode.setPos(0, 0, self.eyeHeight)
lookingSeg = CollisionSegment(0, 0, 0, 0, 100, 0)
self.lookingRay = self.lookingRayNode.attachNewNode(CollisionNode('lookingRay'))
self.lookingRay.node().addSolid(lookingSeg)
self.lookingRay.node().setFromCollideMask(Globals.BLOCK_PICKER_BITMASK | Globals.PLAYER_BITMASK)
self.lookingRay.node().setIntoCollideMask(BitMask32.allOff())
self.lookingRayCollisionEntry = None
self.pickerCollisionHandler = CollisionHandlerQueue()
self.pickerTraverser = CollisionTraverser('pickerTraverser')
self.pickerTraverser.addCollider(self.lookingRay, self.pickerCollisionHandler)
if(not Settings.IS_SERVER):
self.selectionGeom = SelectionGeom()
else:
self.selectionGeom = None
self.CreateCollisionGeoms()
self.LoadModels()
def setupCollision(self):
self.sphere = self.model.attachNewNode(CollisionNode('range'))
self.sphere.node().addSolid(CollisionSphere(0, 0, 0, self.range))
self.sphere.node().setFromCollideMask(BitMask32(2))
self.sphere.node().setIntoCollideMask(BitMask32.allOff())
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.sphere, self.cHandler)
def initCollisionRay(self, originZ, dirZ):
ray = CollisionRay(0,0,originZ,0,0,dirZ)
collNode = CollisionNode('playerRay')
collNode.addSolid(ray)
collNode.setFromCollideMask(BitMask32.bit(1))
collNode.setIntoCollideMask(BitMask32.allOff())
collRayNP = self.playerNode.attachNewNode(collNode)
collRayNP.show()
return collRayNP
def setupCollision(self):
self.sphere = self.model.attachNewNode( CollisionNode('range') )
self.sphere.node().addSolid( CollisionSphere(0, 0, 0, self.range) )
self.sphere.node().setFromCollideMask( BitMask32(2) )
self.sphere.node().setIntoCollideMask(BitMask32.allOff())
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.sphere, self.cHandler)
def startPhysics(self):
#self.actorNode = ActorNode("playerPhysicsControler")
#base.physicsMgr.attachPhysicalNode(self.actorNode)
#self.actorNode.getPhysicsObject().setMass(self.player_mass)
#self.mainNode = render.attachNewNode(self.actorNode)
self.mainNode = render.attachNewNode("CharacterColliders")
self.reparentTo(self.mainNode)
charCollisions = self.mainNode.attachNewNode(CollisionNode(self.char_collision_name))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0, self.player_height/4.0))
#charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/4.0*3.05, self.player_height/4.0))
charCollisions.node().addSolid(CollisionSphere(0, 0, self.player_height/2.0, self.player_height/4.0))
charCollisions.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000
if self.show_collisions:
charCollisions.show()
self.pusher.addCollider(charCollisions, self.mainNode)
base.cTrav.addCollider(charCollisions, self.pusher)
charFFootCollisions = self.attachNewNode(CollisionNode("floor_ray"))
charFFootCollisions.node().addSolid(CollisionRay(0, 0, 0.5, 0, 0, -1))
#charFFootCollisions.node().addSolid(CollisionSegment((0, 0, 0.2), (0, 0, -1)))
charFFootCollisions.node().setIntoCollideMask(BitMask32.allOff())
charFFootCollisions.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
charFFootCollisions.show()
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(charFFootCollisions, self.mainNode)
#self.floor_handler.setOffset(0)
self.floor_handler.setMaxVelocity(5)
base.cTrav.addCollider(charFFootCollisions, self.floor_handler)
self.accept("{}-in".format(self.char_collision_name), self.checkCharCollisions)
self.raytest_segment = CollisionSegment(0, 1)
self.raytest_np = render.attachNewNode(CollisionNode("testRay"))
self.raytest_np.node().addSolid(self.raytest_segment)
self.raytest_np.node().setIntoCollideMask(BitMask32.allOff())
self.raytest_np.node().setFromCollideMask(BitMask32(0x7f)) # 0111 1111
if self.show_collisions:
self.raytest_np.show()
self.raytest_queue = CollisionHandlerQueue()
self.rayCTrav.addCollider(self.raytest_np, self.raytest_queue)
def __init__(self):
try:
self.__initialized
return
except:
self.__initialized = 1
NodePath.__init__(self, hidden.attachNewNode('PositionExaminer'))
self.cRay = CollisionRay(0.0, 0.0, 6.0, 0.0, 0.0, -1.0)
self.cRayNode = CollisionNode('cRayNode')
self.cRayNode.addSolid(self.cRay)
self.cRayNodePath = self.attachNewNode(self.cRayNode)
self.cRayNodePath.hide()
self.cRayBitMask = CIGlobals.FloorBitmask
self.cRayNode.setFromCollideMask(self.cRayBitMask)
self.cRayNode.setIntoCollideMask(BitMask32.allOff())
self.cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.5)
self.cSphereNode = CollisionNode('cSphereNode')
self.cSphereNode.addSolid(self.cSphere)
self.cSphereNodePath = self.attachNewNode(self.cSphereNode)
self.cSphereNodePath.hide()
self.cSphereBitMask = CIGlobals.WallBitmask
self.cSphereNode.setFromCollideMask(self.cSphereBitMask)
self.cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = self.attachNewNode(self.ccLineNode)
self.ccLineNodePath.hide()
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.cRayTrav = CollisionTraverser('PositionExaminer.cRayTrav')
self.cRayTrav.setRespectPrevTransform(False)
self.cRayQueue = CollisionHandlerQueue()
self.cRayTrav.addCollider(self.cRayNodePath, self.cRayQueue)
self.cSphereTrav = CollisionTraverser('PositionExaminer.cSphereTrav')
self.cSphereTrav.setRespectPrevTransform(False)
self.cSphereQueue = CollisionHandlerQueue()
self.cSphereTrav.addCollider(self.cSphereNodePath, self.cSphereQueue)
self.ccLineTrav = CollisionTraverser('PositionExaminer.ccLineTrav')
self.ccLineTrav.setRespectPrevTransform(False)
self.ccLineQueue = CollisionHandlerQueue()
self.ccLineTrav.addCollider(self.ccLineNodePath, self.ccLineQueue)
def collisionInit(self):
# Kollisionserkennung, um auf dem Boden zu laufen. Der Collisionray
# erkennt die Hoehe des Gelaendes und wenn ein Objekt da ist, wird
# die Bewegung als illegal gewertet.
self.cTrav = CollisionTraverser()
self.spielerGroundRay = CollisionRay()
self.spielerGroundRay.setOrigin(0, 0, 1000)
self.spielerGroundRay.setDirection(0, 0, -1)
self.spielerGroundCol = CollisionNode('spielerRay')
self.spielerGroundCol.addSolid(self.spielerGroundRay)
self.spielerGroundCol.setFromCollideMask(BitMask32.bit(0))
self.spielerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.spielerGroundColNp = self.spieler.actor.attachNewNode(
self.spielerGroundCol)
self.spielerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.spielerGroundColNp,
self.spielerGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
self.gegnerGroundRay = CollisionRay()
self.gegnerGroundRay.setOrigin(0, 0, 1000)
self.gegnerGroundRay.setDirection(0, 0, -1)
self.gegnerGroundCol = CollisionNode('gegnerRay')
self.gegnerGroundCol.addSolid(self.gegnerGroundRay)
self.gegnerGroundCol.setFromCollideMask(BitMask32.bit(0))
self.gegnerGroundCol.setIntoCollideMask(BitMask32.allOff())
self.gegnerGroundColNp = self.gegner.actor.attachNewNode(
self.gegnerGroundCol)
self.gegnerGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.gegnerGroundColNp,
self.gegnerGroundHandler)
def __init__(self):
print("TerrainTest object created")
self.make_traverser_handler()
self.tm = TerrainManager(16, 16)
self.down = 0
self.PCs = {}
#self.make_actor()
self.char = Character("pandabuddy")
self.pc = self.char.panda_actor
self.make_actor_collisions(self.pc)
#self.make_test_capsule()
self.tm.get_terrain(0, 0).terrain.getRoot().setTag('myObjectTag', '1')
#self.tm.get_terrain(0, 0).terrain.getRoot().setIntoCollideMask(BitMask32.bit(0))
#col_t = CollisionNode("col_t")
#col_t.addSolid(CollisionPolygon(self.tm.get_terrain(0, 0).terrain.getRoot()))
#CollisionPolygon(self.tm.get_terrain(0, 0).terrain.getRoot())
#base.cTrav.addCollider(self.tm.get_terrain(0, 0).terrain.getRoot(), base.mchandler)
#pusher = CollisionHandlerPusher()
#pusher.addCollider(self.collision_node, self.char.boxc)
#base.cTrav.addCollider(self.collision_node, pusher)
#base.cTrav.addCollider(self.collision_node, base.mchandler)
cp = CollisionPlane(LPlane((0, 0, 1), (0, 0, 0)))
#self.planeANP = render.attachNewNode(ActorNode('p actor'))
planeNP = base.render.attachNewNode(CollisionNode('planecnode'))
#planeNP = self.planeANP.attachNewNode(CollisionNode('planecnode'))
self.accept('into-planecnode', self.hanev)
self.accept('pcol-again-planecnode', self.hanev)
planeNP.node().addSolid(cp)
planeNP.show()
planeNP.setScale(100, 100, 100)
planeNP.node().setIntoCollideMask(BitMask32.bit(0))
planeNP.node().setFromCollideMask(BitMask32.allOff())
planeNP.setPos(0, 0, -100)
#base.mchandler.addCollider(planeNP, self.planeANP)
#base.cTrav.addCollider(planeNP, base.mchandler)
#base.physicsMgr.attachPhysicalNode(self.planeANP.node())
base.cTrav.addCollider(self.char.boxc, base.mchandler)
base.cTrav.setRespectPrevTransform(True)
#base.mchandler.addCollider(self.collision_node, self.char.panda_actor)
#base.mchandler.addCollider(self.collision_node, self.char.boxc)
#base.mchandler.addCollider(self.char.boxc, self.collision_node)
Globals.g_task_manager.add(self.move, "moveTask", priority=-100)
self.task1 = Task(self.gravity)
Globals.g_task_manager.add(self.task1,
"gravityTask",
extraArgs=[self.task1, self.pc])
def __init__(self, model = "cube_nocol", texture = "lava", pos = (0,0,0), scale = (1,1,1), cubetype = "A"):
super(LavaCube, self).__init__(model, texture, pos, scale)
cn = CollisionNode('lava')
cn.setFromCollideMask(COLLISIONMASKS['lava'])
cn.setIntoCollideMask(BitMask32.allOff())
np = self.node.attachNewNode(cn)
cn.addSolid(CollisionSphere(0,0,0,1.1))
h = CollisionHandlerEvent()
h.addInPattern('%fn-into-%in')
h.addOutPattern('%fn-outof-%in')
base.cTrav.addCollider(np, h)
def createPortalCollisions(self):
# Enter the portals
cn = CollisionNode('bluePortal')
cn.setFromCollideMask(COLLISIONMASKS['portals'])
cn.setIntoCollideMask(BitMask32.allOff())
np = self.bluePortal.attachNewNode(cn)
cn.addSolid(CollisionSphere(0,0,0,2))
h = CollisionHandlerEvent()
h.addInPattern('%fn-into-%in')
h.addOutPattern('%fn-outof-%in')
self.base.cTrav.addCollider(np, h)
cn = CollisionNode('orangePortal')
cn.setFromCollideMask(COLLISIONMASKS['portals'])
cn.setIntoCollideMask(BitMask32.allOff())
np = self.orangePortal.attachNewNode(cn)
cn.addSolid(CollisionSphere(0,0,0,2))
h = CollisionHandlerEvent()
h.addInPattern('%fn-into-%in')
h.addOutPattern('%fn-outof-%in')
self.base.cTrav.addCollider(np, h)
def addCollisionOnMainChar(self):
self.mainCharGroundRay = CollisionRay()
self.mainCharGroundRay.setOrigin(0,0,1000)
self.mainCharGroundRay.setDirection(0,0,-1)
self.mainCharGroundCol = CollisionNode('mainChar')
self.mainCharGroundCol.addSolid(self.mainCharGroundRay)
self.mainCharGroundCol.setFromCollideMask(BitMask32.bit(0))
self.mainCharGroundCol.setIntoCollideMask(BitMask32.allOff())
self.mainCharGroundColNp = self.mainChar.attachNewNode(self.mainCharGroundCol)
self.mainCharGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.mainCharGroundColNp, self.mainCharGroundHandler)
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def addCollisionOnCam(self):
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def __init__(self, name):
self.name = name
self.cell_x = 0
self.cell_y = 0
self.vel = LPoint3(0, 0, 0)
self.c_node = base.render.attachNewNode(
self.name+"_camera_node")
self.panda_actor = Actor("models/panda-model", {"walk": "models/panda-walk4"})
self.panda_actor.setScale(0.05, 0.05, 0.05)
self.p_node = NodePath(self.name+"_phys_node")
self.p_node.reparentTo(render)
self.an = ActorNode("panda-phys")
self.anp = self.p_node.attachNewNode(self.an)
base.enableParticles()
base.physicsMgr.attachPhysicalNode(self.an)
self.panda_actor.reparentTo(self.anp)
gravityFN=ForceNode('world-forces')
gravityFNP=render.attachNewNode(gravityFN)
#gravityForce=LinearVectorForce(0,0,-9.81) #gravity acceleration
self.gravityForce=LinearVectorForce(0,0,-9.81)
gravityFN.addForce(self.gravityForce)
base.physicsMgr.addLinearForce(self.gravityForce)
self.c_node.reparentTo(self.panda_actor)
self.c_node.setCompass()
#self.panda_actor.reparentTo(base.render)
base.camera.reparentTo(self.c_node)
self.box = loader.loadModel("box.egg")
self.box.setScale(100, 100, 100)
self.box.setPos(-180, 0, 0)
self.boxc = self.box.find("**/Cube")
self.boxc.node().setIntoCollideMask(BitMask32.bit(0))
self.boxc.node().setFromCollideMask(BitMask32.allOff())
self.ban = ActorNode("box-phys")
base.physicsMgr.attachPhysicalNode(self.ban)
self.bp_node = NodePath(self.name+"_phys_node2")
self.bp_node.reparentTo(render)
self.banp = self.bp_node.attachNewNode(self.ban)
self.box.reparentTo(self.banp)
self.boxc.show()
def createMouseCollisions(self):
# Fire the portals
firingNode = CollisionNode('mouseRay')
firingNP = self.base.camera.attachNewNode(firingNode)
firingNode.setFromCollideMask(COLLISIONMASKS['geometry'])
firingNode.setIntoCollideMask(BitMask32.allOff())
firingRay = CollisionRay()
firingRay.setOrigin(0,0,0)
firingRay.setDirection(0,1,0)
firingNode.addSolid(firingRay)
self.firingHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(firingNP, self.firingHandler)
def genSuccession(self, axis, distance, direction=None):
axis_index = (self.axis_index_dic[axis])
col_index = (self.axis_index_dic[axis] + 1) % len(self.axis_index_dic)
row_index = (self.axis_index_dic[axis] + 2) % len(self.axis_index_dic)
ast_location = []
for ast_column in range(
self.field_expanse[col_index][0],
self.field_expanse[col_index][1] +
self.succession_interval[col_index],
self.succession_interval[col_index]):
for ast_row in range(
self.field_expanse[row_index][0],
self.field_expanse[row_index][1] +
self.succession_interval[row_index],
self.succession_interval[row_index]):
ast_location = [0, 0, 0]
ast_location[axis_index] = distance
ast_location[col_index] = ast_column
ast_location[row_index] = ast_row
model_ref = choice(Asteroid.ASTEROID_MODELS)
asteroid = Asteroid(loader.loadModel(model_ref.modelPath),
ast_location, self.deviation_factor, 1, .1)
bound = asteroid.objectNP.getBounds()
bound_center = bound.getCenter()
bound_radius = bound.getRadius()
asteroidSphere = CollisionSphere(
bound_center[0] - asteroid.objectNP.getX(),
bound_center[1] - asteroid.objectNP.getY(),
bound_center[2] - asteroid.objectNP.getZ(),
bound_radius * model_ref.radialScale)
asteroidSphereNode = CollisionNode(Asteroid.COLLISION_NAME)
asteroidSphereNode.addSolid(asteroidSphere)
asteroidSphereNode.setFromCollideMask(BitMask32.allOff())
asteroidSphereNode.setIntoCollideMask(BitMask32.bit(0))
pandaBodySphereNodepath = asteroid.objectNP.attachNewNode(
asteroidSphereNode)
asteroid.orient()
self.asteroids.append(asteroid)
def addCollisionSphere(self, radius):
"""Create a collision sphere and adds it to the node's tree.
The sphere is centered at the center of the object.
"""
center = self.getBounds().getCenter()
collisionSphere = CollisionSphere(center, radius)
collisionNode = CollisionNode(self.name + '_collision_node')
collisionNode.addSolid(collisionSphere)
self.collider = self.actor.attachNewNode(collisionNode)
self.model.setCollideMask(BitMask32.allOff())
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def create(self):
self.mPickerTraverser = CollisionTraverser()
self.mCollisionQue = CollisionHandlerQueue()
self.mPickRay = CollisionRay()
self.mPickRay.setOrigin(base.camera.getPos(base.render))
self.mPickRay.setDirection(
base.render.getRelativeVector(base.camera, Vec3(0, 1, 0)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode(self.nodeName)
self.mPickNode.addSolid(self.mPickRay)
#Attach that node to the camera since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = base.camera.attachNewNode(self.mPickNode)
#we'll use what panda calls the "from" node. This is reall a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
self.mPickNode.setFromCollideMask(BitMask32(1))
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQue)
#Setup 2D picker
self.mPickerTraverser2D = CollisionTraverser()
self.mCollisionQue2D = CollisionHandlerQueue()
self.mPickNode2D = CollisionNode('2D PickNode')
self.mPickNode2D.setFromCollideMask(BitMask32(1))
self.mPickNode2D.setIntoCollideMask(BitMask32.allOff())
self.mPick2DNP = base.camera2d.attachNewNode(self.mPickNode2D)
self.mPickRay2D = CollisionRay()
self.mPickNode2D.addSolid(self.mPickRay2D)
self.mPickerTraverser2D.addCollider(self.mPick2DNP,
self.mCollisionQue2D)
if self.showCollisions:
self.mPickerTraverser.showCollisions(base.render)
self.mPickerTraverser2D.showCollisions(base.aspect2d)
def __init__(self, _heightField):
texture = loader.loadTexture("ground_tex.png")
self.zScale = 45
self.terrain = GeoMipTerrain("BasicTerrain")
self.terrain.setHeightfield(_heightField)
# Dynamic settings?
self.terrain.setBlockSize(16)
self.terrain.setNear(20)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
# Settings
self.terrain.getRoot().setSz(self.zScale)
self.terrain.getRoot().setTexture(texture)
self.terrain.getRoot().reparentTo(render)
self.terrain.generate()
self.terrainSize = (self.terrain.heightfield().getReadXSize(), self.terrain.heightfield().getReadYSize())
print "Terrain Size:", self.terrainSize
taskMgr.add(self.terrainTask, "TerrainTask")
self.skydome = loader.loadModel("Skydome")
self.skydome.setDepthTest(False)
self.skydome.setAttrib(CullBinAttrib.make("skydomeBin", 1000))
self.skydome.reparentTo(camera)
self.skydome.setScale(2)
self.skydome.setPos(0, 0, -0.5)
self.skydome.setCollideMask(BitMask32.allOff())
taskMgr.add(self.skydomeTask, "paperplanet_skydome")
# Add some fancy fog
self.fog = Fog("Fog Name")
self.fog.setColor(0.4,0.2,0.3)
self.fog.setExpDensity(0.015)
render.setFog(self.fog)
# Some Test light
dlight = DirectionalLight("dlight")
dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
# Add basic blacksmith hut
tmp = loader.loadModel("blacksmith_hut")
tmp.reparentTo(render)
tmp.setPos(164.054, 340.92, 11.3384)
def __setup_collision(self):
#Colisao
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 5)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.__modelo.attachNewNode(
self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setup_shadow_ray(self, shadow_node, mat):
ray = CollisionRay(0.0, 0.0, CollisionHandlerRayStart, 0.0, 0.0, -1.0)
ray_node = CollisionNode('ray_node')
ray_node.add_solid(ray)
self.ray_np = shadow_node.attach_new_node(ray_node)
self.ray_np.node().set_from_collide_mask(CIGlobals.FloorBitmask)
self.ray_np.node().set_into_collide_mask(BitMask32.allOff())
floor_offset = 0.025
lifter = CollisionHandlerFloor()
lifter.set_offset(floor_offset)
lifter.set_reach(4.0)
lifter.add_collider(self.ray_np, shadow_node)
if not mat:
base.cTrav.add_collider(self.ray_np, lifter)
def setupCaptureSphere(self, parent):
if not self.newEventSphereNodePath:
newEventSphere = CollisionSphere(1447, -2363, 0, 1300)
newEventSphere.setTangible(0)
newEventSphereName = self.uniqueName('shipCapture')
newEventSphereNode = CollisionNode(newEventSphereName)
newEventSphereNode.setFromCollideMask(BitMask32.allOff())
newEventSphereNode.setIntoCollideMask(
PiratesGlobals.ShipCollideBitmask)
newEventSphereNode.addSolid(newEventSphere)
self.newEventSphereName = newEventSphereName
self.newEventSphereNodePath = parent.attachNewNode(
newEventSphereNode)
self.acceptOnce('enter' + newEventSphereName,
self.handleShipCapture)
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
