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, 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 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 __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 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)
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 __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")
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 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 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 __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_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)
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 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 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 _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 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 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')
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 __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, 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)
def __init__(self):
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
self.selected = -1
self.selected_node = None
self.selecteds = []
self.multi_select = False
self.multi_selecting = False
self.select_box = NodePath()
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.DO = DirectObject()
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-battle', self.col_in_object)
self.DO.accept('mray-out-battle', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
if base.client == False:
self.col_handler.addInPattern("%(player)ft-into-%(player)it")
self.col_handler.addInPattern("%(type)ft-into-%(type)it")
self.DO.accept('army-into-battle', self.col_army_against_battle)
self.DO.accept('army-into-tower', self.col_army_against_tower)
self.DO.accept('1-into-2', self.col_p1_into_p2)
self.pickable = None
self.DO.accept('mouse1', self.mouse_click, ["down"])
self.DO.accept('mouse1-up', self.mouse_click, ["up"])
self.DO.accept('mouse3-up', self.mouse_order)
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.task_select_check, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("models/chest.egg")
self.model.reparentTo(render)
self.model.hide()
cm = CardMaker("blah")
cm.setFrame(-100, 100, -100, 100)
pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1)
pnode.hide()
def __init__(self):
base.disableMouse()
base.camLens.setFar(100)
self.parserClass = Parser.Parser() # Making the required instances
self.mapLoaderClass = mapLoader.mapLoader(self)
self.gameObjects = {}
self.gameObjectID = 0
self.mapX = self.mapLoaderClass.mapConfigParser.getint(
"map", "width") - 1 # Name says it all really
self.mapY = self.mapLoaderClass.mapConfigParser.getint(
"map", "height") - 1
self.modelLoaderClass = modelLoader.modelLoader(self)
self.cameraClass = stratCam.CameraHandler(self)
self.mouseClass = stratCam.mouseHandler(self)
self.GUI = stratCam.GUI(self)
# self.GUI = stratCam.GUI(self)
self.priorities = priorities.priorities()
base.setFrameRateMeter(True)
###############
base.cTrav2 = CollisionTraverser('world2')
# base.cTrav2.showCollisions(render)
self.heightRay = CollisionRay(
) # A collision ray, used for getting the height of the terrain
self.heightRay.setOrigin(0, 0, 100)
self.heightRay.setDirection(0, 0, -1)
self.heightCol = CollisionNode('unit Ray')
self.heightCol.addSolid(self.heightRay)
self.heightCol.setTag('units', 'ray1')
self.heightCol.setFromCollideMask(BitMask32.bit(0))
# self.heightCol.setIntoCollideMask(BitMask32.allOff())
self.heightColNp = render.attachNewNode(self.heightCol)
self.heightColNp.setPos(2, 2, 0)
self.heightHandler = CollisionHandlerQueue()
base.cTrav2.addCollider(self.heightColNp, self.heightHandler)
###############
# myFrame = DirectFrame(frameColor=(0, 0, 0, 1),
# frameSize=(-0.25, 0.25, -1, 1),
# pos=(1.08, 0, 0))
# button = DirectButton(text = ("button"), scale = 0.1)
# button.reparentTo(myFrame)
# button.setPos(0, 0, 0.9)
self.grids = astar.grid(self)
self.unitHandler = unitHandler.world(self)
# self.unitHandler.addUnit(0, (10,10,5), self)
# self.unitHandler.addUnit(1, (6,10,5), self)
# self.unitHandler.moveTo(self, (6, 34), 0)
# self.unitHandler.moveTo(self, (34, 30), 1)
self.buildingHandler = buildingHandler.buildingHandler(self)
self.tileSelected = (0, 0)
taskMgr.add(self.tskCheckWalls, "Wall checking")
taskMgr.add(self.priorities.jobTask, "Jobs", extraArgs=[self])
self.loadLight()
self.accept("escape", sys.exit)
self.accept("1", self.unitHandler.addUnit2, extraArgs=[0, self])
self.accept("2", self.unitHandler.addUnit2, extraArgs=[1, self])
self.accept("3", self.unitHandler.addUnit2, extraArgs=[2, self])
self.accept("enter",
self.buildingHandler.addBuilding2,
extraArgs=[self, 0])
self.accept("p", self.priorities.addJob)
print 'END OF GAMEMAIN.PY!'
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from tower import *
import collision
import player
import tower
import troop
from pathfindingMesh import *
"""File to handle mouse picking, receiving a collision object
to add the mouse ray to the collision handler
"""
pickerNode = CollisionNode('mouseRay_cnode')
pickerNP = base.camera.attachNewNode(pickerNode)
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
#pickerNode.setFromCollideMask(BitMask32(0x1))
#pickerNode.setFromCollideMask(BitMask32(0x2))
collision.addCollider(pickerNP)
#A struct like to solve reference pass problems
class MousePicking:
mpos = None
pickingEnabled = True
towerFollowMouse = False
mousePickingOnTower = False
mousePickingOnTroop = False
collindingNode = None
gameHUD = None
lastClickedTower = None
#** Collision masks
FLOOR_MASK = BitMask32.bit(1)
MASK_OFF = BitMask32.allOff()
#** Our steering avatar
avatarNP = base.render.attachNewNode(ActorNode('smileyNP'))
avatarNP.reparentTo(base.render)
avatar = loader.loadModel('smiley')
avatar.reparentTo(avatarNP)
avatar.setPos(0, 0, 1)
avatar.setCollideMask(MASK_OFF)
avatarNP.setPos(0, 0, 15)
#** Stick and set the ray collider to the avatar
raygeometry = CollisionRay(0, 0, 2, 0, 0, -1)
avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay'))
avatarRay.node().addSolid(raygeometry)
# let's mask our floor FROM collider
avatarRay.node().setFromCollideMask(FLOOR_MASK)
avatarRay.node().setIntoCollideMask(MASK_OFF)
#** This is the terrain map - differently than what we used to in previous steps, the collision solids will be loaded separately. See this below.
terrain = loader.loadModel("oc3ground")
terrain.reparentTo(render)
terrain.setCollideMask(MASK_OFF)
terrain.setScale(10)
#** Let's load ands mask our collision surfaces - the task is repeated 2 times: one for a single-mesh collider and the other for the octreefied one and the two colliders data is conveniently stored in the dictionary 'floorcolliderdata', for a later usage, to show the performance difference between the two setups. The important thing to know here is that when your collision model mesh will be octreefied, the octree script will change a bit the mesh naming, changing indeed the root name, that we use here to find its geometry inside the egg file, and mask it to be recognized by the floor collision handler. In a octreefied mesh the root name will always be (at the date I'm writing and until the script will changes) "octree-root" - just be advised.
# the colliders storage
