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, 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
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 __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 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 _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, 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 __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()
