def setUpCarCollider(self):
self.carCollideTrav = CollisionTraverser()
base.cTrav = self.carCollideTrav
self.handler = CollisionHandlerQueue()
self.carRay = CollisionRay(self.carPositionX, self.carPositionY,
self.carPositionZ, 0, 0, -1)
self.carForwardHandler = CollisionHandlerQueue()
# so that it doesn't collide with things forward and backward.
degToRad = math.pi / 180
(xDir, yDir, zDir) = self.findCarFrontDir()
self.carRayForward = CollisionRay(self.carPositionX, self.carPositionY,
self.carPositionZ, xDir, yDir, zDir)
self.carForwardCollision = CollisionNode("forwardCollision")
self.carForwardCollision.addSolid(self.carRayForward)
self.carForwardCollision.setIntoCollideMask(CollideMask.allOff())
self.carForwardCollisionNode = self.car.attachNewNode(
self.carForwardCollision)
(centerX,
centerY) = self.findActualCenter(0, 0, self.adjustedXForCenter,
self.adjustedYForCenter, self.carYaw)
self.carRayForward.setOrigin(5, 10, 5)
self.carCollision = CollisionNode("groundCollision")
self.carCollision.addSolid(self.carRay)
self.carCollision.setIntoCollideMask(CollideMask.allOff())
self.carCollisionNode = self.car.attachNewNode(self.carCollision)
self.carCollideTrav.addCollider(self.carCollisionNode, self.handler)
self.carCollideTrav.addCollider(self.carForwardCollisionNode,
self.carForwardHandler)
self.carForwardCollisionNode.show()
def initializeSmartCameraCollisions(self):
if self.initialized:
return
self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav')
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode)
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.camCollisionQueue = CollisionHandlerQueue()
self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue)
self.ccSphere = CollisionSphere(0, 0, 0, 1)
self.ccSphereNode = CollisionNode('ccSphereNode')
self.ccSphereNode.addSolid(self.ccSphere)
self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode)
self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode.setIntoCollideMask(BitMask32.allOff())
self.camPusher = CollisionHandlerPusher()
self.camPusher.addCollider(self.ccSphereNodePath, base.camera)
self.camPusher.setCenter(base.localAvatar)
self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav')
self.ccSphere2 = self.ccSphere
self.ccSphereNode2 = CollisionNode('ccSphereNode2')
self.ccSphereNode2.addSolid(self.ccSphere2)
self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2)
self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask)
self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff())
self.camPusher2 = CollisionHandlerPusher()
self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2)
self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera)
self.camPusher2.setCenter(base.localAvatar)
self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode')
self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRayNode = CollisionNode('ccRayNode')
self.ccRayNode.addSolid(self.ccRay)
self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode)
self.ccRayBitMask = CIGlobals.FloorBitmask
self.ccRayNode.setFromCollideMask(self.ccRayBitMask)
self.ccRayNode.setIntoCollideMask(BitMask32.allOff())
self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor')
self.camFloorCollisionQueue = CollisionHandlerQueue()
self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue)
self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor')
self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0)
self.ccRay2Node = CollisionNode('ccRay2Node')
self.ccRay2Node.addSolid(self.ccRay2)
self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node)
self.ccRay2BitMask = CIGlobals.FloorBitmask
self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask)
self.ccRay2Node.setIntoCollideMask(BitMask32.allOff())
self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode')
self.camFloorCollisionBroadcaster = CollisionHandlerFloor()
self.camFloorCollisionBroadcaster.setInPattern('on-floor')
self.camFloorCollisionBroadcaster.setOutPattern('off-floor')
self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath)
self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster)
self.initialized = True
def create(self):
self.mPickerTraverser = CollisionTraverser()
self.mCollisionQue = CollisionHandlerQueue()
self.mPickRay = CollisionRay()
self.mPickRay.setOrigin(base.camera.getPos(base.render))
self.mPickRay.setDirection(
base.render.getRelativeVector(base.camera, Vec3(0, 1, 0)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode(self.nodeName)
self.mPickNode.addSolid(self.mPickRay)
#Attach that node to the camera since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = base.camera.attachNewNode(self.mPickNode)
#we'll use what panda calls the "from" node. This is reall a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
self.mPickNode.setFromCollideMask(BitMask32(1))
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQue)
#Setup 2D picker
self.mPickerTraverser2D = CollisionTraverser()
self.mCollisionQue2D = CollisionHandlerQueue()
self.mPickNode2D = CollisionNode('2D PickNode')
self.mPickNode2D.setFromCollideMask(BitMask32(1))
self.mPickNode2D.setIntoCollideMask(BitMask32.allOff())
self.mPick2DNP = base.camera2d.attachNewNode(self.mPickNode2D)
self.mPickRay2D = CollisionRay()
self.mPickNode2D.addSolid(self.mPickRay2D)
self.mPickerTraverser2D.addCollider(self.mPick2DNP,
self.mCollisionQue2D)
if self.showCollisions:
self.mPickerTraverser.showCollisions(base.render)
self.mPickerTraverser2D.showCollisions(base.aspect2d)
def test_collision_traverser_pickle():
from direct.stdpy.pickle import dumps, loads
handler = CollisionHandlerQueue()
collider1 = NodePath(CollisionNode("collider1"))
collider2 = NodePath(CollisionNode("collider2"))
trav = CollisionTraverser("test123")
trav.respect_prev_transform = True
trav.add_collider(collider1, handler)
trav.add_collider(collider2, handler)
trav = loads(dumps(trav, -1))
assert trav.respect_prev_transform is True
assert trav.name == "test123"
assert trav.get_num_colliders() == 2
collider1 = trav.get_collider(0)
collider2 = trav.get_collider(1)
assert collider1.name == "collider1"
assert collider2.name == "collider2"
# Two colliders must still be the same object; this only works with our own
# version of the pickle module, in direct.stdpy.pickle.
assert trav.get_handler(collider1) == trav.get_handler(collider2)
def __init__(self, ip, port, verbose=False):
super().__init__()
# Set up mouse input
base.cTrav = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.mouseHandler = MouseHandler()
self.taskMgr.add(self.inputTask, "InputTask")
# Set up the UI
self.fonts = hud.hud.Fonts()
self._scene = None
# Set up audio
self.audioMaster = audio.AudioMaster()
# Set up the NetworkManager
self.client = protocol.client.Client(ip, port, verbose)
instr = networkInstructions.NetworkInstructions(self)
self.client.add_observer(instr)
self.clientActions = self.client.clientActions
self.gameState = self.client.state
# Connect to the server
self.scene = hud.connection.ConnectionUI()
self.connectionManager = ConnectionManager((ip, port), self, self.scene)
self.connectionManager.tryConnect()
self.taskMgr.add(self.networkUpdateTask, "NetworkUpdateTask")
def __init__(self):
colliderNode = CollisionNode(self.colliderName + "WallCollider")
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3))
self.collider = self.root.attachNewNode(colliderNode)
self.collider.setPythonTag(TAG_OWNER, self)
colliderNode.setFromCollideMask(MASK_WALLS)
colliderNode.setIntoCollideMask(0)
self.collider.setZ(self.height * 0.5)
base.pusher.addCollider(self.collider, self.root)
base.traverser.addCollider(self.collider, base.pusher)
self.ray = CollisionRay(0, 0, self.height / 2, 0, 0, -1)
rayNode = CollisionNode(self.colliderName + "Ray")
rayNode.addSolid(self.ray)
rayNode.setFromCollideMask(MASK_FLOORS)
rayNode.setIntoCollideMask(0)
self.rayNodePath = self.root.attachNewNode(rayNode)
self.rayQueue = CollisionHandlerQueue()
base.traverser.addCollider(self.rayNodePath, self.rayQueue)
def setupMouseCollision(self):
""" """
#Since we are using collision detection to do picking, we set it up
#any other collision detection system with a traverser and a handler
self.mPickerTraverser = CollisionTraverser() #Make a traverser
self.mCollisionQueue = CollisionHandlerQueue()
#create a collision solid ray to detect against
self.mPickRay = CollisionRay()
#self.mPickRay.setOrigin(base.camera.getPos(render))
#self.mPickRay.setDirection(render.getRelativeVector(base.camera, Vec3(0,1,0)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode('pickRay')
self.mPickNode.addSolid(self.mPickRay)
#Attach that node to the camera since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = base.camera.attachNewNode(self.mPickNode)
#well use what panda calls the "from" node. This is reall a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
self.mPickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQueue)
def checkcmcd(objcm1, objcm2, toggleplot=False):
"""
detect the collision between collision models
:return: True or False
author: weiwei, Toyonaka
date: 20190312
"""
oocnp = NodePath("collision nodepath")
obj1cnp = objcm1.copycdnpTo(oocnp)
obj2cnp = objcm2.copycdnpTo(oocnp)
if toggleplot:
oocnp.reparentTo(base.render)
obj1cnp.show()
obj2cnp.show()
ctrav = CollisionTraverser()
chan = CollisionHandlerQueue()
ctrav.addCollider(obj1cnp, chan)
ctrav.traverse(oocnp)
if chan.getNumEntries() > 0:
return True
else:
return False
def __init__(self, cr):
DistributedObject.__init__(self, cr)
#self.model = loader.loadModel('environment')
#self.model.setZ(0)
#self.builder = Builder(self, "map.txt", "development")
plane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
cnode = CollisionNode('cnode')
cnode.setIntoCollideMask(BitMask32.bit(1))
cnode.setFromCollideMask(BitMask32.bit(1))
cnode.addSolid(plane)
self.planeNP = self.model.attachNewNode(cnode)
self.planeNP.show()
# Setup a traverser for the picking collisions
self.picker = CollisionTraverser()
# Setup mouse ray
self.pq = CollisionHandlerQueue()
# Create a collision Node
pickerNode = CollisionNode('MouseRay')
# set the nodes collision bitmask
pickerNode.setFromCollideMask(BitMask32.bit(1))
# create a collision ray
self.pickerRay = CollisionRay()
# add the ray as a solid to the picker node
pickerNode.addSolid(self.pickerRay)
# create a nodepath with the camera to the picker node
self.pickerNP = base.camera.attachNewNode(pickerNode)
# add the nodepath to the base traverser
self.picker.addCollider(self.pickerNP, self.pq)
print "model loaded"
#TODO: check how to load multiple levels and set players in specific levels!
self.accept("mouse1", self.mouseClick)
def __init__(self):
ShowBase.__init__(self)
base.enableParticles()
base.cTrav = CollisionTraverser("base collision traverser")
base.handler = CollisionHandlerQueue()
self.scene = self.loader.loadModel("models/environment")
self.scene.reparentTo(self.render)
self.scene.setScale(0.25, 0.25, 0.25)
self.scene.setPos(-8, 42, 0)
self.teapots = [None for i in range(2)]
self.fires = [None for i in range(2)]
for i in range(2):
self.teapots[i] = self.loader.loadModel("teapot")
self.teapots[i].reparentTo(render)
self.fires[i] = fireSystem(i, self.teapots[i])
self.teapots[i].setPos(i * 15, i, i)
self.fires[1].ignite()
self.tick = taskMgr.add(self.tick, "Update")
base.disableMouse()
self.camera.setPos(0, -20, 5)
def startSeeking(self):
if not self.avatar:
return
self.cleanupShadow()
self.buildShadow()
scale = self.dropShadow.getScale()
if scale < 1.0:
self.maxDistance += 40
x, y, z = self.avatar.getPos(render)
self.dropShadow.reparentTo(render)
self.dropShadow.setPos(x, y + 5, z + 2)
self.cameraNode = CollisionNode('coll_camera')
self.cameraNode.setFromCollideMask(CIGlobals.WallBitmask)
self.cameraRay = CollisionRay()
self.cameraNode.addSolid(self.cameraRay)
self.cameraNP = camera.attachNewNode(self.cameraNode)
base.cTrav.addCollider(self.cameraNP, CollisionHandlerQueue())
if not self.legacyMode:
shadowNode = CollisionNode('coll_shadow')
self.shadowRay = CollisionRay(0, 0, 6, 0, 0, -1)
shadowNode.addSolid(self.shadowRay)
shadowNode.setFromCollideMask(CIGlobals.FloorBitmask)
self.shadowNP = self.dropShadow.attachNewNode(shadowNode)
base.cTrav.addCollider(self.shadowNP, self.collHdlFl)
base.taskMgr.add(self.__moveShadow, self.moveShadowTaskName)
self.avatar.acceptOnce('mouse1', self.locationChosen)
def __init__(self, ip, port, verbose=False, lagSimulation=0):
super().__init__()
# Set up mouse input
base.cTrav = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.mouseHandler = MouseHandler()
self.taskMgr.add(self.inputTask, "InputTask")
# Set up the UI
self.fonts = hud.Fonts()
# View the cards at an angle
self.camera.setPosHpr(4, -15, -15, 0, 45, 0)
# Set up the NetworkManager
instr = client.networkInstructions.NetworkInstructions()
self.networkManager = ClientNetworkManager(instr, ip, port)
self.networkManager.verbose = verbose
# Connect to the server
self.connectionManager = ConnectionManager((ip, port), self)
self.connectionManager.tryConnect()
self.taskMgr.add(self.networkUpdateTask, "NetworkUpdateTask")
# Set up lag simulation
self.lagTimer = self.lagSimulation = lagSimulation
self.availableFactions = [
templars.Templar, mariners.Mariner, thieves.Thief, fae.Faerie
]
self.hasMulliganed = False
self.ready = False
def start(self):
base.camLens.setNear(0.1)
self.shooterTrav = CollisionTraverser('ToonFPS.shooterTrav')
ray = CollisionRay()
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setCollideMask(BitMask32(0))
rayNode.setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask)
self.shooterRay = ray
self.shooterRayNode = base.camera.attachNewNode(rayNode)
self.shooterHandler = CollisionHandlerQueue()
self.shooterTrav.addCollider(self.shooterRayNode, self.shooterHandler)
self.firstPerson.start()
self.v_model_root.reparentTo(base.camera)
self.v_model.reparentTo(self.v_model_root)
if self.weaponName == "pistol":
self.v_model_root.setZ(-1.8)
self.v_model_root.setY(0.3)
self.v_model_root.setX(-0.1)
self.v_model_root.setH(2)
elif self.weaponName == "sniper":
self.v_model_root.setPos(-0.42, -0.81, -1.7)
self.v_model_root.setHpr(359, 352.87, 0.00)
elif self.weaponName == "shotgun":
self.v_model_root.setPos(-0.42, -0.81, -1.7)
self.v_model_root.setHpr(359, 352.87, 0.00)
self.gui.start()
self.firstPerson.disableMouse()
self.aliveFSM.request('draw')
def __init__(self, render, objid, start_pos, gameclient):
self.client = gameclient
self.id = objid
self.motion_controller = None
self.is_player = False
# state management
self.isAnimating = False
self.state = state.IDLE
self.render = render # scene graph root
# create the panda3d actor: just load a default model for now
self.actor = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.actor.reparentTo(render)
self.actor.setScale(.2)
self.actor.setPos(start_pos)
# prepare collision handling
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0, 0, 1000)
self.GroundRay.setDirection(0, 0, -1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def __init__(self):
#selection detection
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
#self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) #TODO WOW geometry collision is SUPER slow...
self.pickerNode.setFromCollideMask(BitMask32.bit(BITMASK_COLL_CLICK))
#render.find('**selectable').node().setIntoCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
#box selection detection HINT: start with drawing the 2d thing yo!
self.__shift__ = False
self.accept("shift", self.shiftOn)
self.accept("shift-up", self.shiftOff)
self.__ctrl__ = False
self.accept("control", self.ctrlOn)
self.accept("control-up", self.ctrlOff)
#mouse handling
self.accept("mouse1", self.clickHandler)
self.accept("shift-mouse1", self.clickHandler)
self.accept("mouse1-up", self.releaseHandler)
#dragging
self.dragTask = taskMgr.add(self.dragTask, 'dragTask')
def __init__(self):
ShowBase.__init__(self)
self.physicsMgr = Pmango()
self.cTravA = CollisionTraverser()
physicsMgr = self.physicsMgr
self.alin = LinearEulerIntegrator()
self.physicsMgr.attachLinearIntegrator(self.alin)
self.arin = AngularEulerIntegrator()
self.physicsMgr.attachAngularIntegrator(self.arin)
alin = self.alin
arin = self.arin
grava = ForceNode('GravAll')
grta = LinearVectorForce(0, 0, -8)
grava.addForce(grta)
physicsMgr.addLinearForce(grta)
self.readbuff = open("InterBuff.py", "r+")
self.taskMgr.doMethodLater(0.1, self.phytime, "PhyTime")
self.taskMgr.add(self.interbuff, "InterBuff")
self.DinGro = CollisionHandlerQueue()
def setCollisions(self, value):
if value == True:
b = self.node.getBounds().getRadius()
self.cTrav = CollisionTraverser()
self.collisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'])
self.collisionNode = CollisionNode('characterTube')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.collisionNodeNp, self.collisionHandler)
if self.showCollisions == True or main.editormode:
# Uncomment this line to see the collision rays
self.collisionNodeNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
else:
b = self.node.getBounds().getRadius()
self.collisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'])
#allowing playables to collide with npcs
if self.isNPC == True: #TODO: fix because it's completely f****d up
self.collisionNode = CollisionNode('characterTube')
else:
self.collisionNode = CollisionNode('characterNPCTube')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
def generate(self):
data = CIGlobals.SuitBodyData[self.SUIT]
type = data[0]
team = data[1]
self.team = team
self.level = 12
self.suit = type
Suit.generate(self, SuitBank.MrHollywood, 0, hideFirst=False)
self.suit = type
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def setPickCollisions(self, value):
if value:
print "setting pick collisions"
b = self.node.getBounds().getRadius()
self.pickCTrav = CollisionTraverser()
self.pickCollisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'] + 0.01)
self.pickCollisionNode = CollisionNode('characterPickTube')
self.pickCollisionNode.addSolid(self.pickCollisionTube)
self.pickCollisionNodeNp = NodePath(self.pickCollisionNode)
self.pickCollisionNodeNp.reparentTo(self.node)
self.pickCollisionHandler = CollisionHandlerQueue()
self.pickCTrav.addCollider(self.pickCollisionNodeNp,
self.pickCollisionHandler)
if self.showCollisions == True:
# Uncomment this line to see the collision rays
self.pickCollisionNodeNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
self.pickCTrav.showCollisions(render)
else:
#dereferincing all pick colliders (must be done in order not to collide onto NPCs)
self.pickCTrav = None
self.pickCollisionTube = None
self.pickCollisionNode = None
self.pickCollisionNodeNp = None
self.pickCollisionHandler = None
def __init__(self, parent: NodePath):
super().__init__()
self.parent = parent
self.mouse_np = p3d.camera.attach_new_node(PandaNode('mouse'))
self.mouse_np.set_y(p3d.lens.get_near())
picker_node = CollisionNode('mouse_ray')
picker_np = p3d.camera.attach_new_node(picker_node)
self._picker_ray = CollisionRay()
picker_node.add_solid(self._picker_ray)
self._collision_handler = CollisionHandlerQueue()
self._traverser = CollisionTraverser('mouse_traverser')
self._traverser.add_collider(picker_np, self._collision_handler)
self.actor = Actor(
resource_filename('tsim', 'data/models/cursor'),
{'spin': resource_filename('tsim', 'data/models/cursor-spin')})
self.actor.loop('spin')
self.actor.reparent_to(parent)
self.actor.set_pos(0.0, 0.0, 0.0)
self.actor.set_shader_off()
self._position = Point(0.0, 0.0)
self.last_position = self._position
self.moved = False
self.pointed_at = None
self._tool: Optional[Tool] = None
self._register_events()
def __init__(self, parent=None, pitch=None, id=None):
NetEnt.__init__(self, id)
self.node = NetNodePath(PandaNode('projectile'))
if parent:
self.parent = parent
self.node.setPos(parent.node.getPos() + (0, 0, 1))
self.node.setHpr(parent.node.getHpr())
self.node.setP(pitch)
self.node.reparentTo(render)
ProjectilePool.add(self)
#print 'there are',len(ProjectilePool.values()),'projectiles'
self.flyTime = 0
self.sprite = Sprite2d('resources/missile.png',
rows=3,
cols=1,
rowPerFace=(0, 1, 2, 1),
anchorY=Sprite2d.ALIGN_CENTER)
self.sprite.node.reparentTo(self.node)
# set up 'from' collisions - for detecting projectile hitting things
self.collisionHandler = CollisionHandlerQueue()
self.fromCollider = self.node.attachNewNode(
CollisionNode('fromCollider'))
self.fromCollider.node().addSolid(CollisionRay(0, 0, 0, 0, 1, 0))
self.fromCollider.node().setIntoCollideMask(BITMASK_EMPTY)
self.fromCollider.node().setFromCollideMask(BITMASK_TERRAIN
| BITMASK_CHARACTER)
if SHOW_COLLISIONS:
self.fromCollider.show()
Character.collisionTraverser.addCollider(self.fromCollider,
self.collisionHandler)
def checkcmcdlistlist(objcmlist0, objcmlist1, toggleplot=False):
"""
detect the collision between two collision model lists
:return: True or False
author: weiwei, Toyonaka
date: 20190422
"""
oocnp0 = NodePath("collision nodepath")
oocnp1 = NodePath("collision nodepath")
obj0cnplist = []
for objcm0 in objcmlist0:
obj0cnplist.append(objcm0.copycdnpTo(oocnp0))
obj1cnplist = []
for objcm1 in objcmlist1:
obj1cnplist.append(objcm1.copycdnpTo(oocnp1))
if toggleplot:
oocnp0.reparentTo(base.render)
oocnp1.reparentTo(base.render)
for obj0cnp in obj0cnplist:
obj0cnp.show()
for obj1cnp in obj1cnplist:
obj1cnp.show()
ctrav = CollisionTraverser()
chan = CollisionHandlerQueue()
for obj0cnp in obj0cnplist:
ctrav.addCollider(obj0cnp, chan)
ctrav.traverse(oocnp1)
if chan.getNumEntries() > 0:
return True
else:
return False
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0,-a,a+3)#80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock=ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.monsters = []
self.accept('c',self._create)
base.enableParticles()
def __init__(self, fulcrum, terrain):
TerrainCamera.__init__(self)
self.terrain = terrain
self.fulcrum = fulcrum
# in behind Ralph regardless of ralph's movement.
self.camNode.reparentTo(fulcrum)
# How far should the camera be from Ralph
self.cameraDistance = 30
# Initialize the pitch of the camera
self.cameraPitch = 10
self.focus = self.fulcrum.attachNewNode("focus")
self.maxDistance = 500.0
self.minDistance = 2
self.maxPitch = 80
self.minPitch = -70
# 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.
# 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.cameraRay = CollisionSegment(self.fulcrum.getPos(), (0, 5, 5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.fulcrum.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def player_init(self):
self.base.pusher.addCollider(self.collider, self.actor)
self.base.cTrav.addCollider(self.collider, self.base.pusher)
self.collider.setPythonTag("player", self)
self.score = 0
self.score_string = str(self.score)
# self.base.camLens.setFov(150) #----------------------------------------------
# self.base.camLens.setFov(5)
self.textObject = OnscreenText(text='Score:' + self.score_string,
pos=(-1.15, -0.95),
scale=0.1)
self.ray = CollisionRay(0, 0, 0, 0, -1, 0)
rayNode = CollisionNode("playerRay")
rayNode.addSolid(self.ray)
self.rayNodePath = self.actor.attachNewNode(rayNode)
self.rayQueue = CollisionHandlerQueue()
self.base.cTrav.addCollider(self.rayNodePath, self.rayQueue)
# self.damagePerSecond = -5.0
self.beamModel = self.base.loader.loadModel("models/frowney")
self.beamModel.reparentTo(self.actor)
self.beamModel.setZ(10)
self.beamModel.setLightOff()
self.beamModel.hide()
def __init__(self, energy, jeep):
self.bebidas = 0
self.energy = energy
self.crash = []
self.jeep = jeep
""" ---------------------- Prepara las Colisiones ---------------------- """
self.cs = CollisionSphere(0, 0, 0, 20)
cont = 0
while (cont < 80):
self.crash.append(self.energy[cont].attachNewNode(
CollisionNode(str(cont))))
self.crash[cont].node().addSolid(self.cs)
#self.crash[cont].show() Uncomment this line to see the colisions
cont = cont + 1
self.css = CollisionSphere(0, 0, 0, 12)
self.cnodePath = self.jeep.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(self.css)
#self.cnodePath.show() Uncomment this line to see the colisions
self.traverser = CollisionTraverser()
self.queue = CollisionHandlerQueue()
""" --------------------------------------------------------------------- """
taskMgr.add(self.choque, "choque")
def getObjectsInBox(self, mins, maxs):
objects = []
# Create a one-off collision box, traverser, and queue to test against all MapObjects
box = CollisionBox(mins, maxs)
node = CollisionNode("selectToolCollBox")
node.addSolid(box)
node.setFromCollideMask(self.Mask)
node.setIntoCollideMask(BitMask32.allOff())
boxNp = self.doc.render.attachNewNode(node)
queue = CollisionHandlerQueue()
base.clickTraverse(boxNp, queue)
queue.sortEntries()
key = self.Key
entries = queue.getEntries()
# Select every MapObject our box intersected with
for entry in entries:
np = entry.getIntoNodePath().findNetPythonTag(key)
if not np.isEmpty():
obj = np.getPythonTag(key)
actual = self.getActualObject(obj, entry)
if isinstance(actual, list):
for a in actual:
if not any(a == x[0] for x in objects):
objects.append((a, entry))
else:
objects.append((actual, entry))
boxNp.removeNode()
return objects
def startSeeking(self):
if not self.avatar: return
self.cleanupShadow()
self.buildShadow()
# Let's increase the distance if the shadow is smaller than expected.
scale = self.dropShadow.getScale()
if scale < 1.0:
self.maxDistance += 40
# Let's setup the drop shadow's initial position.
x, y, z = self.avatar.getPos(render)
self.dropShadow.reparentTo(render)
self.dropShadow.setPos(x, y + 5, z + 2)
# Let's setup the collisions for the mouse.
self.cameraNode = CollisionNode('coll_camera')
self.cameraNode.setFromCollideMask(CIGlobals.WallBitmask)
self.cameraRay = CollisionRay()
self.cameraNode.addSolid(self.cameraRay)
self.cameraNP = camera.attachNewNode(self.cameraNode)
base.cTrav.addCollider(self.cameraNP, CollisionHandlerQueue())
if not self.legacyMode:
# Let's setup the collisions for the shadow.
shadowNode = CollisionNode('coll_shadow')
self.shadowRay = CollisionRay(0, 0, 6, 0, 0, -1)
shadowNode.addSolid(self.shadowRay)
shadowNode.setFromCollideMask(CIGlobals.FloorBitmask)
self.shadowNP = self.dropShadow.attachNewNode(shadowNode)
base.cTrav.addCollider(self.shadowNP, self.collHdlFl)
# Finally, let's start moving the shadow with the mouse and accept left mouse clicks.
base.taskMgr.add(self.__moveShadow, self.moveShadowTaskName)
self.avatar.acceptOnce('mouse1', self.locationChosen)
def __init__(self):
self.enabled = False
self.locked = False
self.position = Vec3(0, 0, 0)
self.delta = Vec3(0, 0, 0)
self.prev_x = 0
self.prev_y = 0
self.start_x = 0
self.start_y = 0
self.velocity = Vec3(0, 0, 0)
self.prev_click_time = time.time()
self.double_click_distance = .5
self.hovered_entity = None
self.left = False
self.right = False
self.middle = False
self.delta_drag = Vec3(0, 0, 0)
self.update_step = 1
self._i = 0
self._mouse_watcher = None
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('mouseRay')
self._pickerNP = camera.attach_new_node(self._pickerNode)
self._pickerRay = CollisionRay() # Make our ray
self._pickerNode.addSolid(self._pickerRay)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNode.set_into_collide_mask(0)
self.raycast = True
self.collision = None
self.collisions = list()
self.enabled = True
def generate(self):
self.level = 12
self.maxHealth = 200
self.health = 200
Suit.generate(self,
FactorySneakGuardSuit.SUIT,
FactorySneakGuardSuit.VARIANT,
hideFirst=False)
self.setName(self.suitPlan.getName(), None)
self.cleanupPropeller()
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4. / 3.))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
