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 play(self, ai, difficult=False):
self.easyAI.destroy()
self.hardAI.destroy()
self.ai = None
self.cTrav = CollisionTraverser()
self.coll = CollisionHandlerEvent()
self.coll.addInPattern("%fn-into-%in")
self.clock = ClockObject()
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("heightMap.png")
terrain.setColorMap("colormap.png")
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(self.render)
root.setSz(1)
terrain.generate()
self.player = Character("models/panda-model", 0.05, (300, 300, 0),
self.render, {"walk": "models/panda-walk4"},
self, self.path, 200, "player")
self.addControls()
self.loadUI()
self.startTasks()
self.accept("proj-into-player", self.player.changeLife, [-1])
self.others = dict()
self.roundOv = False
self.taskMgr.add(self.update, "Update")
self.gameOver = False
if ai:
self.aiBattle(difficult)
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')
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 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 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 __init__(self):
ShowBase.__init__(self)
pman.shim.init(self)
#props = WindowProperties()
#props.setCursorHidden(True)
#props.setMouseMode(WindowProperties.M_relative)
#base.win.requestProperties(props)
base.disableMouse()
self.mouse = [0, 0]
self.setFrameRateMeter(True)
self.win.setClearColor((0, 0, 0, 1))
self.cTrav = CollisionTraverser()
self.cTrav.setRespectPrevTransform(True)
self.delay = [0, 5]
base.win.display_regions[1].dimensions = (0, 1, 0.25, 1)
render.setShaderAuto()
self.music = None
self.shuffleSong()
self.mode = "edit"
self.defineKeys()
self.hud = Hud(self)
self.road = RoadMan(self)
self.road.enableEditing()
self.spawn()
self.taskMgr.add(self.update)
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 __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 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, 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 initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# self.cQueue = CollisionHandlerQueue()
# Initialize the Pusher collision handler.
#self.pusher = CollisionHandlerPusher()
self.pusher = CollisionHandlerFloor()
### player
print DirectNotifyGlobal.directNotify.getCategories()
# Create a collsion node for this object.
playerNode = CollisionNode('player')
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# playerNode.setFromCollideMask(BitMask32.bit(0))
# playerNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
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 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 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 __init__(self, services: Services, base: ShowBase, map_data: MapData, name: Optional[str] = None):
self.__services = services
self.__services.ev_manager.register_listener(self)
self.__base = base
self.__name = name if name is not None else (map_data.name + "_picker")
self.__map = map_data
self.__data = map_data.data
# collision traverser & queue
self.__ctrav = CollisionTraverser(self.name + '_ctrav')
self.__cqueue = CollisionHandlerQueue()
# collision boxes
self.__cn = CollisionNode(self.name + '_cn')
self.__cn.set_collide_mask(MapPicker.COLLIDE_MASK)
self.__cnp = self.__map.root.attach_new_node(self.__cn)
self.__ctrav.add_collider(self.__cnp, self.__cqueue)
self.__points = []
z_offset = 1 if self.__map.dim == 3 else self.__map.depth
for idx in np.ndindex(self.__data.shape):
if bool(self.__data[idx] & MapData.TRAVERSABLE_MASK):
p = Point(*idx)
self.__points.append(p)
idx = self.__cn.add_solid(CollisionBox(idx, Point3(p.x+1, p.y+1, p.z-z_offset)))
assert idx == (len(self.__points) - 1)
# mouse picker
self.__pn = CollisionNode(self.name + '_pray')
self.__pnp = self.__base.cam.attach_new_node(self.__pn)
self.__pn.set_from_collide_mask(MapPicker.COLLIDE_MASK)
self.__pray = CollisionRay()
self.__pn.add_solid(self.__pray)
self.__ctrav.add_collider(self.__pnp, self.__cqueue)
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):
ShowBase.__init__(self)
# Override defaults
self.disableMouse()
self.setBackgroundColor(0.7, 0.7, 0.7)
self.setFrameRateMeter(True)
# Lights
dlight = DirectionalLight("dlight")
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(180.0, -70.0, 0)
self.render.setLight(dlnp)
alight = AmbientLight("alight")
alnp = self.render.attachNewNode(alight)
alight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.render.setLight(alnp)
# Collisions
self.cTrav = CollisionTraverser("collisionTraverser")
self.cTrav.showCollisions(self.render)
# Camera controls
self.cameraController = CameraController(self, 200, math.pi / 4.0,
math.pi / 4.0)
#self.cameraController = CameraController(self, 200, -math.pi, math.pi / 4.0)
# Load the track
self.track = self.loader.loadModel("models/trackMotegi")
self.track.reparentTo(self.render)
# Load the car
self.car = KeyboardController(self)
def set_controls(self):
"""Configure common game controls.
Configure major keys, collisions system
and controls to manipulate characters.
"""
base.accept("f1", self._show_keys) # noqa: F821
base.accept("escape", base.main_menu.show) # noqa: F821
base.accept("r", self._show_char_relations) # noqa: F821
base.accept("m", base.world.rails_scheme.show) # noqa: F821
base.accept("j", base.journal.show) # noqa: F821
# configure mouse collisions
col_node = CollisionNode("mouse_ray")
col_node.setIntoCollideMask(NO_MASK)
col_node.setFromCollideMask(MOUSE_MASK)
self._mouse_ray = CollisionRay()
col_node.addSolid(self._mouse_ray)
# set common collisions handler
handler = CollisionHandlerEvent()
handler.addInPattern("%fn-into")
handler.addAgainPattern("%fn-again")
handler.addOutPattern("%fn-out")
self.traverser = CollisionTraverser("traverser")
self.traverser.addCollider(
base.cam.attachNewNode(col_node), handler # noqa: F821
)
self.set_mouse_events()
taskMgr.doMethodLater(0.03, self._collide_mouse, "collide_mouse") # noqa: F821
taskMgr.doMethodLater(0.04, self._traverse, name="main_traverse") # noqa: F821
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 __init__(self):
super().__init__(name='raycaster', eternal=True)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
def __init__(self):
self.rayCTrav = CollisionTraverser("collision traverser for ray tests")
#self.pusher = PhysicsCollisionHandler()
self.pusher = CollisionHandlerPusher()
self.pusher.addInPattern('%fn-in-%in')
self.pusher.addOutPattern('%fn-out-%in')
self.pusher.addInPattern('%fn-in')
self.pusher.addOutPattern('%fn-out')
def levelInit(self, levelname):
# Load a backdrop model and attach it to the Scene Graph
self.environment = loader.loadModel(levelname)
self.environment.reparentTo(render)
# Set up level collision
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
def __init__(self, game):
self.game = game
self.setup_collision()
self.queue = CollisionHandlerQueue()
self.traverser = CollisionTraverser('Collision Traverser')
self.traverser.showCollisions(render)
self.traverser.add_collider(self.target_nodepath, self.queue)
base.taskMgr.add(self.collide, "Collision Task")
def __init__(self):
ShowBase.__init__(self)
# Override defaults
self.disableMouse()
self.setBackgroundColor(VBase3(160, 200, 150) / 255.0)
self.setFrameRateMeter(True)
# Lights
dlight = DirectionalLight("dlight")
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(180.0, -70.0, 0)
self.render.setLight(dlnp)
alight = AmbientLight("alight")
alnp = self.render.attachNewNode(alight)
alight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.render.setLight(alnp)
# Collision traverser
self.cTrav = CollisionTraverser("collisionTraverser")
#self.cTrav.showCollisions(self.render)
# Collision handlers
self.carCollisionHandler = CollisionHandlerEvent()
self.carCollisionHandler.addInPattern("%fn-into-%in")
# Camera controls
self.cameraController = CameraController(self, 400, math.pi / 4.0,
math.pi / 4.0)
#self.cameraController = CameraController(self, 300, -math.pi, math.pi / 4.0)
# Load the track
#self.track = self.loader.loadModel("models/trackMotegi")
self.track = self.loader.loadModel("models/trackValencia")
checkpointsCollision = self.track.find("checkpoints").node()
checkpointsCollision.setIntoCollideMask(BitMask32(0xF0))
self.numCheckpoints = checkpointsCollision.getNumSolids()
self.track.reparentTo(self.render)
# Load the car
#self.car = KeyboardCar(self)
self.car = NeuralNetworkCar(self)
self.cameraController.follow(self.car.getNodePath())
#self.cameraController.setTarget(self.car.getNodePath())
# Reposition the car
#self.car.getNodePath().setH(180.0)
# Register car collisions with track
self.cTrav.addCollider(self.car.carCollider, self.carCollisionHandler)
self.accept("carCollider-into-trackCollision", self.car.onCrash)
self.accept("carCollider-into-checkpoints", self.car.onCheckpoint)
# State logger
self.loggingActive = False
self.log = []
self.accept("l", self.toggleStateLogger)
def __init__(self):
# значение шага перемещения клавиатурой
self.key_step = 0.2
# значение шага поворота мышкой
self.mouse_step = 0.2
# координаты центра экрана
self.x_center = base.win.getXSize() // 2
self.y_center = base.win.getYSize() // 2
# перемещаем указатель мышки в центр экрана
base.win.movePointer(0, self.x_center, self.y_center)
# отключаем стандартное управление мышкой
base.disableMouse()
# устанавливаем поле зрения объектива
base.camLens.setFov(80)
# устанавливаем ближайшую границу отрисовки
base.camLens.setNear(0.2)
# устанавливаем текущие значения ориентации камеры
self.heading = 0
self.pitch = 0
# запускаем задачу контроля камеры
taskMgr.doMethodLater(0.02, self.controlCamera, "camera-task")
# регистрируем на нажатие клавиши "Esc"
# событие закрытия приложения
base.accept("escape", base.userExit)
# устанавливаем клавиши управления перемещением камеры
# словарь, хранящий флаги нажатия клавиш
self.keys = dict()
# заполняем словарь
for key in ['a', 'd', 'w', 's', 'q', 'e']:
# создаём запись в словаре
self.keys[key] = 0
# регистрируем событие на нажатие клавиши
base.accept(key, self.setKey, [key, 1])
# регистрируем событие на отжатие клавиши
base.accept(key + '-up', self.setKey, [key, 0])
# создание обходчика столкновений
self.traverser = CollisionTraverser()
# очередь обработки столкновений
self.collisQueue = CollisionHandlerQueue()
# узел для сферы столкновений
self.collisNode = CollisionNode('CameraSphere')
# устанавливаем маску проверки столкновений ОТ
self.collisNode.setFromCollideMask(BitMask32.bit(1))
# сбрасываем маску проверки столкновений ДО
self.collisNode.setIntoCollideMask(BitMask32.allOff())
# создайте сферу столкновения
# ...
# и прикрепите к созданному ранее узлу self.collisNode
# ...
# закрепляем узел на камере
self.collisCamNode = base.camera.attachNewNode(self.collisNode)
# уведомляем обходчик о новом «объекте ОТ»
self.traverser.addCollider(self.collisCamNode, self.collisQueue)
def setupCollision(self):
self.sphere = self.model.attachNewNode(CollisionNode('range'))
self.sphere.node().addSolid(CollisionSphere(0, 0, 0, self.range))
self.sphere.node().setFromCollideMask(BitMask32(2))
self.sphere.node().setIntoCollideMask(BitMask32.allOff())
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.sphere, self.cHandler)
def __init__(self, app) -> None:
self.app = app
# 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()
def __init__(self, name="auto"):
self.ctrav = CollisionTraverser()
self.chan = CollisionHandlerQueue()
self.np = NodePath(name)
self.bitmask_list = [BitMask32(2**n) for n in range(31)]
self._bitmask_ext = BitMask32(
2**31) # 31 is prepared for cd with external non-active objects
self.all_cdelements = [
] # a list of cdlnks or cdobjs for quick accessing the cd elements (cdlnks/cdobjs)
def __init__(self, showbase, usersData, gameData):
DirectObject.__init__(self)
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
self.ambientLight = showbase.render.attachNewNode(
AmbientLight("ambientLight"))
# Set the color of the ambient light
self.ambientLight.node().setColor((.1, .1, .1, 1))
# add the newly created light to the lightAttrib
# showbase.render.setLight(self.ambientLight)
self.spotlight = None
numberOfPlayers = len(self.usersData)
for index, user in enumerate(self.usersData):
user.centipede = Centipede(showbase, index, numberOfPlayers,
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.spotlight = self.centipede.head.attachNewNode(
PointLight("playerSpotlight"))
self.spotlight.setPos(LVector3(0, 0, 8))
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight.node().setAttenuation(
LVector3(.025, 0.0005, 0.0001))
self.spotlight.node().setColor((0.35, 0.35, .35, 1))
self.spotlight.node().setSpecularColor((0.01, 0.01, 0.01, 1))
showbase.render.setLight(self.spotlight)
self.perPixelEnabled = True
self.shadowsEnabled = True
#if self.spotlight:
# self.spotlight.node().setShadowCaster(True, 512, 512)
showbase.render.setShaderAuto()
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
class Mouse(DirectObject):
def __init__(self, levelNP):
self.setCursor()
# store the nodepath to the level collisions
# will be used to check for intersections with the mouse ray
self.levelNP = levelNP
# 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))#GeomNode.getDefaultCollideMask())
# 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)
def setCursor(self):
base.win.clearRejectedProperties()
props = WindowProperties()
if sys.platform.startswith('linux'):
props.setCursorFilename("./assets/cursor.x11")
else:
props.setCursorFilename("./assets/cursor.ico")
base.win.requestProperties(props)
def getMousePos(self):
# check if we have a mouse on the window
if base.mouseWatcherNode.hasMouse():
# get the mouse position on the screen
mpos = base.mouseWatcherNode.getMouse()
# set the ray's position
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
# Now call the traverse function to let the traverser check for collisions
# with the added colliders and the levelNP
self.picker.traverse(self.levelNP)
# check if we have a collision
if self.pq.getNumEntries() > 0:
# sort the entries to get the closest first
self.pq.sortEntries()
# This is the point at where the mouse ray and the level plane intersect
hitPos = self.pq.getEntry(0).getSurfacePoint(render)
return hitPos
return Point3(0, 0, 0)
task.cont
def __init__(self, _main):
self.main = _main
self.name = ""
self.points = 0
self.health = 100.0
self.runSpeed = 1.8
self.keyMap = {
"left":False,
"right":False,
"up":False,
"down":False
}
base.camera.setPos(0,0,0)
self.model = loader.loadModel("Player")
self.model.find('**/+SequenceNode').node().stop()
self.model.find('**/+SequenceNode').node().pose(0)
base.camera.setP(-90)
self.playerHud = Hud()
self.playerHud.hide()
self.model.hide()
# Weapons: size=2, 0=main, 1=offhand
self.mountSlot = []
self.activeWeapon = None
self.isAutoActive = False
self.trigger = False
self.lastShot = 0.0
self.fireRate = 0.0
self.playerTraverser = CollisionTraverser()
self.playerEH = CollisionHandlerEvent()
## INTO PATTERNS
self.playerEH.addInPattern('intoPlayer-%in')
#self.playerEH.addInPattern('colIn-%fn')
self.playerEH.addInPattern('intoHeal-%in')
self.playerEH.addInPattern('intoWeapon-%in')
## OUT PATTERNS
self.playerEH.addOutPattern('outOfPlayer-%in')
playerCNode = CollisionNode('playerSphere')
playerCNode.setFromCollideMask(BitMask32.bit(1))
playerCNode.setIntoCollideMask(BitMask32.bit(1))
self.playerSphere = CollisionSphere(0, 0, 0, 0.6)
playerCNode.addSolid(self.playerSphere)
self.playerNP = self.model.attachNewNode(playerCNode)
self.playerTraverser.addCollider(self.playerNP, self.playerEH)
#self.playerNP.show()
self.playerPusher = CollisionHandlerPusher()
self.playerPusher.addCollider(self.playerNP, self.model)
self.playerPushTraverser = CollisionTraverser()
self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher)
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)
class PlayerObject():
def __init__(self, render, player):
self.username = player.getUsername()
self.isMoving = False
self.render = render
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
self.actor = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"})
self.actor.reparentTo(render)
self.actor.setScale(0.2)
self.actor.setPos(player.getX(), player.getY(), player.getZ())
self.actor.setH(player.getH())
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 getUsername(self):
# return self.username
def getActor(self):
return self.actor
def setPos(self, x, y, z):
self.actor.setPos(x, y, z)
def setH(self, h):
self.actor.setH(h)
def move(self, isActorMove):
if isActorMove == "True":
if self.isMoving is False:
self.actor.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.actor.stop()
self.actor.pose("walk",5)
self.isMoving = False
def __init__(self, render, player):
self.username = player.getUsername()
self.isMoving = False
self.render = render
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
#self.actor = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"})
self.actor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.actor.reparentTo(render)
self.actor.setScale(0.002, 0.002, 0.002)
self.actor.setPos(player.getX(), player.getY(), player.getZ())
self.actor.setH(player.getH())
#self.actor.loop("walk")
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 initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# self.cQueue = CollisionHandlerQueue()
# Initialize the Pusher collision handler.
# self.pusher = CollisionHandlerPusher()
self.pusher = CollisionHandlerFloor()
### player
print DirectNotifyGlobal.directNotify.getCategories()
# Create a collsion node for this object.
playerNode = CollisionNode("player")
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# playerNode.setFromCollideMask(BitMask32.bit(0))
# playerNode.setIntoCollideMask(BitMask32.allOn())
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
def __init__(self, engine, environment):
self.engine = engine
self.players = {}
self.environment = environment
self.inputQueue = deque()
self.collisionDummy = CollisionDummy()
self.inputPollWait = 0
self.playerCollisionHandler = CollisionHandlerPusher()
self.playerCollisionHandler.addCollider(self.collisionDummy.GetCollisionNode(), self.collisionDummy.GetNode())
self.playerCollisionTraverser = CollisionTraverser('playerCollisionTraverser')
self.playerCollisionTraverser.addCollider(self.collisionDummy.GetCollisionNode(), self.playerCollisionHandler)
#self.playerCollisionTraverser.showCollisions(render)
self.LoadServerPosDebug()
self.LoadMyself()
self.accept(ViewModeChangeEvent.EventName, self.OnViewModeChange)
self.accept(SelectedItemChangeEvent.EventName, self.OnSelectedItemChangeEvent)
self.accept(PlayerAttackEvent.EventName, self.OnPlayerAttackEvent)
self.accept(PlayerRespawnEvent.EventName, self.OnPlayerRespawnEvent)
self.accept(PlayerDeathEvent.EventName, self.OnPlayerDeathEvent)
self.accept(TeamSelectEvent.EventName, self.OnTeamSelectEvent)
if(not Settings.IS_SERVER):
self.sounds = {}
self.sounds['blockBreak'] = loader.loadSfx('Assets/Sounds/blockBreak.mp3')
self.sounds['blockPlace'] = loader.loadSfx('Assets/Sounds/blockPlace.mp3')
def __init__(self,gmap,gaming_zone):
DirectObject.__init__(self)
#gaming zone (used for mouse movement), as a tools.Rectangle
self.gaming_zone=gaming_zone
#actual camera node
self.p3dcam=base.camera
#what the cam is oriented to
self._target=base.render.attachNewNode('GaminCam.target')
#range=[0,1] between min and max closeness to ground
self.level=.7
#
#keys_down acts as a pool containing keys (+mouse buttons) currently down
self.keys_down=[]
update_list.append(self.update)
#setup for mouse picking
picker_node=CollisionNode('gcam_to_mouse_ray')#general collision node
picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray=CollisionRay()#solid ray to attach to coll node
picker_node.addSolid(self.picker_ray)
self.picker_np=self.p3dcam.attachNewNode(picker_node)#attach this node to gcam
self.collision_queue=CollisionHandlerQueue()#stores collisions
self.collision_traverser=CollisionTraverser('gcam_traverser')#actual computer
self.collision_traverser.addCollider(self.picker_np,self.collision_queue)
base.cTrav=self.collision_traverser
self.gmap=gmap
#stack of states (state=pos+zoom)
self.states_stack=[]
#enable the cam to move according to keyboard and mouse
self.move_enabled=True
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 __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, 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):
#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, show=False):
self.accept('makePickable', self.makePickable)
#create traverser
#base.cTrav = CollisionTraverser()
self.cTrav = CollisionTraverser()
#create collision ray
self.createRay(self,base.camera,name="mouseRay",show=show)
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 addRalph(self, pos):
ralphStartPos = pos
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
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)
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 __init__(self):
self.initialize()
self.WALLS = self.MAZE.find("**/Wall.004")
self.WALLS.node().setIntoCollideMask(BitMask32.bit(0))
# collision with the ground. different bit mask
#self.mazeGround = self.maze.find("**/ground_collide")
#self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
self.MAZEGROUND = self.MAZE.find("**/Cube.004")
self.MAZEGROUND.node().setIntoCollideMask(BitMask32.bit(1))
# add collision to the rock
cs = CollisionSphere(0, 0, 0, 0.5)
self.cnodePath = self.rock.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(cs)
self.cnodePath.show()
self.cnodePath.node().setIntoCollideMask(BitMask32.bit(0))
# load the ball and attach it to the scene.
# it is on a dummy node so that we can rotate the ball
# without rotating the ray that will be attached to it
# CollisionTraversers calculate collisions
self.cTrav = CollisionTraverser()
#self.cTrav.showCollisions(render)
#self.cTrav.showCollisions(render)
# A list collision handler queue
self.cHandler = CollisionHandlerQueue()
# add collision nodes to the traverse.
# maximum nodes per traverser: 32
self.cTrav.addCollider(self.ballSphere,self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp,self.cHandler)
self.cTrav.addCollider(self.cnodePath, self.cHandler)
# collision traversers have a built-in tool to visualize collisons
#self.cTrav.showCollisions(render)
self.start()
def __init__(self):
self.rayCTrav = CollisionTraverser("collision traverser for ray tests")
#self.pusher = PhysicsCollisionHandler()
self.pusher = CollisionHandlerPusher()
self.pusher.addInPattern('%fn-in-%in')
self.pusher.addOutPattern('%fn-out-%in')
self.pusher.addInPattern('%fn-in')
self.pusher.addOutPattern('%fn-out')
def __init__(self):
self.pNode = render.attachNewNode('playerRoot') # The root node of the player
self.eyeHeight = 1.5 # The z height of the camera
self.selectedBlock = 0
self.adjacentBlock = 0
self.selectedPlayer = None
self.playerState = PlayerState(self)
self.inputBuffer = InputBuffer()
self.currentItem = None
self.itemModels = {}
self.playerModel = None
# The bounding box of the player for collision with environment geometry
self.boundingBoxCenterNode = self.pNode.attachNewNode('bboxCenter')
self.boundingBoxCenterNode.setPos(0, 0, 0.9)
self.boundingBox = BoundingBox(self.boundingBoxCenterNode, [0.2, 0.2, 0.9])
self.animFSM = PlayerAnimationFSM(self)
self.animFSM.request('Idle')
self.camNode = self.pNode.attachNewNode('cam') # The position of the player's eyes
self.camNode.setPos(0, 0, self.eyeHeight)
self.playerParent = self.pNode.attachNewNode('playerParent')
# Change this back so items follow player turning
#self.itemNode = self.playerParent.attachNewNode('3rdPersonItem')
self.itemNode = self.pNode.attachNewNode('3rdPersonItem')
self.itemNode.setPos(0, 0, 1.2)
self.camItemNode = self.camNode.attachNewNode('1stPersonItem')
# Node for name text
self.nameText = None
self.nameNode = self.pNode.attachNewNode('NameNode')
self.nameNode.setPos(0, 0, 1.97)
self.lookingRayNode = self.pNode.attachNewNode('lookingRayNode')
self.lookingRayNode.setPos(0, 0, self.eyeHeight)
lookingSeg = CollisionSegment(0, 0, 0, 0, 100, 0)
self.lookingRay = self.lookingRayNode.attachNewNode(CollisionNode('lookingRay'))
self.lookingRay.node().addSolid(lookingSeg)
self.lookingRay.node().setFromCollideMask(Globals.BLOCK_PICKER_BITMASK | Globals.PLAYER_BITMASK)
self.lookingRay.node().setIntoCollideMask(BitMask32.allOff())
self.lookingRayCollisionEntry = None
self.pickerCollisionHandler = CollisionHandlerQueue()
self.pickerTraverser = CollisionTraverser('pickerTraverser')
self.pickerTraverser.addCollider(self.lookingRay, self.pickerCollisionHandler)
if(not Settings.IS_SERVER):
self.selectionGeom = SelectionGeom()
else:
self.selectionGeom = None
self.CreateCollisionGeoms()
self.LoadModels()
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
self.orbCollisionHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
#hbPath = NodePath()
utilsKristina.HealthBar()
utilsKristina.setUpKeys(self)
utilsKristina.loadModels(self)
utilsKristina.setUpLighting(self)
utilsKristina.setUpFloatingSpheres(self)
utilsKristina.setUpRalphsShot(self)
utilsKristina.setUpCamera(self)
utilsKristina.setUpCollisionSpheres(self)
self.healthTxt = utilsKristina.addInstructions(.06,"Health: 100")
self.orbTxt = utilsKristina.addInstructions(.18,"Orbs: 0")
self.vec = LVector3(0,1,0)#vector for pawns shot
# Create a frame
#frame = DirectFrame(text = "main", scale = 0.001)
# Add button
#bar = DirectWaitBar(text = "", value = 50, pos = (0,.4,.4))
#bar.reparent(render)
# Game state variables
self.isMoving = False
self.jumping = False
self.vz = 0
self.numOrbs = 0
self.healthCount = 100
#self.shotList = []
taskMgr.add(self.move, "moveTask")
#taskMgr.add(utils2.moveChris,"moveChrisTask")
self.sphere = CollisionSphere(0,0,4,2)
self.sphere2 = CollisionSphere(0,0,2,2)
self.cnodePath = self.ralph.attachNewNode((CollisionNode('ralphColNode')))
self.cnodePath.node().addSolid(self.sphere)
self.cnodePath.node().addSolid(self.sphere2)
#self.cnodePath.show()
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.cnodePath, self.ralph)
#self.cTrav.addCollider(self.cnodePath, self.ralphCollisionHandler)
self.cTrav.addCollider(self.cnodePath, self.pusher)
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
self.chrisLastShotTime = globalClock.getFrameTime()
self.chrisTimer = globalClock.getDt()
def setupCollision(self):
self.sphere = self.model.attachNewNode( CollisionNode('range') )
self.sphere.node().addSolid( CollisionSphere(0, 0, 0, self.range) )
self.sphere.node().setFromCollideMask( BitMask32(2) )
self.sphere.node().setIntoCollideMask(BitMask32.allOff())
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.sphere, self.cHandler)
def loadCursorPicker(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)
def setUpCamera(self):
""" puts camera behind the player in third person """
# Set up the camera
# Adding the camera to actor is a simple way to keep the camera locked
# in behind actor regardless of actor's movement.
base.camera.reparentTo(self.actor)
# We don't actually want to point the camera at actors's feet.
# This value will serve as a vertical offset so we can look over the actor
self.cameraTargetHeight = 0.5
# How far should the camera be from the actor
self.cameraDistance = 10
# Initialize the pitch of the camera
self.cameraPitch = 45
# The mouse moves rotates the camera so lets get rid of the cursor
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
#set up FOV
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
# 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.
"""
TODO:: This will need to be changed to bullet
"""
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)
# We will detect anything obstructing the camera's view of the player
self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(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.actor.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
class Colisiones:
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 choque(self, task):
self.traverser.addCollider(self.cnodePath, self.queue)
self.traverser.traverse(render)
for i in range(self.queue.getNumEntries()):
entry = self.queue.getEntry(i)
self.energy[int( entry.getIntoNode().getName() )].setPos(0,0,5000)
self.bebidas = self.bebidas + 1
global texta
texta.destroy()
texta = addText( 0.9, -1.2, "Hasta Ahora LLevamos " + str(self.bebidas) + " Bebidas", 0.07 )
return Task.cont
def __init__(self, ship):
self.ship = ship
self.setup_collision()
self.queue = CollisionHandlerQueue()
self.traverser = CollisionTraverser('Collision Traverser')
self.traverser.showCollisions(render)
self.traverser.add_collider(self.target_nodepath, self.queue)
base.taskMgr.add(self.collide, "Collision Task")
def setupPicker(self):
self.pickerTrav = CollisionTraverser('LT.pickerTrav')
self.pickerRay = CollisionRay()
rayNode = CollisionNode('LT.pickerNode')
rayNode.addSolid(self.pickerRay)
rayNode.setCollideMask(BitMask32(0))
rayNode.setFromCollideMask(CIGlobals.WallBitmask)
self.pickerRayNode = base.camera.attachNewNode(rayNode)
self.pickerHandler = CollisionHandlerQueue()
self.pickerTrav.addCollider(self.pickerRayNode, self.pickerHandler)
def setupClickCollision(self):
self.clickHandler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('ClickTraverser')
base.cTrave = self.traverser
self.clickerNode = CollisionNode('mouseClick')
self.clickerNodePoint = self.camera.attachNewNode(self.clickerNode)
self.clickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.clickerRay = CollisionRay()
self.clickerNode.addSolid(self.clickerRay)
self.traverser.addCollider(self.clickerNodePoint,self.clickHandler)
class MouseCollision:
def __init__(self, game):
self.game = game
self.c_trav = CollisionTraverser()
self.mouse_groundHandler = CollisionHandlerQueue()
self.mouse_ground_ray = CollisionRay()
self.mouse_ground_col = CollisionNode('mouseRay')
self.mouse_ground_ray.setOrigin(0, 0, 0)
self.mouse_ground_ray.setDirection(0, -1, 0)
self.mouse_ground_col.addSolid(self.mouse_ground_ray)
self.mouse_ground_col.setFromCollideMask(CollideMask.bit(0))
self.mouse_ground_col.setIntoCollideMask(CollideMask.allOff())
self.mouse_ground_col_np = self.game.camera.attachNewNode(self.mouse_ground_col)
self.c_trav.addCollider(self.mouse_ground_col_np, self.mouse_groundHandler)
self.game.taskMgr.add(self.update, 'updateMouse')
def update(self, task):
if self.game.mouseWatcherNode.hasMouse():
if self.game.ship.model:
mouse_pos = self.game.mouseWatcherNode.getMouse()
self.mouse_ground_ray.setFromLens(self.game.camNode, mouse_pos.getX(), mouse_pos.getY())
near_point = render.getRelativePoint(self.game.camera, self.mouse_ground_ray.getOrigin())
near_vec = render.getRelativeVector(self.game.camera, self.mouse_ground_ray.getDirection())
self.game.ship.shipPoint.setPos(self.PointAtY(self.game.ship.model.getY(), near_point, near_vec))
return task.cont
def PointAtY(self, y, point, vec):
return point + vec * ((y - point.getY()) / vec.getY())
def setupMouseCollision(self):
self.mouseTraverser = CollisionTraverser()
self.mouseCollisionQueue = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.mouseRay.setOrigin(self.pandaScene.camera.getPos(self.pandaScene.render))
self.mouseRay.setDirection(self.pandaScene.render.getRelativeVector(self.pandaScene.camera, Vec3(0,1,0)))
self.mouseNode = CollisionNode('mouseRay')
self.mouseNode.addSolid(self.mouseRay)
self.mouseNodePath = self.pandaScene.camera.attachNewNode(self.mouseNode)
self.mouseNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mouseTraverser.addCollider(self.mouseNodePath, self.mouseCollisionQueue)
def __init__(self, mouse):
ShowBase.__init__(self)
self.mouse = mouse
self.joy_x = None
self.joy_y = None
props = WindowProperties()
props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen
self.disableMouse()
self.win.requestProperties(props)
self.setBackgroundColor(0, 0, 0)
# Make missiles glow
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large")
self.screen_width = self.win.getXSize()
self.screen_height = self.win.getYSize()
self.center_x = self.screen_width/2
self.center_y = self.screen_height/2
# self.win.movePointer(0, self.center_x, self.center_y)
self.enableParticles()
self.cTrav = CollisionTraverser()
# self.cTrav.setRespectPrevTransform(True)
self.pusher = PhysicsCollisionHandler()
self.pusher.addInPattern('%fn-into-%in')
self.target = None
self.maxvel = 50
self.roll_time = 0
self.fuel = 1000
self.ship()
self.sounds()
self.hud()
self.part = Spacedust(self)
self.events()
self.camLens.setFov(70)
self.camLens.setNear(1)
self.camLens.setFar(500)
self.get_key = {
"ACCEL": False,
"DECEL": False,
"FORWARD_THRUST": False,
"REVERSE_THRUST": False,
"ROLL_LEFT": False,
"ROLL_RIGHT": False,
"ROLL_LEFT_BEG": False,
"ROLL_RIGHT_BEG": False,
"FIRE": False,
"FIRING": False,
"LOCK": False,
"LOCKING": False,
}
self.AIworld = AIWorld(self.render)
self.taskMgr.add(self.update, "task-update")
self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage")
self.taskMgr.add(self.AI_update, "AI-update")
self.gen_enemy()
