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, *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 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 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 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):
self.line_dir = NodePath()
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.model = loader.loadModel("../models/chest.egg")
self.model_node = NodePath("sdfafd")
self.model.reparentTo(self.model_node)
self.model_node.reparentTo(render)
#
# self.text_node = TextNode("battle_text")
# self.text_node.setText("TEXTYTEXTYTEXTTEXT")
# self.text_node_path = render.attachNewNode(self.text_node)
# self.text_node_path.reparentTo(render)
# self.text_node_path.setPos(0,0,4)
# self.text_node_path.setHpr(0,0,0)
# self.text_node_path.setScale(1)
# #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha)
# self.text_node.setTextColor((1,1,1,1))
# self.text_node.setAlign(TextNode.ALeft)
self.placement_ghost = EditorObjects.PlacementGhost(
0, "tower", base.object_scale)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
self.input_init()
self.pickable = None
def setMousePicker(self):
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
self.selectable = render.attachNewNode("selectable")
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):
self.pickerNode = CollisionNode('RepairMousePicker.pickerNode')
self.pickerNP = base.cam2d.attachNewNode(self.pickerNode)
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.collisionTraverser = CollisionTraverser()
self.collisionHandler = CollisionHandlerQueue()
self.collisionTraverser.addCollider(self.pickerNP,
self.collisionHandler)
self.clearCollisionMask()
self.orthographic = True
def __init__(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_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)
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)
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__(self, actor):
"""Initialise the camera, setting it to follow 'actor'.
Arguments:
actor -- The Actor that the camera will initially follow.
"""
self.actor = actor
self.prevtime = 0
# The camera's controls:
# "left" = move the camera left, 0 = off, 1 = on
# "right" = move the camera right, 0 = off, 1 = on
self.controlMap = {"left": 0, "right": 0}
taskMgr.add(self.move, "cameraMoveTask")
# Create a "floater" object. It is used to orient the camera above the
# target actor's head.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Set up the camera.
base.disableMouse()
base.camera.setPos(self.actor.getX(), self.actor.getY() + 2, 2)
# uncomment for topdown
#base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2)
#base.camera.setHpr(180, -50, 0)
# A CollisionRay beginning above the camera and going down toward the
# ground is used to detect camera collisions and the height of the
# camera above the ground. A ray may hit the terrain, or it may hit a
# rock or a tree. If it hits the terrain, we detect the camera's
# height. If it hits anything else, the camera is in an illegal
# position.
self.cTrav = CollisionTraverser()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0, 0, 1000)
self.groundRay.setDirection(0, 0, -1)
self.groundCol = CollisionNode('camRay')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setFromCollideMask(BitMask32.bit(1))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = base.camera.attachNewNode(self.groundCol)
self.groundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.groundColNp, self.groundHandler)
def __init__(self):
self.keys = {}
for char in string.ascii_lowercase:
self.keys[char] = BUTTON_UP
def makeKeyPair(ch):
def keyUp():
self.keys[ch] = BUTTON_DOWN
#print "%s UP" % (ch)
def keyDown():
self.keys[ch] = BUTTON_UP
#print "%s DOWN" % (ch)
return [keyUp, keyDown]
keyPair = makeKeyPair(char)
self.accept(char, keyPair[0])
self.accept(char + '-up', keyPair[1])
self.accept('mouse1', self.leftClick)
self.accept('mouse1-up', self.leftClickUp)
self.accept('mouse2', self.mClick)
self.accept('mouse2-up', self.mClickUp)
self.accept('mouse3', self.rightClick)
self.accept('mouse3-up', self.rightClickUp)
self.mouse1Down = False
self.mouse2Down = False
self.mouse3Down = False
self.trackMouseTimeOld = 0
self.trackMouseX = 0
self.trackMouseY = 0
self.trackMouse_Mouse1DownOld = False
self.trackMouse_Mouse2DownOld = False
self.trackMouse_Mouse3DownOld = False
taskMgr.add(self.trackMouseTask, 'trackMouseTask')
#
base.cTrav = CollisionTraverser()
self.pickerQ = CollisionHandlerQueue()
self.pickerCollN = CollisionNode('mouseRay')
self.pickerCamN = base.camera.attachNewNode(self.pickerCollN)
self.pickerCollN.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerCollN.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerCamN, self.pickerQ)
self.objectUnderCursor = None
def __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 __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 placeItem(self, item):
# Add ground collision detector to the health item
self.cTrav1 = CollisionTraverser()
self.collectGroundRay = CollisionRay()
self.collectGroundRay.setOrigin(0,0,300)
self.collectGroundRay.setDirection(0,0,-1)
self.collectGroundCol = CollisionNode('colRay')
self.collectGroundCol.addSolid(self.collectGroundRay)
self.collectGroundCol.setFromCollideMask(BitMask32.bit(1))
self.collectGroundCol.setIntoCollideMask(BitMask32.allOff())
self.collectGroundColNp = item.attachNewNode(self.collectGroundCol)
self.collectGroundHandler = CollisionHandlerQueue()
base.cTrav1.addCollider(self.collectGroundColNp, self.collectGroundHandler)
placed = False;
while placed == False:
# re-randomize position
item.setPos(-random.randint(-350,300),-random.randint(-100,150),0)
base.cTrav1.traverse(render)
# Get Z position from terrain collision
entries = []
for j in range(self.collectGroundHandler.getNumEntries()):
entry = self.collectGroundHandler.getEntry(j)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
item.setZ(entries[0].getSurfacePoint(render).getZ()+4)
placed = True
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, 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, name, char_rig):
from pandac.PandaModules import CollisionNode, CollisionRay, CollisionSphere
self.name = name
self.char_rig = char_rig
self.actor = Actor('models/robot3', {'run': 'models/robot3-run'})
self.actor.setPlayRate(2.0, 'run')
self.actor.reparentTo(self.char_rig)
self.actor.setCompass()
self.actor.setCollideMask(0)
self.actor_from_floor = self.actor.attachNewNode(
CollisionNode('blockchar_floor'))
self.actor_from_floor.node().addSolid(
CollisionRay(0, 0, 0.25, 0, 0, -10))
self.actor_from_floor.node().setCollideMask(0)
self.actor_from_floor.node().setFromCollideMask(FLOOR_MASK)
self.actor_from_obstacle = self.actor.attachNewNode(
CollisionNode('blockchar_obstacle'))
self.actor_from_obstacle.node().addSolid(
CollisionSphere(0, 0, 0.35, 0.35))
self.actor_from_obstacle.node().setCollideMask(0)
self.actor_from_obstacle.node().setFromCollideMask(OBSTACLE_MASK)
self.actor_from_zone = self.actor.attachNewNode(
CollisionNode('blockchar_zone'))
self.actor_from_zone.node().addSolid(CollisionSphere(0, 0, 0.55, 0.55))
self.actor_from_zone.node().setCollideMask(0)
self.actor_from_zone.node().setFromCollideMask(ZONE_MASK)
self.move_forward = False
self.move_left = False
self.move_backward = False
self.move_right = False
self.moving = False
self.spinning = False
self.move_prev_time = None
# Based on a jogging speed of 6mph
self.move_speed = 2.7 # m/s
def __init__(self, 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])
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")
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 addCogGroundCollision(self, cog=None, ent=None):
if ent == None:
ent = cog.getCog()
collGround = ent.attachNewNode(CollisionNode('coll_ground'))
collGround.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1))
collGround.node().setIntoCollideMask(BitMask32.allOff())
collGround.node().setFromCollideMask(Globals.WallBitmask)
collHdlF.addCollider(collGround, ent)
base.cTrav.addCollider(collGround, collHdlF)
def Coll(self):
base.cTrav = CollisionTraverser()
self.collHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collHandler)
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 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 attachCollisionRay(self, name, ox, oy, oz, dx, dy, dz, fromCollide,
intoCollide):
from pandac.PandaModules import CollisionRay
from pandac.PandaModules import CollisionNode
coll = CollisionRay.CollisionRay(ox, oy, oz, dx, dy, dz)
collNode = CollisionNode.CollisionNode(name)
collNode.addSolid(coll)
collNode.setFromCollideMask(fromCollide)
collNode.setIntoCollideMask(intoCollide)
collNodePath = self.attachNewNode(collNode)
return collNodePath
def 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 Collision(self):
self.mpos3d=0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
base.cTrav = CollisionTraverser()
self.collHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collHandler)
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()
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):
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 __init__(self,model):
# 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.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.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# 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)
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 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 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 addDropCollision(self, drop):
collSph = drop.attachNewNode(CollisionNode('coll_drop'))
collSph.node().addSolid(CollisionSphere(0, 0, 0, 1))
collSph.node().setIntoCollideMask(BitMask32.allOff())
collSph.node().setFromCollideMask(Globals.DropBitmask)
collGround = drop.attachNewNode(CollisionNode('coll_drop_ground'))
collGround.node().addSolid(CollisionRay(0, 0, 0, 0, 0, -1))
collGround.node().setIntoCollideMask(BitMask32.allOff())
collGround.node().setFromCollideMask(Globals.WallBitmask)
collGround.show()
collHdlF.addCollider(collGround, drop)
base.cTrav.addCollider(collSph, collHdl)
base.cTrav.addCollider(collGround, collHdlF)
self.accept("coll_drop-into", self.handleDropCollision)
self.accept("coll_drop-out", self.completeCollision)
def 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 setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def __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 __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, game_data, gfx_manager):
self.game_data = game_data
self.gui_traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.selectable_objects = {}
for cid, model in gfx_manager.character_models.items():
new_collision_node = CollisionNode('person_' + str(cid))
new_collision_node.addSolid(CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5))
new_collision_nodepath = model.attachNewNode(new_collision_node)
new_collision_nodepath.setTag("type","character")
new_collision_nodepath.setTag("id",str(cid))
picker_node = CollisionNode('mouseRay')
picker_np = camera.attachNewNode(picker_node)
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.gui_traverser.addCollider(picker_np, self.handler)
self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
self.floor_np = render.attachNewNode(CollisionNode('floor'))
self.floor_np.setTag("type", "ground")
self.floor_np.node().addSolid(self.floor)
def __init__(self):
''' Should the traverser be shared? '''
LOG.debug("[Selector] Initializing")
# The collision traverser does the checking of solids for collisions
self.cTrav = CollisionTraverser()
# The collision handler queue is a simple handler that records all
# detected collisions during traversal
self.cHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerNP, self.cHandler)
# Start listening to clicks
self.resume()
def createRay(self,
obj,
ent,
name,
show=False,
x=0,
y=0,
z=0,
dx=0,
dy=0,
dz=-1):
#create queue
obj.queue = CollisionHandlerQueue()
#create ray
obj.rayNP = ent.attachNewNode(CollisionNode(name))
obj.ray = CollisionRay(x, y, z, dx, dy, dz)
obj.rayNP.node().addSolid(obj.ray)
obj.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask())
sandbox.pickTrav.addCollider(obj.rayNP, obj.queue)
if show:
obj.rayNP.show()
def createCollisionHandlers(self):
# Create a new collision traverser instance. We will use this to determine
# if any collisions occurred after performing movement.
self.cTrav = CollisionTraverser()
camGroundRay = CollisionRay()
camGroundRay.setOrigin(0, 0, 1000)
camGroundRay.setDirection(0, 0, -1)
camGroundCol = CollisionNode('camRay')
camGroundCol.addSolid(camGroundRay)
camGroundCol.setFromCollideMask(BitMask32.bit(0))
camGroundCol.setIntoCollideMask(BitMask32.allOff())
camGroundColNp = base.camera.attachNewNode(camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(camGroundColNp, self.camGroundHandler)
# register the collision pusher
self.pusher = CollisionHandlerPusher()
# register collision event pattern names
self.pusher.addInPattern('col-%fn-into')
def __init__(self, name, world, pos):
ActorNode.__init__(self, name)
self.nodePath = NodePath(self)
self.world = world
# init the model or the Actor
self.model = self.getModel()
self.model.reparentTo(self.nodePath)
self.nodePath.setPos(*pos)
self.prevPos = self.nodePath.getPos()
# collision detection
fromObject = self.nodePath.attachNewNode(CollisionNode(name))
self.addSolids(fromObject)
fromObject.show()
# setup the ground ray, needed for detecting the ground
groundRay = CollisionRay()
groundRay.setOrigin(0, 0, 1000)
groundRay.setDirection(0, 0, -1)
groundCol = CollisionNode('groundRay')
groundCol.addSolid(groundRay)
groundCol.setFromCollideMask(BitMask32.bit(0))
groundCol.setIntoCollideMask(BitMask32.allOff())
groundColNp = base.camera.attachNewNode(groundCol)
self.groundHandler = CollisionHandlerQueue()
self.world.cTrav.addCollider(groundColNp, self.groundHandler)
# self.world.cTrav.addCollider(fromObject, self.world.pusher)
# self.world.pusher.addCollider(fromObject, self.nodePath)
self.postInit()
#** the avatar's fallout sensor - stuff already seen in former snippets, but this time we'll use it for more that to detect the fallout impact force, so we'll add another mask to look out
avatarSensor = avatarNP.attachNewNode(CollisionNode('yolkysensor'))
cs = CollisionSphere(0, 0, 0, 1.2)
avatarSensor.node().addSolid(cs)
# here the masking: note that this sensor will look for floor bashing but also for other geometries masked with TRIGGER_MASK.
avatarSensor.node().setFromCollideMask(FLOOR_MASK | TRIGGER_MASK)
avatarSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)
#** here's how to read the events fired by the 'sensor' while colliding with geometry we enable to collide with it.
collisionEvent.addInPattern('%fn-into')
collisionEvent.addOutPattern('%fn-out')
#** the floor ray collider for the avatar
avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay'))
avatarRay.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1))
avatarRay.node().setFromCollideMask(FLOOR_MASK)
avatarRay.node().setIntoCollideMask(BitMask32.allOff())
#** This is the scene map - we'll gather off here almost every element of the map: scenery, ground colliders, walls, and also triggers and spawn points. See the .blend source for details on the scene components.
scene = loader.loadModel("windmill")
scene.reparentTo(render)
scene.setCollideMask(BitMask32.allOff())
scene.setScale(10)
# Let's mask our main collision surfaces
floorcollider = scene.find("**/floor0/floor_collide*")
floorcollider.node().setIntoCollideMask(FLOOR_MASK)
wallcollider = scene.find("**/wall0/wall_collide*")
wallcollider.node().setIntoCollideMask(WALL_MASK)
class MousePicker(p3d.SingleTask):
"""
Class to represent a ray fired from the input camera lens using the mouse.
"""
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 OnUpdate(self, task, x=None, y=None):
# Update the ray's position
if self.mouseWatcherNode.hasMouse():
mp = self.mouseWatcherNode.getMouse()
x, y = mp.getX(), mp.getY()
if x is None or y is None:
return
self.pickerRay.setFromLens(self.camera.node(), x, y)
# Traverse the hierarchy and find collisions
self.collTrav.traverse(self.rootNp)
if self.collHandler.getNumEntries():
# If we have hit something, sort the hits so that the closest is first
self.collHandler.sortEntries()
collEntry = self.collHandler.getEntry(0)
node = collEntry.getIntoNode()
# If this node is different to the last node, send a mouse leave
# event to the last node, and a mouse enter to the new node
if node != self.node:
if self.node is not None:
messenger.send('%s-mouse-leave' % self.node.getName(),
[self.collEntry])
messenger.send('%s-mouse-enter' % node.getName(), [collEntry])
# Send a message containing the node name and the event over name,
# including the collision entry as arguments
messenger.send('%s-mouse-over' % node.getName(), [collEntry])
# Keep these values
self.collEntry = collEntry
self.node = node
elif self.node is not None:
# No collisions, clear the node and send a mouse leave to the last
# node that stored
messenger.send('%s-mouse-leave' % self.node.getName(),
[self.collEntry])
self.node = None
def FireEvent(self, event):
"""
Send a message containing the node name and the event name, including
the collision entry as arguments.
"""
if self.node is not None:
messenger.send('%s-%s' % (self.node.getName(), event),
[self.collEntry])
def GetFirstNodePath(self):
"""
Return the first node in the collision queue if there is one, None
otherwise.
"""
if self.collHandler.getNumEntries():
collEntry = self.collHandler.getEntry(0)
return collEntry.getIntoNodePath()
return None
