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 setupCollisions(self): self.collTrav = CollisionTraverser() # rapid collisions detected using below plus FLUID pos self.collTrav.setRespectPrevTransform(True) self.playerGroundSphere = CollisionSphere(0, 1.5, -1.5, 1.5) self.playerGroundCol = CollisionNode('playerSphere') self.playerGroundCol.addSolid(self.playerGroundSphere) # bitmasks self.playerGroundCol.setFromCollideMask(BitMask32.bit(0)) self.playerGroundCol.setIntoCollideMask(BitMask32.allOff()) self.world.setGroundMask(BitMask32.bit(0)) self.world.setWaterMask(BitMask32.bit(0)) # and done self.playerGroundColNp = self.player.attach(self.playerGroundCol) self.playerGroundHandler = CollisionHandlerQueue() self.collTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler) # DEBUG as per video: if (self.debug == True): self.playerGroundColNp.show() self.collTrav.showCollisions(self.render)
def __init__(self, *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 __init__(self, render, camera): #Since we are using collision detection to do picking, we set it up like any other collision detection system with a traverser and a handler self.picker = CollisionTraverser() #Make a traverser self.pq = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pickerNode = CollisionNode('mouseRay') #Attach that node to the camera since the ray will need to be positioned relative to it self.pickerNP = camera.attachNewNode(self.pickerNode) #Everything to be picked will use bit 1. This way if we were doing other collision we could seperate it self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() #Make our ray self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node #Register the ray as something that can cause collisions self.picker.addCollider(self.pickerNP, self.pq) #self.picker.showCollisions(render) self.pst = CollisionTraverser() #Make a traverser self.hqp = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pstNode = CollisionNode('mouseRaytoObj') #Attach that node to the camera since the ray will need to be positioned relative to it self.pstNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pstNode2 = camera.attachNewNode(self.pstNode) self.pickerRayObj = CollisionRay() #Everything to be picked will use bit 1. This way if we were doing other collision we could seperate it #self.pstNode.setFromCollideMask(BitMask32.bit(1)) self.pstNode.addSolid(self.pickerRayObj) #Add it to the collision node #Register the ray as something that can cause collisions self.pst.addCollider(self.pstNode2, self.hqp) #self.pst.showCollisions(render)
def __init__(self, showbase, usersData, gameData): self.showbase = showbase self.usersData = usersData self.gameData = gameData random.seed(self.gameData.randSeed) # Initialize the collision traverser. self.cTrav = CollisionTraverser() # Initialize the handler. self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern('into-%in') self.world = World(showbase) for user in self.usersData: user.centipede = Centipede(showbase, len(self.usersData), self.addToCollisions) if user.thisPlayer: self.centipede = user.centipede self.centipede.attachRing(showbase) self.foods = [] for i in range(self.gameData.maxFoods): self.foods.append(Food(self.showbase, i, self.addToCollisions)) self.ticks = 0
class Agent: def __init__(self, model, run, walk, startPos, scale, select,ralph,saysome): self.actor = Actor(model, {"run":run, "walk":walk}) self.actor.reparentTo(render) self.actor.setScale(scale) self.actor.setPos(startPos) self.actor.setHpr(90,0,0) self.playerGUI = saysome self.myralph = ralph self.setAI() self.cTrav = CollisionTraverser() self.groundRay = CollisionRay(0,0,1000,0,0,-1) self.groundCol = CollisionNode('dinoRay') 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) self.sphere = CollisionSphere(0,0,5,13) self.spherecol = CollisionNode('dinoSphere') self.spherecol.addSolid(self.sphere) self.spherecol.setCollideMask(BitMask32.bit(1)) self.dinocolhs = self.actor.attachNewNode(self.spherecol) #self.dinocolhs.show() #self.groundColNp.show() #self.cTrav.showCollisions(render) def setAI(self): #Creating AI World self.AIworld = AIWorld(render) self.AIchar = AICharacter("seeker",self.actor, 380, 50, 250) self.AIworld.addAiChar(self.AIchar) self.AIbehaviors = self.AIchar.getAiBehaviors() self.AIbehaviors.pursue(self.myralph) self.actor.loop('run') #AI World update taskMgr.add(self.AIUpdate,"AIUpdate") #to update the AIWorld def AIUpdate(self,task): if self.playerGUI.getpausevalue(): self.AIworld.update() return Task.cont def setControl(self, control, value): self.controlMap[control] = value def getactor(self): return self.actor
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)
class RepairMousePicker: 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 destroy(self): del self.pickerNode self.pickerNP.removeNode() del self.pickerNP del self.pickerRay del self.collisionTraverser del self.collisionHandler def setOrthographic(self, ortho): self.orthographic = ortho def setCollisionMask(self, mask): self.pickerNode.setFromCollideMask(mask) def clearCollisionMask(self): self.pickerNode.setFromCollideMask(BitMask32.allOff()) def getCollisions(self, traverseRoot, useIntoNodePaths = False): if not base.mouseWatcherNode.hasMouse(): return [] mpos = base.mouseWatcherNode.getMouse() if self.orthographic: self.pickerRay.setFromLens(base.cam2d.node(), 0, 0) self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY()) else: self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(), mpos.getY()) self.pickerNP.setPos(0.0, 0.0, 0.0) self.collisionTraverser.traverse(traverseRoot) pickedObjects = [] if useIntoNodePaths: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i).getIntoNodePath()) else: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i)) return pickedObjects
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")
class RepairMousePicker: 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 destroy(self): del self.pickerNode self.pickerNP.removeNode() del self.pickerNP del self.pickerRay del self.collisionTraverser del self.collisionHandler def setOrthographic(self, ortho): self.orthographic = ortho def setCollisionMask(self, mask): self.pickerNode.setFromCollideMask(mask) def clearCollisionMask(self): self.pickerNode.setFromCollideMask(BitMask32.allOff()) def getCollisions(self, traverseRoot, useIntoNodePaths=False): if not base.mouseWatcherNode.hasMouse(): return [] mpos = base.mouseWatcherNode.getMouse() if self.orthographic: self.pickerRay.setFromLens(base.cam2d.node(), 0, 0) self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY()) else: self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(), mpos.getY()) self.pickerNP.setPos(0.0, 0.0, 0.0) self.collisionTraverser.traverse(traverseRoot) pickedObjects = [] if useIntoNodePaths: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append( self.collisionHandler.getEntry(i).getIntoNodePath()) else: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i)) return pickedObjects
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 __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
class Selector(object): '''A Selector listens for mouse clicks and then runs select. Select then broadcasts the selected tag (if there is one)''' 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 select(self, event): LOG.debug("[Selector] Selecting ") if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.cTrav.traverse(render) # TODO - change this to a lower node if self.cHandler.getNumEntries() > 0: #LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries()) self.cHandler.sortEntries() selectionNP = self.cHandler.getEntry(0).getIntoNodePath() selection = selectionNP.findNetTag('SelectorTag').getTag( 'SelectorTag') if selection is not '': LOG.debug("[Selector] Collision with %s" % selection) Event.Dispatcher().broadcast( Event.Event('E_EntitySelect', src=self, data=selection)) else: LOG.debug("[Selector] No collision") #Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection)) def pause(self): Event.Dispatcher().unregister(self, 'E_Mouse_1') def resume(self): print("unpausing selector") Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
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)
class Selector(object): '''A Selector listens for mouse clicks and then runs select. Select then broadcasts the selected tag (if there is one)''' 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 select(self, event): LOG.debug("[Selector] Selecting ") if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.cTrav.traverse(render) # TODO - change this to a lower node if self.cHandler.getNumEntries() > 0: #LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries()) self.cHandler.sortEntries() selectionNP = self.cHandler.getEntry(0).getIntoNodePath() selection = selectionNP.findNetTag('SelectorTag').getTag('SelectorTag') if selection is not '': LOG.debug("[Selector] Collision with %s" % selection) Event.Dispatcher().broadcast(Event.Event('E_EntitySelect', src=self, data=selection)) else: LOG.debug("[Selector] No collision") #Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection)) def pause(self): Event.Dispatcher().unregister(self, 'E_Mouse_1') def resume(self): print("unpausing selector") Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
def createBallColliderModel(self): #creates the collider sphere around the ball cSphereRad = 9.9 self.cTrav = CollisionTraverser() #moves over all possible collisions self.ballModelSphere = CollisionSphere(0, 0, 0, cSphereRad) #collision mesh around ball is a simple sphere self.ballModelCol = CollisionNode('ballModelSphere') self.ballModelCol.addSolid(self.ballModelSphere) self.ballModelCol.setFromCollideMask(BitMask32.bit(0)) self.ballModelCol.setIntoCollideMask(BitMask32.allOff()) self.ballModelColNp = self.ballModel.attachNewNode(self.ballModelCol) self.ballModelGroundHandler = CollisionHandlerQueue() #collision handler queue stores all collision points self.cTrav.addCollider(self.ballModelColNp, self.ballModelGroundHandler)
def __init__(self,actor): self.actor = actor self.prevtime = 0 self.controlMap = {"left":0, "right":0} taskMgr.add(self.move,"cameraMoveTask") self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) base.disableMouse() #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) base.camera.setPos(self.actor.getX()-30,self.actor.getY()-10,self.actor.getZ()+7) camera.setHpr(-60,0,0) 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) self.groundColNp.show()
def __init__( self, name, camera=None, rootNp=None, fromCollideMask=None, pickTag=None ): gizmo_core.Object.__init__( self, name, camera, rootNp ) self.fromCollideMask = fromCollideMask self.pickTag = pickTag self.selection = [] self.node = None self.collEntry = None # Create a marquee self.marquee = gizmo_core.Marquee( '%sMarquee' % self.name ) # 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 = 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 __setupCollisions(self): self.cTrav = CollisionTraverser("traverser") base.cTrav = self.cTrav self.physicsCollisionHandler = PhysicsCollisionHandler() self.physicsCollisionHandler.setDynamicFrictionCoef(0.5) self.physicsCollisionHandler.setStaticFrictionCoef(0.7)
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 __init__(self, model, run, walk, startPos, scale, select,ralph,saysome): self.actor = Actor(model, {"run":run, "walk":walk}) self.actor.reparentTo(render) self.actor.setScale(scale) self.actor.setPos(startPos) self.actor.setHpr(90,0,0) self.playerGUI = saysome self.myralph = ralph self.setAI() self.cTrav = CollisionTraverser() self.groundRay = CollisionRay(0,0,1000,0,0,-1) self.groundCol = CollisionNode('dinoRay') 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) self.sphere = CollisionSphere(0,0,5,13) self.spherecol = CollisionNode('dinoSphere') self.spherecol.addSolid(self.sphere) self.spherecol.setCollideMask(BitMask32.bit(1)) self.dinocolhs = self.actor.attachNewNode(self.spherecol)
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 __init__( self, name, camera=None, rootNp=None, fromCollideMask=None, pickTag=None, gizmos=None ): p3d.Object.__init__( self, name, camera, rootNp ) self.fromCollideMask = fromCollideMask self.pickTag = pickTag self.selection = set([]) self.node = None self.np = None self.collEntry = None self.gizmos = gizmos assert self.gizmos is not None # Create a marquee self.marquee = marquee.Marquee( '%sMarquee' % self.name ) # Create collision ray self.pickerRay = CollisionRay() # Create collision node pickerNode = CollisionNode( self.name ) pickerNode.addSolid( self.pickerRay ) pickerNode.setFromCollideMask( self.fromCollideMask ) self.pickerNp = camera.attachNewNode( pickerNode ) #pickerNp.setCollideMask(AXIS_COLLISION_MASK) self.collHandler = CollisionHandlerQueue() self.collTrav = CollisionTraverser() self.collTrav.showCollisions( render ) self.collTrav.addCollider( self.pickerNp, self.collHandler ) # Bind mouse button events eventNames = ['mouse1', 'control-mouse1', 'mouse1-up'] for eventName in eventNames: self.accept( eventName, self.FireEvent, [eventName] ) #== self.selectionCol = None
def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False # self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", {"run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk"}, ) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode("ralphRay") self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[mainClass, parserClass, mapLoaderClass, modelLoaderClass])
class Picker(object): ''' classdocs ''' def __init__(self, camera, mouseWatcherNode, camNode, things): ''' Constructor ''' self.mouseWatcherNode = mouseWatcherNode self.camNode = camNode self.things = things self.pickerRay = CollisionRay() self.pickerNode = CollisionNode('mouseRay') self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerNode.addSolid(self.pickerRay) self.pickerNP = camera.attachNewNode(self.pickerNode) self.pq = CollisionHandlerQueue() self.picker = CollisionTraverser() self.picker.addCollider(self.pickerNP, self.pq) def getMouseOn(self, mouse_x, mouse_y): #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(self.camNode, mouse_x, mouse_y) self.picker.traverse(self.things.node) if self.pq.getNumEntries() > 0: #if we have hit something, sort the hits so that the closest #is first, and highlight that node self.pq.sortEntries() selectedNode = self.pq.getEntry(0).getIntoNode() selectedNodeId = selectedNode.getTag('nodeId') thingId = selectedNode.getTag('ID') mouseOnInfo = MouseOnInfo(self.things.getById(thingId), thingId, selectedNode, selectedNodeId, mouse_x, mouse_y) return mouseOnInfo
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 __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 intersect(lbase, delta, mask=None): t = time.time() root = lbase.rootnode terrain = root.getChildren()[2] terrain.setCollideMask(BitMask32.bit(1)) player = root collTrav = CollisionTraverser() #the collision traverser. we need this to perform collide in the end fromObject = player.attachNewNode(CollisionNode('colNode')) camera_pos = tuple(lbase.cameras.getPos()) lens = lbase.cameras.getChildren()[0].node().getLens() fov = np.radians(lens.getMinFov()) zpos = camera_pos[1] sw = 2. * np.abs(zpos) * np.tan(fov / 2.) rvals = np.arange(-sw/2., sw/2., delta) if mask is None: poses = [(xpos , -1 * zpos, ypos) for xpos in rvals for ypos in rvals] else: assert mask.shape == (len(rvals), len(rvals)) poses = [(xpos , -1 * zpos, ypos) for _i, xpos in enumerate(rvals) for _j, ypos in enumerate(rvals) if mask[_j, _i] < 1] print(len(poses), 'lp', len(rvals)**2) print('1a', time.time() - t) t = time.time() for p in poses: vec = camera_pos + p fromObject.node().addSolid(CollisionRay(*vec)) print('1', time.time() - t) t = time.time() #and now we turn turn of the collision for the playermodel so it wont collide with the ray or anything. player.node().setIntoCollideMask(BitMask32.allOff()) fromObject.node().setFromCollideMask(BitMask32.bit(1)) queue = CollisionHandlerQueue() collTrav.addCollider(fromObject, queue) print('2', time.time() - t) t = time.time() collTrav.traverse(root) print('3', time.time() - t) return queue
class heightChecker(): def __init__(self): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('heightChecker') self.pickerNode = render.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay(0,0,300,0,0,-1) pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNode, self.pickerQ) def getHeight(self,obj,pos): res=0 self.pickerNode.setPos(pos) self.picker.traverse(obj) if self.pickerQ.getNumEntries() > 0: self.pickerQ.sortEntries() res=self.pickerQ.getEntry(0).getSurfacePoint(render).getZ() return res
def __init__(self): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('heightChecker') self.pickerNode = render.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay(0,0,300,0,0,-1) pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNode, self.pickerQ)
def setupCollHandlers(self): ###### Collisions ###### base.cTrav = CollisionTraverser() self.collisionHandler = CollisionHandlerEvent() self.wallHandler = CollisionHandlerPusher() self.collisionHandler.addInPattern('%fn-into-%in') # this is on the other hand the relative call for the OUT event, as is when the FROM object (heart) goes OUT the INTO oject (heart). self.collisionHandler.addOutPattern('%fn-out-%in')
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 init_collide(self): from pandac.PandaModules import CollisionTraverser, CollisionNode from pandac.PandaModules import CollisionHandlerQueue, CollisionRay 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): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('mouseRay') pickerCamN = base.camera.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(pickerCamN, self.pickerQ) self.accept('mouse1',self.pick)
def __init__(self): self.accept('makePickable', self.makePickable) self.accept('switchLevelRequest', self.switchLevel) self.level = 0 #create traverser sandbox.pickTrav = CollisionTraverser() #create collision ray self.createRay(self, sandbox.base.camera, name="mouseRay", show=True) #initialize mousePick #self.accept('mouse1-up', self.mousePick, [1,self.queue]) self.accept('mouse1', self.mousePick, [1, self.queue])
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 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')
class mouseControl(DirectObject): def __init__(self): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('mouseRay') pickerCamN = base.camera.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(pickerCamN, self.pickerQ) self.accept('mouse1',self.pick) def pick(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.picker.traverse(render) for i in xrange(self.pickerQ.getNumEntries()): entry=self.pickerQ.getEntry(i) player.control('replace_wp', ('goto', Vec3(entry.getSurfacePoint(render))))
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 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()
class Gui3D: 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 mouse_click(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.gui_traverser.traverse(render) num_entries = self.handler.getNumEntries() if num_entries > 0: self.handler.sortEntries() entry = self.handler.getEntry(0) selected = entry.getIntoNodePath() selected_type = selected.getTag("type") if selected_type == "character": self.game_data.select_character(int(selected.getTag("id"))) elif selected_type == "ground": self.game_data.click_point(entry.getSurfacePoint(render))
def setupCollisions(self): self.coll_trav = CollisionTraverser() self.player_ground_sphere = CollisionSphere(0, 1.5, -1.5, 1.5) self.player_ground_col = CollisionNode('playerSphere') self.player_ground_col.addSolid(self.player_ground_sphere) # bitmasks self.player_ground_col.setFromCollideMask(BitMask32.bit(0)) self.player_ground_col.setIntoCollideMask(BitMask32.allOff()) self.world.setCollideMask(BitMask32.bit(0)) self.water.setCollideMask(BitMask32.bit(0)) # and done self.player_ground_col_np = self.player.attachNewNode(self.player_ground_col) self.player_ground_handler = CollisionHandlerQueue() self.coll_trav.addCollider(self.player_ground_col_np, self.player_ground_handler) # DEBUG if self.debug: self.player_ground_col_np.show() self.coll_trav.showCollisions(self.render)
def initCollisionTest(self): self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern('into-%in') base.cTrav = CollisionTraverser('test name') if False: base.cTrav.showCollisions(render) cName = 'BallCollNode' cSphere = CollisionSphere(0, 0, 0, 1.0) cNode = CollisionNode(cName) cNode.addSolid(cSphere) cNodePath = self.ball.modelNode.attachNewNode(cNode) base.cTrav.addCollider(cNodePath, self.collHandEvent)
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)
class Gui3D: 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 mouse_click(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.gui_traverser.traverse(render) num_entries = self.handler.getNumEntries() if num_entries > 0: self.handler.sortEntries() entry = self.handler.getEntry(0) selected = entry.getIntoNodePath() selected_type = selected.getTag("type") if selected_type == "character": self.game_data.select_character(int(selected.getTag("id"))) elif selected_type == "ground": self.game_data.click_point(entry.getSurfacePoint(render))
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): ShowBase.__init__(self) self.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerEvent() self.gameMode = "Exploring" self.countNpc = 0 self.npcName = [] self.npcX = [] self.npcY = [] self.talkies = False self.txtConvo = OnscreenText("",style=1, align = TextNode.ALeft, fg=(1,1,1,1), pos = (-1.1,-0.6,0), scale = 0.1) self.txtConvoOp1 = OnscreenText("",style=1, align = TextNode.ALeft, fg=(1,1,1,1), pos = (-1.1,-0.65,0), scale = 0.1) self.txtConvoOp2 = OnscreenText("",style=1, align = TextNode.ALeft, fg=(1,1,1,1), pos = (-1.1,-0.7,0), scale = 0.1) self.txtConvoOp3 = OnscreenText("",style=1, align = TextNode.ALeft,fg=(1,1,1,1), pos = (-1.1,-0.75,0), scale = 0.1) self.convoLineSelected = 0 self.keyboardSetup() self.cameraDistance = -50 self.camHeight = 25 self.camXAngle = 180 self.camYAngle = -15 self.camZAngle = 0 self.corrAngle = math.pi / 2 self.createPlayer() self.terrainSize = 20 self.drawTerrain() self.placeModels() self.collides() #cTrav.showCollisions(render) self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") self.taskMgr.add(self.step, "GameStep") self.drawUI()
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 initialize_collision_handling(self): self.collision_handling_mutex = Lock() self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode(self.attach_object.name + "_collision_node") self.groundCol.setIntoCollideMask(BitMask32.bit(0)) self.groundCol.setFromCollideMask(BitMask32.bit(0)) self.groundCol.addSolid(self.groundRay) self.groundColNp = self.attach_object.render_model.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler)
def gameLoop(self, task): #print "game task" # ***************** SET CAMERA ****************** base.taskMgr.add(self.rotateCamera, "rotateCamera") self.game.setPlayer(self.player) # ***************** PICKABLE SHITS *************** # setup the pickable suqre planes on the board planes = [] id_plane = 0 for k in range(3): for i in range(3): #print "adding plane: ", id_plane p = addPlane(3) p.setPos(3 * i - 2.5, 3 * k - 2.5, 3.1) p.setTag('pickable', str(id_plane)) p.hide() planes.append(p) id_plane += 1 # set picks pickerNode = CollisionNode('mouseRay') pickerNP = self.cam.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) #pickerNP.show() self.rayQueue = CollisionHandlerQueue() self.cTrav = CollisionTraverser() self.cTrav.addCollider(pickerNP, self.rayQueue) # set action in case of pick self.accept('mouse1', self.picked)
def __init__( self, bit=[PICKABLE] ): global OBJECTIDMAPPING #Since we are using collision detection to do picking, we set it up like #any other collision detection system with a traverser and a handler self.picker = CollisionTraverser() #Make a traverser self.pq = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pickerNode = CollisionNode('mouseRay') #Attach that node to the camera since the ray will need to be positioned #relative to it self.pickerNP = base.camera.attachNewNode(self.pickerNode) #Everything to be picked will use bit 1. This way if we were doing other #collision we could seperate it self.pickerNode.setFromCollideMask(bitMaskOr(bit)) self.pickerRay = CollisionRay() #Make our ray self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node #Register the ray as something that can cause collisions self.picker.addCollider(self.pickerNP, self.pq)
def __init__(self, camera, mouseWatcherNode, camNode, things): ''' Constructor ''' self.mouseWatcherNode = mouseWatcherNode self.camNode = camNode self.things = things self.pickerRay = CollisionRay() self.pickerNode = CollisionNode('mouseRay') self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerNode.addSolid(self.pickerRay) self.pickerNP = camera.attachNewNode(self.pickerNode) self.pq = CollisionHandlerQueue() self.picker = CollisionTraverser() self.picker.addCollider(self.pickerNP, self.pq)