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 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 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 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 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 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, base, player): self.base=base self.player=player # actor self.actor=Actor("models/zorrito") self.actor.reparentTo(self.base.render) self.actor.setScale(0.15) # collision # ray collRay=CollisionRay(0, 0, 1.5, 0, 0, -1) collRayN=CollisionNode("playerCollRay") collRayN.addSolid(collRay) collRayN.setFromCollideMask(1) collRayN.setIntoCollideMask(CollideMask.allOff()) #collRayNP=self.actor.attachNewNode(collRayN) self.collQRay=CollisionHandlerQueue() #self.base.cTrav.addCollider(collRayNP, self.collQRay) # ai self.aiWorld=AIWorld(self.base.render) self.aiChar=AICharacter("aiZorrito", self.actor, 150, 0.05, 6) self.aiWorld.addAiChar(self.aiChar) self.aiBehaviors=self.aiChar.getAiBehaviors() self.aiBehaviors.initPathFind("models/navmesh.csv") # state self.distanceToPlayer=1000 self.zOffset=0 self.terrainSurfZ=0 self.state=Zorrito.STATE_IDLE self.currentStateTimeout=4+6*random.random() # uptade task self.base.taskMgr.add(self.update, "zorritoUpdateTask")
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 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 getMouseRay(self, collRay=False): ray = CollisionRay() ray.setFromLens(self.camNode, self.getMouse()) if collRay: return ray else: return Ray(ray.getOrigin(), ray.getDirection())
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 set_controls(self): """Configure common game controls. Configure major keys, collisions system and controls to manipulate characters. """ base.accept("f1", self._show_keys) # noqa: F821 base.accept("escape", base.main_menu.show) # noqa: F821 base.accept("r", self._show_char_relations) # noqa: F821 base.accept("m", base.world.rails_scheme.show) # noqa: F821 base.accept("j", base.journal.show) # noqa: F821 # configure mouse collisions col_node = CollisionNode("mouse_ray") col_node.setIntoCollideMask(NO_MASK) col_node.setFromCollideMask(MOUSE_MASK) self._mouse_ray = CollisionRay() col_node.addSolid(self._mouse_ray) # set common collisions handler handler = CollisionHandlerEvent() handler.addInPattern("%fn-into") handler.addAgainPattern("%fn-again") handler.addOutPattern("%fn-out") self.traverser = CollisionTraverser("traverser") self.traverser.addCollider( base.cam.attachNewNode(col_node), handler # noqa: F821 ) self.set_mouse_events() taskMgr.doMethodLater(0.03, self._collide_mouse, "collide_mouse") # noqa: F821 taskMgr.doMethodLater(0.04, self._traverse, name="main_traverse") # noqa: F821
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 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 __init__(self, services: Services, base: ShowBase, map_data: MapData, name: Optional[str] = None): self.__services = services self.__services.ev_manager.register_listener(self) self.__base = base self.__name = name if name is not None else (map_data.name + "_picker") self.__map = map_data self.__data = map_data.data # collision traverser & queue self.__ctrav = CollisionTraverser(self.name + '_ctrav') self.__cqueue = CollisionHandlerQueue() # collision boxes self.__cn = CollisionNode(self.name + '_cn') self.__cn.set_collide_mask(MapPicker.COLLIDE_MASK) self.__cnp = self.__map.root.attach_new_node(self.__cn) self.__ctrav.add_collider(self.__cnp, self.__cqueue) self.__points = [] z_offset = 1 if self.__map.dim == 3 else self.__map.depth for idx in np.ndindex(self.__data.shape): if bool(self.__data[idx] & MapData.TRAVERSABLE_MASK): p = Point(*idx) self.__points.append(p) idx = self.__cn.add_solid(CollisionBox(idx, Point3(p.x+1, p.y+1, p.z-z_offset))) assert idx == (len(self.__points) - 1) # mouse picker self.__pn = CollisionNode(self.name + '_pray') self.__pnp = self.__base.cam.attach_new_node(self.__pn) self.__pn.set_from_collide_mask(MapPicker.COLLIDE_MASK) self.__pray = CollisionRay() self.__pn.add_solid(self.__pray) self.__ctrav.add_collider(self.__pnp, self.__cqueue)
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 initHero(self): self.hero = loader.loadModel("charaRoot") self.hero.reparentTo(self.stage) model = base.gameData.heroModel self.heroArmature = Actor( "{}".format(model), { "idle": "{}-idle".format(model), "walk": "{}-run".format(model) }) self.heroArmature.reparentTo(self.hero) self.hero.setPos(self.startPos) cNode = CollisionNode('hero') cNode.addSolid(CollisionSphere(0, 0, 1.5, 1)) heroCollision = self.hero.attachNewNode(cNode) ######################################################### # heroCollision.show() self.pusher.addCollider( heroCollision, self.hero, base.drive.node()) base.cTrav.addCollider(heroCollision, self.pusher) heroGroundRay = CollisionRay() heroGroundRay.setOrigin(0, 0, 9) heroGroundRay.setDirection(0, 0, -1) heroGroundCol = CollisionNode('heroRay') heroGroundCol.addSolid(heroGroundRay) heroGroundCol.setFromCollideMask(CollideMask.bit(0)) heroGroundCol.setIntoCollideMask(CollideMask.allOff()) heroGroundColNp = self.hero.attachNewNode(heroGroundCol) ######################################################### # heroGroundColNp.show() base.cTrav.addCollider(heroGroundColNp, self.heroGroundHandler) self.controlCamera()
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 __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 __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, 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 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 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): self.accept('mouse1', self.onMouse1Down, []) # Left click self.accept('mouse1-up', self.onMouse1Up, []) self.accept('mouse3', self.onMouse3Down, []) # Right click self.showCollisions = False pickerNode = CollisionNode('mouseRay') pickerNP = camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(cardBuilder.cardCollisionMask) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) base.cTrav.addCollider(pickerNP, base.handler) if self.showCollisions: base.cTrav.showCollisions(render) base.disableMouse() self.activeCard = None self._targeting = False self._dragging = None # Counts down between clicks to detect double click self.doubleClickTimer = -1.0 self.doubleClickInterval = 1.0 self.line = attackLine.Line()
def __init__(self): GameObject.__init__(self, Vec3(0, 0, 0), "Models/PandaChan/act_p3d_chan", { "stand" : "Models/PandaChan/a_p3d_chan_idle", "walk" : "Models/PandaChan/a_p3d_chan_run" }, 5, 10, "player") self.actor.getChild(0).setH(180) mask = BitMask32() mask.setBit(1) self.collider.node().setIntoCollideMask(mask) mask = BitMask32() mask.setBit(1) self.collider.node().setFromCollideMask(mask) base.pusher.addCollider(self.collider, self.actor) base.cTrav.addCollider(self.collider, base.pusher) self.lastMousePos = Vec2(0, 0) self.groundPlane = Plane(Vec3(0, 0, 1), Vec3(0, 0, 0)) self.ray = CollisionRay(0, 0, 0, 0, 1, 0) rayNode = CollisionNode("playerRay") rayNode.addSolid(self.ray) mask = BitMask32() mask.setBit(2) rayNode.setFromCollideMask(mask) mask = BitMask32() rayNode.setIntoCollideMask(mask) self.rayNodePath = render.attachNewNode(rayNode) self.rayQueue = CollisionHandlerQueue() base.cTrav.addCollider(self.rayNodePath, self.rayQueue) self.beamModel = loader.loadModel("Models/Misc/bambooLaser") self.beamModel.reparentTo(self.actor) self.beamModel.setZ(1.5) self.beamModel.setLightOff() self.beamModel.hide() self.damagePerSecond = -5.0 self.yVector = Vec2(0, 1) self.actor.loop("stand")
def raycast(self, origin, direction=(0,0,1), distance=inf, traverse_target=scene, ignore=list(), debug=False): self.position = origin self.look_at(self.position + direction) self._pickerNode.clearSolids() ray = CollisionRay() ray.setOrigin(Vec3(0,0,0)) ray.setDirection(Vec3(0,0,1)) self._pickerNode.addSolid(ray) if debug: temp = Entity(position=origin, model=Raycaster.line_model, scale=Vec3(1,1,min(distance,9999)), add_to_scene_entities=False) temp.look_at(self.position + direction) destroy(temp, 1/30) self._picker.traverse(traverse_target) if self._pq.get_num_entries() == 0: self.hit = HitInfo(hit=False, distance=distance) return self.hit ignore += tuple([e for e in scene.entities if not e.collision]) self._pq.sort_entries() self.entries = [ # filter out ignored entities e for e in self._pq.getEntries() if e.get_into_node_path().parent not in ignore and self.distance(self.world_position, Vec3(*e.get_surface_point(render))) <= distance ] if len(self.entries) == 0: self.hit = HitInfo(hit=False, distance=distance) return self.hit self.collision = self.entries[0] nP = self.collision.get_into_node_path().parent point = Vec3(*self.collision.get_surface_point(nP)) world_point = Vec3(*self.collision.get_surface_point(render)) hit_dist = self.distance(self.world_position, world_point) self.hit = HitInfo(hit=True, distance=distance) for e in scene.entities: if e == nP: # print('cast nP to Entity') self.hit.entity = e self.hit.point = point self.hit.world_point = world_point self.hit.distance = hit_dist self.hit.normal = Vec3(*self.collision.get_surface_normal(self.collision.get_into_node_path().parent).normalized()) self.hit.world_normal = Vec3(*self.collision.get_surface_normal(render).normalized()) return self.hit self.hit = HitInfo(hit=False, distance=distance) return self.hit
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 attachCollisionRay(self, name, ox, oy, oz, dx, dy, dz, fromCollide, intoCollide): from panda3d.core import CollisionRay from panda3d.core import CollisionNode coll = CollisionRay(ox, oy, oz, dx, dy, dz) collNode = CollisionNode(name) collNode.addSolid(coll) collNode.setFromCollideMask(fromCollide) collNode.setIntoCollideMask(intoCollide) collNodePath = self.attachNewNode(collNode) return collNodePath
def setupMouseCollision(self): self.mouseTraverser = CollisionTraverser() self.mouseCollisionQueue = CollisionHandlerQueue() self.mouseRay = CollisionRay() self.mouseRay.setOrigin(self.pandaScene.camera.getPos(self.pandaScene.render)) self.mouseRay.setDirection(self.pandaScene.render.getRelativeVector(self.pandaScene.camera, Vec3(0,1,0))) self.mouseNode = CollisionNode('mouseRay') self.mouseNode.addSolid(self.mouseRay) self.mouseNodePath = self.pandaScene.camera.attachNewNode(self.mouseNode) self.mouseNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.mouseTraverser.addCollider(self.mouseNodePath, self.mouseCollisionQueue)