def setUpCarCollider(self): self.carCollideTrav = CollisionTraverser() base.cTrav = self.carCollideTrav self.handler = CollisionHandlerQueue() self.carRay = CollisionRay(self.carPositionX, self.carPositionY, self.carPositionZ, 0, 0, -1) self.carForwardHandler = CollisionHandlerQueue() # so that it doesn't collide with things forward and backward. degToRad = math.pi / 180 (xDir, yDir, zDir) = self.findCarFrontDir() self.carRayForward = CollisionRay(self.carPositionX, self.carPositionY, self.carPositionZ, xDir, yDir, zDir) self.carForwardCollision = CollisionNode("forwardCollision") self.carForwardCollision.addSolid(self.carRayForward) self.carForwardCollision.setIntoCollideMask(CollideMask.allOff()) self.carForwardCollisionNode = self.car.attachNewNode( self.carForwardCollision) (centerX, centerY) = self.findActualCenter(0, 0, self.adjustedXForCenter, self.adjustedYForCenter, self.carYaw) self.carRayForward.setOrigin(5, 10, 5) self.carCollision = CollisionNode("groundCollision") self.carCollision.addSolid(self.carRay) self.carCollision.setIntoCollideMask(CollideMask.allOff()) self.carCollisionNode = self.car.attachNewNode(self.carCollision) self.carCollideTrav.addCollider(self.carCollisionNode, self.handler) self.carCollideTrav.addCollider(self.carForwardCollisionNode, self.carForwardHandler) self.carForwardCollisionNode.show()
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 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 test_collision_traverser_pickle(): from direct.stdpy.pickle import dumps, loads handler = CollisionHandlerQueue() collider1 = NodePath(CollisionNode("collider1")) collider2 = NodePath(CollisionNode("collider2")) trav = CollisionTraverser("test123") trav.respect_prev_transform = True trav.add_collider(collider1, handler) trav.add_collider(collider2, handler) trav = loads(dumps(trav, -1)) assert trav.respect_prev_transform is True assert trav.name == "test123" assert trav.get_num_colliders() == 2 collider1 = trav.get_collider(0) collider2 = trav.get_collider(1) assert collider1.name == "collider1" assert collider2.name == "collider2" # Two colliders must still be the same object; this only works with our own # version of the pickle module, in direct.stdpy.pickle. assert trav.get_handler(collider1) == trav.get_handler(collider2)
def __init__(self, ip, port, verbose=False): super().__init__() # Set up mouse input base.cTrav = CollisionTraverser() self.handler = CollisionHandlerQueue() self.mouseHandler = MouseHandler() self.taskMgr.add(self.inputTask, "InputTask") # Set up the UI self.fonts = hud.hud.Fonts() self._scene = None # Set up audio self.audioMaster = audio.AudioMaster() # Set up the NetworkManager self.client = protocol.client.Client(ip, port, verbose) instr = networkInstructions.NetworkInstructions(self) self.client.add_observer(instr) self.clientActions = self.client.clientActions self.gameState = self.client.state # Connect to the server self.scene = hud.connection.ConnectionUI() self.connectionManager = ConnectionManager((ip, port), self, self.scene) self.connectionManager.tryConnect() self.taskMgr.add(self.networkUpdateTask, "NetworkUpdateTask")
def __init__(self): colliderNode = CollisionNode(self.colliderName + "WallCollider") colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3)) self.collider = self.root.attachNewNode(colliderNode) self.collider.setPythonTag(TAG_OWNER, self) colliderNode.setFromCollideMask(MASK_WALLS) colliderNode.setIntoCollideMask(0) self.collider.setZ(self.height * 0.5) base.pusher.addCollider(self.collider, self.root) base.traverser.addCollider(self.collider, base.pusher) self.ray = CollisionRay(0, 0, self.height / 2, 0, 0, -1) rayNode = CollisionNode(self.colliderName + "Ray") rayNode.addSolid(self.ray) rayNode.setFromCollideMask(MASK_FLOORS) rayNode.setIntoCollideMask(0) self.rayNodePath = self.root.attachNewNode(rayNode) self.rayQueue = CollisionHandlerQueue() base.traverser.addCollider(self.rayNodePath, self.rayQueue)
def setupMouseCollision(self): """ """ #Since we are using collision detection to do picking, we set it up #any other collision detection system with a traverser and a handler self.mPickerTraverser = CollisionTraverser() #Make a traverser self.mCollisionQueue = CollisionHandlerQueue() #create a collision solid ray to detect against self.mPickRay = CollisionRay() #self.mPickRay.setOrigin(base.camera.getPos(render)) #self.mPickRay.setDirection(render.getRelativeVector(base.camera, Vec3(0,1,0))) #create our collison Node to hold the ray self.mPickNode = CollisionNode('pickRay') 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) #well 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(GeomNode.getDefaultCollideMask()) #Register the ray as something that can cause collisions self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQueue)
def checkcmcd(objcm1, objcm2, toggleplot=False): """ detect the collision between collision models :return: True or False author: weiwei, Toyonaka date: 20190312 """ oocnp = NodePath("collision nodepath") obj1cnp = objcm1.copycdnpTo(oocnp) obj2cnp = objcm2.copycdnpTo(oocnp) if toggleplot: oocnp.reparentTo(base.render) obj1cnp.show() obj2cnp.show() ctrav = CollisionTraverser() chan = CollisionHandlerQueue() ctrav.addCollider(obj1cnp, chan) ctrav.traverse(oocnp) if chan.getNumEntries() > 0: return True else: return False
def __init__(self, cr): DistributedObject.__init__(self, cr) #self.model = loader.loadModel('environment') #self.model.setZ(0) #self.builder = Builder(self, "map.txt", "development") plane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) cnode = CollisionNode('cnode') cnode.setIntoCollideMask(BitMask32.bit(1)) cnode.setFromCollideMask(BitMask32.bit(1)) cnode.addSolid(plane) self.planeNP = self.model.attachNewNode(cnode) self.planeNP.show() # Setup a traverser for the picking collisions self.picker = CollisionTraverser() # Setup mouse ray self.pq = CollisionHandlerQueue() # Create a collision Node pickerNode = CollisionNode('MouseRay') # set the nodes collision bitmask pickerNode.setFromCollideMask(BitMask32.bit(1)) # create a collision ray self.pickerRay = CollisionRay() # add the ray as a solid to the picker node pickerNode.addSolid(self.pickerRay) # create a nodepath with the camera to the picker node self.pickerNP = base.camera.attachNewNode(pickerNode) # add the nodepath to the base traverser self.picker.addCollider(self.pickerNP, self.pq) print "model loaded" #TODO: check how to load multiple levels and set players in specific levels! self.accept("mouse1", self.mouseClick)
def __init__(self): ShowBase.__init__(self) base.enableParticles() base.cTrav = CollisionTraverser("base collision traverser") base.handler = CollisionHandlerQueue() self.scene = self.loader.loadModel("models/environment") self.scene.reparentTo(self.render) self.scene.setScale(0.25, 0.25, 0.25) self.scene.setPos(-8, 42, 0) self.teapots = [None for i in range(2)] self.fires = [None for i in range(2)] for i in range(2): self.teapots[i] = self.loader.loadModel("teapot") self.teapots[i].reparentTo(render) self.fires[i] = fireSystem(i, self.teapots[i]) self.teapots[i].setPos(i * 15, i, i) self.fires[1].ignite() self.tick = taskMgr.add(self.tick, "Update") base.disableMouse() self.camera.setPos(0, -20, 5)
def startSeeking(self): if not self.avatar: return self.cleanupShadow() self.buildShadow() scale = self.dropShadow.getScale() if scale < 1.0: self.maxDistance += 40 x, y, z = self.avatar.getPos(render) self.dropShadow.reparentTo(render) self.dropShadow.setPos(x, y + 5, z + 2) self.cameraNode = CollisionNode('coll_camera') self.cameraNode.setFromCollideMask(CIGlobals.WallBitmask) self.cameraRay = CollisionRay() self.cameraNode.addSolid(self.cameraRay) self.cameraNP = camera.attachNewNode(self.cameraNode) base.cTrav.addCollider(self.cameraNP, CollisionHandlerQueue()) if not self.legacyMode: shadowNode = CollisionNode('coll_shadow') self.shadowRay = CollisionRay(0, 0, 6, 0, 0, -1) shadowNode.addSolid(self.shadowRay) shadowNode.setFromCollideMask(CIGlobals.FloorBitmask) self.shadowNP = self.dropShadow.attachNewNode(shadowNode) base.cTrav.addCollider(self.shadowNP, self.collHdlFl) base.taskMgr.add(self.__moveShadow, self.moveShadowTaskName) self.avatar.acceptOnce('mouse1', self.locationChosen)
def __init__(self, ip, port, verbose=False, lagSimulation=0): super().__init__() # Set up mouse input base.cTrav = CollisionTraverser() self.handler = CollisionHandlerQueue() self.mouseHandler = MouseHandler() self.taskMgr.add(self.inputTask, "InputTask") # Set up the UI self.fonts = hud.Fonts() # View the cards at an angle self.camera.setPosHpr(4, -15, -15, 0, 45, 0) # Set up the NetworkManager instr = client.networkInstructions.NetworkInstructions() self.networkManager = ClientNetworkManager(instr, ip, port) self.networkManager.verbose = verbose # Connect to the server self.connectionManager = ConnectionManager((ip, port), self) self.connectionManager.tryConnect() self.taskMgr.add(self.networkUpdateTask, "NetworkUpdateTask") # Set up lag simulation self.lagTimer = self.lagSimulation = lagSimulation self.availableFactions = [ templars.Templar, mariners.Mariner, thieves.Thief, fae.Faerie ] self.hasMulliganed = False self.ready = False
def start(self): base.camLens.setNear(0.1) self.shooterTrav = CollisionTraverser('ToonFPS.shooterTrav') ray = CollisionRay() rayNode = CollisionNode('ToonFPS.rayNode') rayNode.addSolid(ray) rayNode.setCollideMask(BitMask32(0)) rayNode.setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask) self.shooterRay = ray self.shooterRayNode = base.camera.attachNewNode(rayNode) self.shooterHandler = CollisionHandlerQueue() self.shooterTrav.addCollider(self.shooterRayNode, self.shooterHandler) self.firstPerson.start() self.v_model_root.reparentTo(base.camera) self.v_model.reparentTo(self.v_model_root) if self.weaponName == "pistol": self.v_model_root.setZ(-1.8) self.v_model_root.setY(0.3) self.v_model_root.setX(-0.1) self.v_model_root.setH(2) elif self.weaponName == "sniper": self.v_model_root.setPos(-0.42, -0.81, -1.7) self.v_model_root.setHpr(359, 352.87, 0.00) elif self.weaponName == "shotgun": self.v_model_root.setPos(-0.42, -0.81, -1.7) self.v_model_root.setHpr(359, 352.87, 0.00) self.gui.start() self.firstPerson.disableMouse() self.aliveFSM.request('draw')
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 __init__(self): #selection detection self.picker = CollisionTraverser() self.pq = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) #self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) #TODO WOW geometry collision is SUPER slow... self.pickerNode.setFromCollideMask(BitMask32.bit(BITMASK_COLL_CLICK)) #render.find('**selectable').node().setIntoCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNP, self.pq) #self.picker.showCollisions(render) #box selection detection HINT: start with drawing the 2d thing yo! self.__shift__ = False self.accept("shift", self.shiftOn) self.accept("shift-up", self.shiftOff) self.__ctrl__ = False self.accept("control", self.ctrlOn) self.accept("control-up", self.ctrlOff) #mouse handling self.accept("mouse1", self.clickHandler) self.accept("shift-mouse1", self.clickHandler) self.accept("mouse1-up", self.releaseHandler) #dragging self.dragTask = taskMgr.add(self.dragTask, 'dragTask')
def __init__(self): ShowBase.__init__(self) self.physicsMgr = Pmango() self.cTravA = CollisionTraverser() physicsMgr = self.physicsMgr self.alin = LinearEulerIntegrator() self.physicsMgr.attachLinearIntegrator(self.alin) self.arin = AngularEulerIntegrator() self.physicsMgr.attachAngularIntegrator(self.arin) alin = self.alin arin = self.arin grava = ForceNode('GravAll') grta = LinearVectorForce(0, 0, -8) grava.addForce(grta) physicsMgr.addLinearForce(grta) self.readbuff = open("InterBuff.py", "r+") self.taskMgr.doMethodLater(0.1, self.phytime, "PhyTime") self.taskMgr.add(self.interbuff, "InterBuff") self.DinGro = CollisionHandlerQueue()
def setCollisions(self, value): if value == True: b = self.node.getBounds().getRadius() self.cTrav = CollisionTraverser() self.collisionTube = CollisionSphere( b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale']) self.collisionNode = CollisionNode('characterTube') self.collisionNode.addSolid(self.collisionTube) self.collisionNodeNp = self.node.attachNewNode(self.collisionNode) self.collisionHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.collisionNodeNp, self.collisionHandler) if self.showCollisions == True or main.editormode: # Uncomment this line to see the collision rays self.collisionNodeNp.show() # Uncomment this line to show a visual representation of the # collisions occuring self.cTrav.showCollisions(render) else: b = self.node.getBounds().getRadius() self.collisionTube = CollisionSphere( b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale']) #allowing playables to collide with npcs if self.isNPC == True: #TODO: fix because it's completely f****d up self.collisionNode = CollisionNode('characterTube') else: self.collisionNode = CollisionNode('characterNPCTube') self.collisionNode.addSolid(self.collisionTube) self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
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 setPickCollisions(self, value): if value: print "setting pick collisions" b = self.node.getBounds().getRadius() self.pickCTrav = CollisionTraverser() self.pickCollisionTube = CollisionSphere( b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'] + 0.01) self.pickCollisionNode = CollisionNode('characterPickTube') self.pickCollisionNode.addSolid(self.pickCollisionTube) self.pickCollisionNodeNp = NodePath(self.pickCollisionNode) self.pickCollisionNodeNp.reparentTo(self.node) self.pickCollisionHandler = CollisionHandlerQueue() self.pickCTrav.addCollider(self.pickCollisionNodeNp, self.pickCollisionHandler) if self.showCollisions == True: # Uncomment this line to see the collision rays self.pickCollisionNodeNp.show() # Uncomment this line to show a visual representation of the # collisions occuring self.pickCTrav.showCollisions(render) else: #dereferincing all pick colliders (must be done in order not to collide onto NPCs) self.pickCTrav = None self.pickCollisionTube = None self.pickCollisionNode = None self.pickCollisionNodeNp = None self.pickCollisionHandler = None
def __init__(self, parent: NodePath): super().__init__() self.parent = parent self.mouse_np = p3d.camera.attach_new_node(PandaNode('mouse')) self.mouse_np.set_y(p3d.lens.get_near()) picker_node = CollisionNode('mouse_ray') picker_np = p3d.camera.attach_new_node(picker_node) self._picker_ray = CollisionRay() picker_node.add_solid(self._picker_ray) self._collision_handler = CollisionHandlerQueue() self._traverser = CollisionTraverser('mouse_traverser') self._traverser.add_collider(picker_np, self._collision_handler) self.actor = Actor( resource_filename('tsim', 'data/models/cursor'), {'spin': resource_filename('tsim', 'data/models/cursor-spin')}) self.actor.loop('spin') self.actor.reparent_to(parent) self.actor.set_pos(0.0, 0.0, 0.0) self.actor.set_shader_off() self._position = Point(0.0, 0.0) self.last_position = self._position self.moved = False self.pointed_at = None self._tool: Optional[Tool] = None self._register_events()
def __init__(self, parent=None, pitch=None, id=None): NetEnt.__init__(self, id) self.node = NetNodePath(PandaNode('projectile')) if parent: self.parent = parent self.node.setPos(parent.node.getPos() + (0, 0, 1)) self.node.setHpr(parent.node.getHpr()) self.node.setP(pitch) self.node.reparentTo(render) ProjectilePool.add(self) #print 'there are',len(ProjectilePool.values()),'projectiles' self.flyTime = 0 self.sprite = Sprite2d('resources/missile.png', rows=3, cols=1, rowPerFace=(0, 1, 2, 1), anchorY=Sprite2d.ALIGN_CENTER) self.sprite.node.reparentTo(self.node) # set up 'from' collisions - for detecting projectile hitting things self.collisionHandler = CollisionHandlerQueue() self.fromCollider = self.node.attachNewNode( CollisionNode('fromCollider')) self.fromCollider.node().addSolid(CollisionRay(0, 0, 0, 0, 1, 0)) self.fromCollider.node().setIntoCollideMask(BITMASK_EMPTY) self.fromCollider.node().setFromCollideMask(BITMASK_TERRAIN | BITMASK_CHARACTER) if SHOW_COLLISIONS: self.fromCollider.show() Character.collisionTraverser.addCollider(self.fromCollider, self.collisionHandler)
def checkcmcdlistlist(objcmlist0, objcmlist1, toggleplot=False): """ detect the collision between two collision model lists :return: True or False author: weiwei, Toyonaka date: 20190422 """ oocnp0 = NodePath("collision nodepath") oocnp1 = NodePath("collision nodepath") obj0cnplist = [] for objcm0 in objcmlist0: obj0cnplist.append(objcm0.copycdnpTo(oocnp0)) obj1cnplist = [] for objcm1 in objcmlist1: obj1cnplist.append(objcm1.copycdnpTo(oocnp1)) if toggleplot: oocnp0.reparentTo(base.render) oocnp1.reparentTo(base.render) for obj0cnp in obj0cnplist: obj0cnp.show() for obj1cnp in obj1cnplist: obj1cnp.show() ctrav = CollisionTraverser() chan = CollisionHandlerQueue() for obj0cnp in obj0cnplist: ctrav.addCollider(obj0cnp, chan) ctrav.traverse(oocnp1) if chan.getNumEntries() > 0: return True else: return False
def __init__(self): """initialise the engine""" ShowBase.__init__(self) base.camLens.setNearFar(1.0, 10000) base.camLens.setFov(75) a = 33 base.camera.setPos(0,-a,a+3)#80) # collision base.cTrav = CollisionTraverser("base collision traverser") base.cHandler = CollisionHandlerEvent() base.cPusher = CollisionHandlerPusher() base.cQueue = CollisionHandlerQueue() base.globalClock=ClockObject.getGlobalClock() base.cHandler.addInPattern('%fn-into-%in') base.cHandler.addOutPattern('%fn-out-%in') base.cHandler.addAgainPattern('%fn-again-%in') # ai init base.AIworld = AIWorld(render) # 3d manager base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) self.monsters = [] self.accept('c',self._create) base.enableParticles()
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 player_init(self): self.base.pusher.addCollider(self.collider, self.actor) self.base.cTrav.addCollider(self.collider, self.base.pusher) self.collider.setPythonTag("player", self) self.score = 0 self.score_string = str(self.score) # self.base.camLens.setFov(150) #---------------------------------------------- # self.base.camLens.setFov(5) self.textObject = OnscreenText(text='Score:' + self.score_string, pos=(-1.15, -0.95), scale=0.1) self.ray = CollisionRay(0, 0, 0, 0, -1, 0) rayNode = CollisionNode("playerRay") rayNode.addSolid(self.ray) self.rayNodePath = self.actor.attachNewNode(rayNode) self.rayQueue = CollisionHandlerQueue() self.base.cTrav.addCollider(self.rayNodePath, self.rayQueue) # self.damagePerSecond = -5.0 self.beamModel = self.base.loader.loadModel("models/frowney") self.beamModel.reparentTo(self.actor) self.beamModel.setZ(10) self.beamModel.setLightOff() self.beamModel.hide()
def __init__(self, energy, jeep): self.bebidas = 0 self.energy = energy self.crash = [] self.jeep = jeep """ ---------------------- Prepara las Colisiones ---------------------- """ self.cs = CollisionSphere(0, 0, 0, 20) cont = 0 while (cont < 80): self.crash.append(self.energy[cont].attachNewNode( CollisionNode(str(cont)))) self.crash[cont].node().addSolid(self.cs) #self.crash[cont].show() Uncomment this line to see the colisions cont = cont + 1 self.css = CollisionSphere(0, 0, 0, 12) self.cnodePath = self.jeep.attachNewNode(CollisionNode('cnode')) self.cnodePath.node().addSolid(self.css) #self.cnodePath.show() Uncomment this line to see the colisions self.traverser = CollisionTraverser() self.queue = CollisionHandlerQueue() """ --------------------------------------------------------------------- """ taskMgr.add(self.choque, "choque")
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 startSeeking(self): if not self.avatar: return self.cleanupShadow() self.buildShadow() # Let's increase the distance if the shadow is smaller than expected. scale = self.dropShadow.getScale() if scale < 1.0: self.maxDistance += 40 # Let's setup the drop shadow's initial position. x, y, z = self.avatar.getPos(render) self.dropShadow.reparentTo(render) self.dropShadow.setPos(x, y + 5, z + 2) # Let's setup the collisions for the mouse. self.cameraNode = CollisionNode('coll_camera') self.cameraNode.setFromCollideMask(CIGlobals.WallBitmask) self.cameraRay = CollisionRay() self.cameraNode.addSolid(self.cameraRay) self.cameraNP = camera.attachNewNode(self.cameraNode) base.cTrav.addCollider(self.cameraNP, CollisionHandlerQueue()) if not self.legacyMode: # Let's setup the collisions for the shadow. shadowNode = CollisionNode('coll_shadow') self.shadowRay = CollisionRay(0, 0, 6, 0, 0, -1) shadowNode.addSolid(self.shadowRay) shadowNode.setFromCollideMask(CIGlobals.FloorBitmask) self.shadowNP = self.dropShadow.attachNewNode(shadowNode) base.cTrav.addCollider(self.shadowNP, self.collHdlFl) # Finally, let's start moving the shadow with the mouse and accept left mouse clicks. base.taskMgr.add(self.__moveShadow, self.moveShadowTaskName) self.avatar.acceptOnce('mouse1', self.locationChosen)
def __init__(self): self.enabled = False self.locked = False self.position = Vec3(0, 0, 0) self.delta = Vec3(0, 0, 0) self.prev_x = 0 self.prev_y = 0 self.start_x = 0 self.start_y = 0 self.velocity = Vec3(0, 0, 0) self.prev_click_time = time.time() self.double_click_distance = .5 self.hovered_entity = None self.left = False self.right = False self.middle = False self.delta_drag = Vec3(0, 0, 0) self.update_step = 1 self._i = 0 self._mouse_watcher = None self._picker = CollisionTraverser() # Make a traverser self._pq = CollisionHandlerQueue() # Make a handler self._pickerNode = CollisionNode('mouseRay') self._pickerNP = camera.attach_new_node(self._pickerNode) self._pickerRay = CollisionRay() # Make our ray self._pickerNode.addSolid(self._pickerRay) self._picker.addCollider(self._pickerNP, self._pq) self._pickerNode.set_into_collide_mask(0) self.raycast = True self.collision = None self.collisions = list() self.enabled = True
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')