def __init__(self, name, char_rig): from pandac.PandaModules import CollisionNode, CollisionRay, CollisionSphere self.name = name self.char_rig = char_rig self.actor = Actor('models/robot3', {'run': 'models/robot3-run'}) self.actor.setPlayRate(2.0, 'run') self.actor.reparentTo(self.char_rig) self.actor.setCompass() self.actor.setCollideMask(0) self.actor_from_floor = self.actor.attachNewNode( CollisionNode('blockchar_floor')) self.actor_from_floor.node().addSolid( CollisionRay(0, 0, 0.25, 0, 0, -10)) self.actor_from_floor.node().setCollideMask(0) self.actor_from_floor.node().setFromCollideMask(FLOOR_MASK) self.actor_from_obstacle = self.actor.attachNewNode( CollisionNode('blockchar_obstacle')) self.actor_from_obstacle.node().addSolid( CollisionSphere(0, 0, 0.35, 0.35)) self.actor_from_obstacle.node().setCollideMask(0) self.actor_from_obstacle.node().setFromCollideMask(OBSTACLE_MASK) self.actor_from_zone = self.actor.attachNewNode( CollisionNode('blockchar_zone')) self.actor_from_zone.node().addSolid(CollisionSphere(0, 0, 0.55, 0.55)) self.actor_from_zone.node().setCollideMask(0) self.actor_from_zone.node().setFromCollideMask(ZONE_MASK) self.move_forward = False self.move_left = False self.move_backward = False self.move_right = False self.moving = False self.spinning = False self.move_prev_time = None # Based on a jogging speed of 6mph self.move_speed = 2.7 # m/s
def __init__(self, mainClass): base.cTrav = CollisionTraverser('world') # collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode = CollisionNode('mouse ray CollisionNode') pickerNP = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) # base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays', 'ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.tileSelected = (0, 0) self.unitSelected = None self.buildingSelected = None self.tempJob = None self.accept("mouse1", self.mouseClick1, [mainClass]) self.accept("mouse3", self.mouseClick3, [mainClass]) taskMgr.add(self.rayUpdate, "Mouse checking")
def leftClick(self): self.mouse1Down = True #Collision traversal pickerNode = CollisionNode('mouseRay') pickerNP = base.camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) myTraverser = CollisionTraverser() myHandler = CollisionHandlerQueue() myTraverser.addCollider(pickerNP, myHandler) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if myHandler.getNumEntries() > 0: # This is so we get the closest object myHandler.sortEntries() pickedObj = myHandler.getEntry(0).getIntoNodePath() objTag = pickedObj.findNetTag('mouseCollisionTag').getTag( 'mouseCollisionTag') if objTag and len(objTag) > 0: messenger.send('object_click', [objTag]) pickerNP.remove()
def __init__(self, *args, **kwargs): p3d.SingleTask.__init__(self, *args, **kwargs) self.fromCollideMask = kwargs.pop('fromCollideMask', None) self.node = None self.collEntry = None # Create collision nodes self.collTrav = CollisionTraverser() #self.collTrav.showCollisions( render ) self.collHandler = CollisionHandlerQueue() self.pickerRay = CollisionRay() # Create collision ray pickerNode = CollisionNode(self.name) pickerNode.addSolid(self.pickerRay) pickerNode.setIntoCollideMask(BitMask32.allOff()) pickerNp = self.camera.attachNewNode(pickerNode) self.collTrav.addCollider(pickerNp, self.collHandler) # Create collision mask for the ray if one is specified if self.fromCollideMask is not None: pickerNode.setFromCollideMask(self.fromCollideMask) # Bind mouse button events eventNames = ['mouse1', 'control-mouse1', 'mouse1-up'] for eventName in eventNames: self.accept(eventName, self.FireEvent, [eventName])
def makeNodeLocator(self, environment): meshNode = CollisionNode("NavMeshNodeLocator") meshNode.setFromCollideMask(BitMask32.allOff()) meshNode.setIntoCollideMask(OTPGlobals.PathFindingBitmask) self.polyHashToPID = {} for pId in self.polyToAngles: vertCount = 0 corners = [] for angle in self.polyToAngles[pId]: if angle != 180: # It's a corner corners.append(vertCount) vertCount += 1 # XXX this code only works for square nodes at present # Unfortunately we can only make triangle or square CollisionPolygons on the fly assert len(corners) == 4 #import pdb #pdb.set_trace() verts = [] for vert in corners: verts.append( (self.vertexCoords[self.polyToVerts[pId][vert]][0], self.vertexCoords[self.polyToVerts[pId][vert]][1], 0)) #import pdb #pdb.set_trace() poly = CollisionPolygon(verts[0], verts[1], verts[2], verts[3]) assert poly not in self.polyHashToPID self.polyHashToPID[poly] = pId meshNode.addSolid(poly) ray = CollisionRay() ray.setDirection(0, 0, -1) ray.setOrigin(0, 0, 0) rayNode = CollisionNode("NavMeshRay") rayNode.setFromCollideMask(OTPGlobals.PathFindingBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) rayNode.addSolid(ray) self.meshNodePath = environment.attachNewNode(meshNode) self.rayNodePath = environment.attachNewNode(rayNode) self.meshNodePath.setTwoSided(True) self.chq = CollisionHandlerQueue() self.traverser = CollisionTraverser() self.traverser.addCollider(self.rayNodePath, self.chq)
def addCogGroundCollision(self, cog=None, ent=None): if ent == None: ent = cog.getCog() collGround = ent.attachNewNode(CollisionNode('coll_ground')) collGround.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1)) collGround.node().setIntoCollideMask(BitMask32.allOff()) collGround.node().setFromCollideMask(Globals.WallBitmask) collHdlF.addCollider(collGround, ent) base.cTrav.addCollider(collGround, collHdlF)
def __init__(self): self.line_dir = NodePath() base.cTrav = CollisionTraverser() self.col_handler = CollisionHandlerEvent() picker_node = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(picker_node) self.pickerRay = CollisionRay() picker_node.addSolid(self.pickerRay) plane_node = CollisionNode("base_plane") plane = base.render.attachNewNode(plane_node) self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) picker_node.addSolid(self.pickerRay) picker_node.setTag("rays", "mray") base.cTrav.addCollider(pickerNPos, self.col_handler) self.col_handler.addInPattern("%(rays)ft-into-%(type)it") self.col_handler.addOutPattern("%(rays)ft-out-%(type)it") self.col_handler.addAgainPattern("ray_again_all%(" "rays" ")fh%(" "type" ")ih") self.model = loader.loadModel("../models/chest.egg") self.model_node = NodePath("sdfafd") self.model.reparentTo(self.model_node) self.model_node.reparentTo(render) # # self.text_node = TextNode("battle_text") # self.text_node.setText("TEXTYTEXTYTEXTTEXT") # self.text_node_path = render.attachNewNode(self.text_node) # self.text_node_path.reparentTo(render) # self.text_node_path.setPos(0,0,4) # self.text_node_path.setHpr(0,0,0) # self.text_node_path.setScale(1) # #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha) # self.text_node.setTextColor((1,1,1,1)) # self.text_node.setAlign(TextNode.ALeft) self.placement_ghost = EditorObjects.PlacementGhost( 0, "tower", base.object_scale) z = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z)) taskMgr.add(self.ray_update, "updatePicker") taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane") taskMgr.add(self.task_mouse_press_check, "checkMousePress") self.input_init() self.pickable = None
def setMousePicker(self): self.picker = CollisionTraverser() self.pq = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNP, self.pq) self.selectable = render.attachNewNode("selectable")
def __init__(self, model, run, walk, startPos, scale): """Initialise the character. Arguments: model -- The path to the character's model file (string) run : The path to the model's run animation (string) walk : The path to the model's walk animation (string) startPos : Where in the world the character will begin (pos) scale : The amount by which the size of the model will be scaled (float) """ self.controlMap = {"left":0, "right":0, "up":0, "down":0} self.actor = Actor(Config.MYDIR+model, {"run":Config.MYDIR+run, "walk":Config.MYDIR+walk}) self.actor.reparentTo(render) self.actor.setScale(scale) self.actor.setPos(startPos) self.controller = Controller.LocalController(self) taskMgr.add(self.move,"moveTask") # Note: deriving classes DO NOT need # to add their own move tasks to the # task manager. If they override # self.move, then their own self.move # function will get called by the # task manager (they must then # explicitly call Character.move in # that function if they want it). self.prevtime = 0 self.isMoving = False # 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, and the other will start above the camera. # 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.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('ralphRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = self.actor.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler)
def attachCollisionRay(self, name, ox, oy, oz, dx, dy, dz, fromCollide, intoCollide): from pandac.PandaModules import CollisionRay from pandac.PandaModules import CollisionNode coll = CollisionRay.CollisionRay(ox, oy, oz, dx, dy, dz) collNode = CollisionNode.CollisionNode(name) collNode.addSolid(coll) collNode.setFromCollideMask(fromCollide) collNode.setIntoCollideMask(intoCollide) collNodePath = self.attachNewNode(collNode) return collNodePath
def init_collisions(self): base.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerEvent() pickerNode = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) pickerNode.setTag("rays","ray1") base.cTrav.addCollider(pickerNPos, self.cHandler)
def __init__(self): self.pickerNode = CollisionNode('RepairMousePicker.pickerNode') self.pickerNP = base.cam2d.attachNewNode(self.pickerNode) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.collisionTraverser = CollisionTraverser() self.collisionHandler = CollisionHandlerQueue() self.collisionTraverser.addCollider(self.pickerNP, self.collisionHandler) self.clearCollisionMask() self.orthographic = True
def init_collide(self): # why the heck he import within method from pandac.PandaModules import CollisionTraverser, CollisionNode from pandac.PandaModules import CollisionHandlerQueue, CollisionRay # init and import collision for object self.cTrav = CollisionTraverser('MousePointer') self.cQueue = CollisionHandlerQueue() self.cNode = CollisionNode('MousePointer') self.cNodePath = base.camera.attachNewNode(self.cNode) self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.cRay = CollisionRay() self.cNode.addSolid(self.cRay) self.cTrav.addCollider(self.cNodePath, self.cQueue)
def __init__(self, actor): """Initialise the camera, setting it to follow 'actor'. Arguments: actor -- The Actor that the camera will initially follow. """ self.actor = actor self.prevtime = 0 # The camera's controls: # "left" = move the camera left, 0 = off, 1 = on # "right" = move the camera right, 0 = off, 1 = on self.controlMap = {"left": 0, "right": 0} taskMgr.add(self.move, "cameraMoveTask") # Create a "floater" object. It is used to orient the camera above the # target actor's head. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Set up the camera. base.disableMouse() base.camera.setPos(self.actor.getX(), self.actor.getY() + 2, 2) # uncomment for topdown #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) #base.camera.setHpr(180, -50, 0) # 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. 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)
def __init__(self): self.keys = {} for char in string.ascii_lowercase: self.keys[char] = BUTTON_UP def makeKeyPair(ch): def keyUp(): self.keys[ch] = BUTTON_DOWN #print "%s UP" % (ch) def keyDown(): self.keys[ch] = BUTTON_UP #print "%s DOWN" % (ch) return [keyUp, keyDown] keyPair = makeKeyPair(char) self.accept(char, keyPair[0]) self.accept(char + '-up', keyPair[1]) self.accept('mouse1', self.leftClick) self.accept('mouse1-up', self.leftClickUp) self.accept('mouse2', self.mClick) self.accept('mouse2-up', self.mClickUp) self.accept('mouse3', self.rightClick) self.accept('mouse3-up', self.rightClickUp) self.mouse1Down = False self.mouse2Down = False self.mouse3Down = False self.trackMouseTimeOld = 0 self.trackMouseX = 0 self.trackMouseY = 0 self.trackMouse_Mouse1DownOld = False self.trackMouse_Mouse2DownOld = False self.trackMouse_Mouse3DownOld = False taskMgr.add(self.trackMouseTask, 'trackMouseTask') # base.cTrav = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() self.pickerCollN = CollisionNode('mouseRay') self.pickerCamN = base.camera.attachNewNode(self.pickerCollN) self.pickerCollN.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerCollN.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerCamN, self.pickerQ) self.objectUnderCursor = None
def addDropCollision(self, drop): collSph = drop.attachNewNode(CollisionNode('coll_drop')) collSph.node().addSolid(CollisionSphere(0, 0, 0, 1)) collSph.node().setIntoCollideMask(BitMask32.allOff()) collSph.node().setFromCollideMask(Globals.DropBitmask) collGround = drop.attachNewNode(CollisionNode('coll_drop_ground')) collGround.node().addSolid(CollisionRay(0, 0, 0, 0, 0, -1)) collGround.node().setIntoCollideMask(BitMask32.allOff()) collGround.node().setFromCollideMask(Globals.WallBitmask) collGround.show() collHdlF.addCollider(collGround, drop) base.cTrav.addCollider(collSph, collHdl) base.cTrav.addCollider(collGround, collHdlF) self.accept("coll_drop-into", self.handleDropCollision) self.accept("coll_drop-out", self.completeCollision)
def setupRay(self, bitmask, floorOffset, reach): cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0) cRayNode = CollisionNode('Flyer.cRayNode') cRayNode.addSolid(cRay) self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode) cRayNode.setFromCollideMask(bitmask) cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerGravity() self.lifter.setLegacyMode(self._legacyLifter) self.lifter.setGravity(self.getGravity(0)) self.lifter.addInPattern('%fn-enter-%in') self.lifter.addAgainPattern('%fn-again-%in') self.lifter.addOutPattern('%fn-exit-%in') self.lifter.setOffset(floorOffset) self.lifter.setReach(reach) self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def _initCollisions(self): self._camCollRay = CollisionRay() camCollNode = CollisionNode('CameraToonRay') camCollNode.addSolid(self._camCollRay) camCollNode.setFromCollideMask(OTPGlobals.WallBitmask | OTPGlobals.CameraBitmask | ToontownGlobals.FloorEventBitmask | ToontownGlobals.CeilingBitmask) camCollNode.setIntoCollideMask(0) self._camCollNP = self._camera.attachNewNode(camCollNode) self._camCollNP.show() self._collOffset = Vec3(0, 0, 0.5) self._collHandler = CollisionHandlerQueue() self._collTrav = CollisionTraverser() self._collTrav.addCollider(self._camCollNP, self._collHandler) self._betweenCamAndToon = {} self._transNP = NodePath('trans') self._transNP.reparentTo(render) self._transNP.setTransparency(True) self._transNP.setAlphaScale(Globals.Camera.AlphaBetweenToon) self._transNP.setBin('fixed', 10000)
def setupCollision(self): # create collision traverser self.picker = CollisionTraverser() # create collision handler self.pq = CollisionHandlerQueue() # create collision node self.pickerNode = CollisionNode('mouseRay') # create collision node # attach new collision node to camera node self.pickerNP = camera.attachNewNode( self.pickerNode) # attach collision node to camera # set bit mask to one self.pickerNode.setFromCollideMask(BitMask32.bit(1)) # set bit mask # create a collision ray self.pickerRay = CollisionRay() # create collision ray # add picker ray to the picker node self.pickerNode.addSolid( self.pickerRay) # add the collision ray to the collision node # make the traverser know about the picker node and its even handler queue self.picker.addCollider( self.pickerNP, self.pq) # add the colision node path and collision handler queue #self.picker.showCollisions( render ) # render or draw the collisions #self.pickerNP.show( ) # render picker ray # create col node self.colPlane = CollisionNode('colPlane') # add solid to col node plane self.colPlane.addSolid( CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))) # attach new node to the render self.colPlanePath = render.attachNewNode(self.colPlane) #self.colPlanePath.show( ) # render node # make the col plane look at the camera # this makes it alway look at the camera no matter the orientation # we need this because the ray nees to intersect a plane parallel # to the camera self.colPlanePath.lookAt(camera) # prop up the col plane self.colPlanePath.setP(-45) # set bit mask to one # as I understand it, this makes all col nodes with bit mask one # create collisions while ignoring others of other masks self.colPlanePath.node().setIntoCollideMask(BitMask32.bit(1))
def initialize(self): """ To setup collision detection we need: a. A CollisionNode having a ray as its solid and placed at the position of the camera while also having the same orientation as the camera. b. A new nodepath placed in the scenegraph as an immediate child of the camera. It will be used to insert the collision node in the scenegraph. c. A CollisionRay for firing rays based on mouse clicks. d. A collisions traverser. e. A collisions queue where all found collisions will be stored for later processing. """ self.traverser = CollisionTraverser('Hotspots collision traverser') self.collisionsQueue = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.pickerNP = self.renderer.getCamera().attachNewNode( self.pickerNode) self.traverser.addCollider(self.pickerNP, self.collisionsQueue)
def createCollisionHandlers(self): # Create a new collision traverser instance. We will use this to determine # if any collisions occurred after performing movement. self.cTrav = CollisionTraverser() camGroundRay = CollisionRay() camGroundRay.setOrigin(0, 0, 1000) camGroundRay.setDirection(0, 0, -1) camGroundCol = CollisionNode('camRay') camGroundCol.addSolid(camGroundRay) camGroundCol.setFromCollideMask(BitMask32.bit(0)) camGroundCol.setIntoCollideMask(BitMask32.allOff()) camGroundColNp = base.camera.attachNewNode(camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(camGroundColNp, self.camGroundHandler) # register the collision pusher self.pusher = CollisionHandlerPusher() # register collision event pattern names self.pusher.addInPattern('col-%fn-into')
def __init__(self): ''' Should the traverser be shared? ''' LOG.debug("[Selector] Initializing") # The collision traverser does the checking of solids for collisions self.cTrav = CollisionTraverser() # The collision handler queue is a simple handler that records all # detected collisions during traversal self.cHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerNP, self.cHandler) # Start listening to clicks self.resume()
def createRay(self, obj, ent, name, show=False, x=0, y=0, z=0, dx=0, dy=0, dz=-1): #create queue obj.queue = CollisionHandlerQueue() #create ray obj.rayNP = ent.attachNewNode(CollisionNode(name)) obj.ray = CollisionRay(x, y, z, dx, dy, dz) obj.rayNP.node().addSolid(obj.ray) obj.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask()) sandbox.pickTrav.addCollider(obj.rayNP, obj.queue) if show: obj.rayNP.show()
def __init__(self, game_data, gfx_manager): self.game_data = game_data self.gui_traverser = CollisionTraverser() self.handler = CollisionHandlerQueue() self.selectable_objects = {} for cid, model in gfx_manager.character_models.items(): new_collision_node = CollisionNode('person_' + str(cid)) new_collision_node.addSolid( CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5)) new_collision_nodepath = model.attachNewNode(new_collision_node) new_collision_nodepath.setTag("type", "character") new_collision_nodepath.setTag("id", str(cid)) picker_node = CollisionNode('mouseRay') picker_np = camera.attachNewNode(picker_node) self.picker_ray = CollisionRay() picker_node.addSolid(self.picker_ray) self.gui_traverser.addCollider(picker_np, self.handler) self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) self.floor_np = render.attachNewNode(CollisionNode('floor')) self.floor_np.setTag("type", "ground") self.floor_np.node().addSolid(self.floor)
def __init__(self, name, world, pos): ActorNode.__init__(self, name) self.nodePath = NodePath(self) self.world = world # init the model or the Actor self.model = self.getModel() self.model.reparentTo(self.nodePath) self.nodePath.setPos(*pos) self.prevPos = self.nodePath.getPos() # collision detection fromObject = self.nodePath.attachNewNode(CollisionNode(name)) self.addSolids(fromObject) fromObject.show() # setup the ground ray, needed for detecting the ground groundRay = CollisionRay() groundRay.setOrigin(0, 0, 1000) groundRay.setDirection(0, 0, -1) groundCol = CollisionNode('groundRay') groundCol.addSolid(groundRay) groundCol.setFromCollideMask(BitMask32.bit(0)) groundCol.setIntoCollideMask(BitMask32.allOff()) groundColNp = base.camera.attachNewNode(groundCol) self.groundHandler = CollisionHandlerQueue() self.world.cTrav.addCollider(groundColNp, self.groundHandler) # self.world.cTrav.addCollider(fromObject, self.world.pusher) # self.world.pusher.addCollider(fromObject, self.nodePath) self.postInit()
#** the avatar's fallout sensor - stuff already seen in former snippets, but this time we'll use it for more that to detect the fallout impact force, so we'll add another mask to look out avatarSensor = avatarNP.attachNewNode(CollisionNode('yolkysensor')) cs = CollisionSphere(0, 0, 0, 1.2) avatarSensor.node().addSolid(cs) # here the masking: note that this sensor will look for floor bashing but also for other geometries masked with TRIGGER_MASK. avatarSensor.node().setFromCollideMask(FLOOR_MASK | TRIGGER_MASK) avatarSensor.node().setIntoCollideMask(BitMask32.allOff()) cs.setTangible(0) #** here's how to read the events fired by the 'sensor' while colliding with geometry we enable to collide with it. collisionEvent.addInPattern('%fn-into') collisionEvent.addOutPattern('%fn-out') #** the floor ray collider for the avatar avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay')) avatarRay.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1)) avatarRay.node().setFromCollideMask(FLOOR_MASK) avatarRay.node().setIntoCollideMask(BitMask32.allOff()) #** This is the scene map - we'll gather off here almost every element of the map: scenery, ground colliders, walls, and also triggers and spawn points. See the .blend source for details on the scene components. scene = loader.loadModel("windmill") scene.reparentTo(render) scene.setCollideMask(BitMask32.allOff()) scene.setScale(10) # Let's mask our main collision surfaces floorcollider = scene.find("**/floor0/floor_collide*") floorcollider.node().setIntoCollideMask(FLOOR_MASK) wallcollider = scene.find("**/wall0/wall_collide*") wallcollider.node().setIntoCollideMask(WALL_MASK)
def __init__(self): base.cTrav = CollisionTraverser() self.col_handler = CollisionHandlerEvent() self.selected = -1 self.selected_node = None self.selecteds = [] self.multi_select = False self.multi_selecting = False self.select_box = NodePath() picker_node = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(picker_node) self.pickerRay = CollisionRay() picker_node.addSolid(self.pickerRay) plane_node = CollisionNode("base_plane") plane = base.render.attachNewNode(plane_node) self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) picker_node.addSolid(self.pickerRay) picker_node.setTag("rays", "mray") base.cTrav.addCollider(pickerNPos, self.col_handler) self.col_handler.addInPattern("%(rays)ft-into-%(type)it") self.col_handler.addOutPattern("%(rays)ft-out-%(type)it") self.col_handler.addAgainPattern("ray_again_all%(" "rays" ")fh%(" "type" ")ih") self.DO = DirectObject() self.DO.accept('mray-into-army', self.col_in_object) self.DO.accept('mray-out-army', self.col_out_object) self.DO.accept('mray-into-battle', self.col_in_object) self.DO.accept('mray-out-battle', self.col_out_object) self.DO.accept('mray-into-tower', self.col_in_object) self.DO.accept('mray-out-tower', self.col_out_object) self.DO.accept('ray_again_all', self.col_against_object) if base.client == False: self.col_handler.addInPattern("%(player)ft-into-%(player)it") self.col_handler.addInPattern("%(type)ft-into-%(type)it") self.DO.accept('army-into-battle', self.col_army_against_battle) self.DO.accept('army-into-tower', self.col_army_against_tower) self.DO.accept('1-into-2', self.col_p1_into_p2) self.pickable = None self.DO.accept('mouse1', self.mouse_click, ["down"]) self.DO.accept('mouse1-up', self.mouse_click, ["up"]) self.DO.accept('mouse3-up', self.mouse_order) taskMgr.add(self.ray_update, "updatePicker") taskMgr.add(self.task_select_check, "updatePicker") taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane") z = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z)) self.model = loader.loadModel("models/chest.egg") self.model.reparentTo(render) self.model.hide() cm = CardMaker("blah") cm.setFrame(-100, 100, -100, 100) pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1) pnode.hide()
def __init__(self): base.disableMouse() base.camLens.setFar(100) self.parserClass = Parser.Parser() # Making the required instances self.mapLoaderClass = mapLoader.mapLoader(self) self.gameObjects = {} self.gameObjectID = 0 self.mapX = self.mapLoaderClass.mapConfigParser.getint( "map", "width") - 1 # Name says it all really self.mapY = self.mapLoaderClass.mapConfigParser.getint( "map", "height") - 1 self.modelLoaderClass = modelLoader.modelLoader(self) self.cameraClass = stratCam.CameraHandler(self) self.mouseClass = stratCam.mouseHandler(self) self.GUI = stratCam.GUI(self) # self.GUI = stratCam.GUI(self) self.priorities = priorities.priorities() base.setFrameRateMeter(True) ############### base.cTrav2 = CollisionTraverser('world2') # base.cTrav2.showCollisions(render) self.heightRay = CollisionRay( ) # A collision ray, used for getting the height of the terrain self.heightRay.setOrigin(0, 0, 100) self.heightRay.setDirection(0, 0, -1) self.heightCol = CollisionNode('unit Ray') self.heightCol.addSolid(self.heightRay) self.heightCol.setTag('units', 'ray1') self.heightCol.setFromCollideMask(BitMask32.bit(0)) # self.heightCol.setIntoCollideMask(BitMask32.allOff()) self.heightColNp = render.attachNewNode(self.heightCol) self.heightColNp.setPos(2, 2, 0) self.heightHandler = CollisionHandlerQueue() base.cTrav2.addCollider(self.heightColNp, self.heightHandler) ############### # myFrame = DirectFrame(frameColor=(0, 0, 0, 1), # frameSize=(-0.25, 0.25, -1, 1), # pos=(1.08, 0, 0)) # button = DirectButton(text = ("button"), scale = 0.1) # button.reparentTo(myFrame) # button.setPos(0, 0, 0.9) self.grids = astar.grid(self) self.unitHandler = unitHandler.world(self) # self.unitHandler.addUnit(0, (10,10,5), self) # self.unitHandler.addUnit(1, (6,10,5), self) # self.unitHandler.moveTo(self, (6, 34), 0) # self.unitHandler.moveTo(self, (34, 30), 1) self.buildingHandler = buildingHandler.buildingHandler(self) self.tileSelected = (0, 0) taskMgr.add(self.tskCheckWalls, "Wall checking") taskMgr.add(self.priorities.jobTask, "Jobs", extraArgs=[self]) self.loadLight() self.accept("escape", sys.exit) self.accept("1", self.unitHandler.addUnit2, extraArgs=[0, self]) self.accept("2", self.unitHandler.addUnit2, extraArgs=[1, self]) self.accept("3", self.unitHandler.addUnit2, extraArgs=[2, self]) self.accept("enter", self.buildingHandler.addBuilding2, extraArgs=[self, 0]) self.accept("p", self.priorities.addJob) print 'END OF GAMEMAIN.PY!'
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay from tower import * import collision import player import tower import troop from pathfindingMesh import * """File to handle mouse picking, receiving a collision object to add the mouse ray to the collision handler """ pickerNode = CollisionNode('mouseRay_cnode') pickerNP = base.camera.attachNewNode(pickerNode) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) #pickerNode.setFromCollideMask(BitMask32(0x1)) #pickerNode.setFromCollideMask(BitMask32(0x2)) collision.addCollider(pickerNP) #A struct like to solve reference pass problems class MousePicking: mpos = None pickingEnabled = True towerFollowMouse = False mousePickingOnTower = False mousePickingOnTroop = False collindingNode = None gameHUD = None lastClickedTower = None
#** Collision masks FLOOR_MASK = BitMask32.bit(1) MASK_OFF = BitMask32.allOff() #** Our steering avatar avatarNP = base.render.attachNewNode(ActorNode('smileyNP')) avatarNP.reparentTo(base.render) avatar = loader.loadModel('smiley') avatar.reparentTo(avatarNP) avatar.setPos(0, 0, 1) avatar.setCollideMask(MASK_OFF) avatarNP.setPos(0, 0, 15) #** Stick and set the ray collider to the avatar raygeometry = CollisionRay(0, 0, 2, 0, 0, -1) avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay')) avatarRay.node().addSolid(raygeometry) # let's mask our floor FROM collider avatarRay.node().setFromCollideMask(FLOOR_MASK) avatarRay.node().setIntoCollideMask(MASK_OFF) #** This is the terrain map - differently than what we used to in previous steps, the collision solids will be loaded separately. See this below. terrain = loader.loadModel("oc3ground") terrain.reparentTo(render) terrain.setCollideMask(MASK_OFF) terrain.setScale(10) #** Let's load ands mask our collision surfaces - the task is repeated 2 times: one for a single-mesh collider and the other for the octreefied one and the two colliders data is conveniently stored in the dictionary 'floorcolliderdata', for a later usage, to show the performance difference between the two setups. The important thing to know here is that when your collision model mesh will be octreefied, the octree script will change a bit the mesh naming, changing indeed the root name, that we use here to find its geometry inside the egg file, and mask it to be recognized by the floor collision handler. In a octreefied mesh the root name will always be (at the date I'm writing and until the script will changes) "octree-root" - just be advised. # the colliders storage