class FreeBLiTZ(ShowBase): def __init__(self): from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4 ShowBase.__init__(self) self.sky = self.loader.loadModel('models/sky-sphere') self.sky.reparentTo(self.render) self.stage = self.loader.loadModel('models/test-collide') self.stage.reparentTo(self.render) self.floor = self.stage.findAllMatches('**/=CollideType=floor') self.floor.setCollideMask(FLOOR_MASK) self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle') if self.obstacles: self.obstacles.setCollideMask(OBSTACLE_MASK) self.zones = self.stage.findAllMatches('**/=CollideType=zone') if self.zones: self.zones.setCollideMask(ZONE_MASK) self.create_stanchions() # Character rig, which allows camera to follow character self.char_rig = self.stage.attachNewNode('char_rig') self.active_char = Character('mainchar', self.char_rig) self.cam.reparentTo(self.char_rig) self.cam.setPos(0.5, -3, 1.5) self.cam.lookAt(0.5, 0, 1.5) self.light = DirectionalLight('dlight') self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0)) self.lightNP = self.stage.attachNewNode(self.light) self.lightNP.setHpr(-75, -45, 0) self.stage.setLight(self.lightNP) self.amblight = AmbientLight('amblight') self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0)) self.amblightNP = self.stage.attachNewNode(self.amblight) self.stage.setLight(self.amblightNP) self.accept('w', self.active_char.begin_forward) self.accept('a', self.active_char.begin_left) self.accept('s', self.active_char.begin_backward) self.accept('d', self.active_char.begin_right) self.accept('w-up', self.active_char.end_forward) self.accept('a-up', self.active_char.end_left) self.accept('s-up', self.active_char.end_backward) self.accept('d-up', self.active_char.end_right) self.taskMgr.add(self.active_char.MoveTask, 'MoveTask') self.look = False self.prev_pos = None self.accept('mouse2', self.begin_look) self.accept('mouse2-up', self.end_look) self.accept('mouse3', self.active_char.begin_spin) self.accept('mouse3-up', self.active_char.end_spin) self.taskMgr.add(self.MouseTask, 'MouseTask') self.floor_handler = CollisionHandlerFloor() self.floor_handler.addCollider(self.active_char.actor_from_floor, self.char_rig) self.wall_handler = CollisionHandlerPusher() self.wall_handler.addCollider(self.active_char.actor_from_obstacle, self.char_rig) self.zone_handler = CollisionHandlerEvent() self.zone_handler.addInPattern('%fn-into') self.zone_handler.addOutPattern('%fn-out') def foo(entry): print 'You are in the zone' def bar(entry): print 'You are not in the zone' self.accept('blockchar_zone-into', foo) self.accept('blockchar_zone-out', bar) self.cTrav = CollisionTraverser('main traverser') self.cTrav.setRespectPrevTransform(True) self.cTrav.addCollider(self.active_char.actor_from_floor, self.floor_handler) self.cTrav.addCollider(self.active_char.actor_from_obstacle, self.wall_handler) self.cTrav.addCollider(self.active_char.actor_from_zone, self.zone_handler) #self.cTrav.showCollisions(self.stage) def create_stanchions(self): from pandac.PandaModules import GeomVertexReader, CollisionNode, CollisionTube self.stanchions = self.stage.findAllMatches('**/=Stanchion') for stanchion in self.stanchions: geomnode = stanchion.node() radius = float(stanchion.getTag('Stanchion')) geom = geomnode.getGeom(0) vdata = geom.getVertexData() for gp in range(geom.getNumPrimitives()): vreader = GeomVertexReader(vdata, 'vertex') prim = geom.getPrimitive(gp) prim = prim.decompose() for p in range(prim.getNumPrimitives()): start = prim.getPrimitiveStart(p) end = prim.getPrimitiveEnd(p) vertices = [] for v in range(start, end): vi = prim.getVertex(v) vreader.setRow(vi) vertex = vreader.getData3f() vertices.append(vertex) vertices.append(vertices[0]) for i in range(1, len(vertices)): a, b = vertices[i-1], vertices[i] stanchion_np = stanchion.attachNewNode(CollisionNode('stanchion')) print 'creating cyl with radius %f from %s to %s' % (radius, a, b) stanchion_np.node().addSolid(CollisionTube(a[0], a[1], a[2], b[0], b[1], b[2], radius)) stanchion_np.node().setFromCollideMask(OBSTACLE_MASK) geomnode.removeAllGeoms() def begin_look(self): self.look = True def end_look(self): self.look = False self.prev_pos = None def MouseTask(self, task): if self.mouseWatcherNode.hasMouse(): (x, y) = self.mouseWatcherNode.getMouse() if self.prev_pos: if self.look or self.active_char.spinning: h_diff = (x - self.prev_pos[0]) * 180 p_diff = (y - self.prev_pos[1]) * 90 new_h = clamp_deg_sign(self.char_rig.getH() - h_diff) self.char_rig.setH(new_h) self.cam.setP(self.cam.getP() + p_diff) self.active_char.spin(new_h) self.prev_pos = (x, y) return task.cont
class FreeBLiTZ(ShowBase): def __init__(self): from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4 ShowBase.__init__(self) self.sky = self.loader.loadModel('models/sky-sphere') self.sky.reparentTo(self.render) self.stage = self.loader.loadModel('models/test-collide') self.stage.reparentTo(self.render) self.floor = self.stage.findAllMatches('**/=CollideType=floor') self.floor.setCollideMask(FLOOR_MASK) self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle') if self.obstacles: self.obstacles.setCollideMask(OBSTACLE_MASK) self.zones = self.stage.findAllMatches('**/=CollideType=zone') if self.zones: self.zones.setCollideMask(ZONE_MASK) self.create_stanchions() # Character rig, which allows camera to follow character self.char_rig = self.stage.attachNewNode('char_rig') self.active_char = Character('mainchar', self.char_rig) self.cam.reparentTo(self.char_rig) self.cam.setPos(0.5, -3, 1.5) self.cam.lookAt(0.5, 0, 1.5) self.light = DirectionalLight('dlight') self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0)) self.lightNP = self.stage.attachNewNode(self.light) self.lightNP.setHpr(-75, -45, 0) self.stage.setLight(self.lightNP) self.amblight = AmbientLight('amblight') self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0)) self.amblightNP = self.stage.attachNewNode(self.amblight) self.stage.setLight(self.amblightNP) self.accept('w', self.active_char.begin_forward) self.accept('a', self.active_char.begin_left) self.accept('s', self.active_char.begin_backward) self.accept('d', self.active_char.begin_right) self.accept('w-up', self.active_char.end_forward) self.accept('a-up', self.active_char.end_left) self.accept('s-up', self.active_char.end_backward) self.accept('d-up', self.active_char.end_right) self.taskMgr.add(self.active_char.MoveTask, 'MoveTask') self.look = False self.prev_pos = None self.accept('mouse2', self.begin_look) self.accept('mouse2-up', self.end_look) self.accept('mouse3', self.active_char.begin_spin) self.accept('mouse3-up', self.active_char.end_spin) self.taskMgr.add(self.MouseTask, 'MouseTask') self.floor_handler = CollisionHandlerFloor() self.floor_handler.addCollider(self.active_char.actor_from_floor, self.char_rig) self.wall_handler = CollisionHandlerPusher() self.wall_handler.addCollider(self.active_char.actor_from_obstacle, self.char_rig) self.zone_handler = CollisionHandlerEvent() self.zone_handler.addInPattern('%fn-into') self.zone_handler.addOutPattern('%fn-out') def foo(entry): print 'You are in the zone' def bar(entry): print 'You are not in the zone' self.accept('blockchar_zone-into', foo) self.accept('blockchar_zone-out', bar) self.cTrav = CollisionTraverser('main traverser') self.cTrav.setRespectPrevTransform(True) self.cTrav.addCollider(self.active_char.actor_from_floor, self.floor_handler) self.cTrav.addCollider(self.active_char.actor_from_obstacle, self.wall_handler) self.cTrav.addCollider(self.active_char.actor_from_zone, self.zone_handler) #self.cTrav.showCollisions(self.stage) def create_stanchions(self): from pandac.PandaModules import GeomVertexReader, CollisionNode, CollisionTube self.stanchions = self.stage.findAllMatches('**/=Stanchion') for stanchion in self.stanchions: geomnode = stanchion.node() radius = float(stanchion.getTag('Stanchion')) geom = geomnode.getGeom(0) vdata = geom.getVertexData() for gp in range(geom.getNumPrimitives()): vreader = GeomVertexReader(vdata, 'vertex') prim = geom.getPrimitive(gp) prim = prim.decompose() for p in range(prim.getNumPrimitives()): start = prim.getPrimitiveStart(p) end = prim.getPrimitiveEnd(p) vertices = [] for v in range(start, end): vi = prim.getVertex(v) vreader.setRow(vi) vertex = vreader.getData3f() vertices.append(vertex) vertices.append(vertices[0]) for i in range(1, len(vertices)): a, b = vertices[i - 1], vertices[i] stanchion_np = stanchion.attachNewNode( CollisionNode('stanchion')) print 'creating cyl with radius %f from %s to %s' % ( radius, a, b) stanchion_np.node().addSolid( CollisionTube(a[0], a[1], a[2], b[0], b[1], b[2], radius)) stanchion_np.node().setFromCollideMask(OBSTACLE_MASK) geomnode.removeAllGeoms() def begin_look(self): self.look = True def end_look(self): self.look = False self.prev_pos = None def MouseTask(self, task): if self.mouseWatcherNode.hasMouse(): (x, y) = self.mouseWatcherNode.getMouse() if self.prev_pos: if self.look or self.active_char.spinning: h_diff = (x - self.prev_pos[0]) * 180 p_diff = (y - self.prev_pos[1]) * 90 new_h = clamp_deg_sign(self.char_rig.getH() - h_diff) self.char_rig.setH(new_h) self.cam.setP(self.cam.getP() + p_diff) self.active_char.spin(new_h) self.prev_pos = (x, y) return task.cont
#** This is a task function called each frame, where the collision ray position is syncronized with the mouse pointer position def rayupdate(task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() # this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) return task.cont #** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'. # That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events... collisionHandler.addInPattern("%(rays)ft-into-%(balls)it") # ...and here for the OUT events collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it") #** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below. collisionHandler.addAgainPattern("ray_again_all%(" "rays" ")fh%(" "balls" ")ih") """ Note that we could have been done the same using this form as well: collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it") but then we should have used 2 accepts like this: DO.accept('ray1-again-smileys', collideAgainBalls) DO.accept('ray1-again-frowney', collideAgainBalls)
class CollisionManager: def __init__(self): self.line_dir = NodePath() base.cTrav = CollisionTraverser() self.col_handler = CollisionHandlerEvent() picker_node = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(picker_node) self.pickerRay = CollisionRay() picker_node.addSolid(self.pickerRay) plane_node = CollisionNode("base_plane") plane = base.render.attachNewNode(plane_node) self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) picker_node.addSolid(self.pickerRay) picker_node.setTag("rays", "mray") base.cTrav.addCollider(pickerNPos, self.col_handler) self.col_handler.addInPattern("%(rays)ft-into-%(type)it") self.col_handler.addOutPattern("%(rays)ft-out-%(type)it") self.col_handler.addAgainPattern("ray_again_all%(" "rays" ")fh%(" "type" ")ih") self.model = loader.loadModel("../models/chest.egg") self.model_node = NodePath("sdfafd") self.model.reparentTo(self.model_node) self.model_node.reparentTo(render) # # self.text_node = TextNode("battle_text") # self.text_node.setText("TEXTYTEXTYTEXTTEXT") # self.text_node_path = render.attachNewNode(self.text_node) # self.text_node_path.reparentTo(render) # self.text_node_path.setPos(0,0,4) # self.text_node_path.setHpr(0,0,0) # self.text_node_path.setScale(1) # #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha) # self.text_node.setTextColor((1,1,1,1)) # self.text_node.setAlign(TextNode.ALeft) self.placement_ghost = EditorObjects.PlacementGhost( 0, "tower", base.object_scale) z = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z)) taskMgr.add(self.ray_update, "updatePicker") taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane") taskMgr.add(self.task_mouse_press_check, "checkMousePress") self.input_init() self.pickable = None def input_init(self): self.DO = DirectObject() self.DO.accept('mouse1', self.mouse_click, ["1-down"]) self.DO.accept('mouse1-up', self.mouse_click, ["1-up"]) self.DO.accept('mouse3', self.mouse_click, ["3-down"]) self.DO.accept('0', self.placement_ghost.change_player, [0]) self.DO.accept('1', self.placement_ghost.change_player, [1]) self.DO.accept('2', self.placement_ghost.change_player, [2]) self.DO.accept('a', self.placement_ghost.change_type, ["army"]) self.DO.accept('t', self.placement_ghost.change_type, ["tower"]) self.DO.accept('control-s', base.xml_manager.save) self.DO.accept('mray-into-army', self.col_in_object) self.DO.accept('mray-out-army', self.col_out_object) self.DO.accept('mray-into-tower', self.col_in_object) self.DO.accept('mray-out-tower', self.col_out_object) self.DO.accept('ray_again_all', self.col_against_object) def col_against_object(self, entry): if entry.getIntoNodePath().getParent() != self.pickable: np_from = entry.getFromNodePath() np_into = entry.getIntoNodePath() self.selected_type = np_into.getTag("type") self.pickable = np_into.getParent() def col_in_object(self, entry): if base.state == "selecting": np_into = entry.getIntoNodePath() np_into.getParent().setColor(0.5, 0.5, 0.5, 1) def col_out_object(self, entry): np_into = entry.getIntoNodePath() try: np_into.getParent().clearColor() except: print "ERROR CLEARING COLOUR" def get_mouse_plane_pos(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine( self.pos3d, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): #print "Mouse ray intersects ground plane at ", self.pos3d self.model_node.setPos(render, self.pos3d) self.placement_ghost.set_position(self.pos3d[0], self.pos3d[1]) return task.again def ray_update(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) return task.cont def task_mouse_place(self, task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): self.placing_object = True self.place_pos = (self.anchor_x, self.anchor_y) self.line_dir.remove() ls = LineSegs() ls.move_to(self.anchor_x, self.anchor_y, 1) ls.draw_to(self.model.getX(), self.model.getY(), 1) node = ls.create() angle1 = math.atan2(self.anchor_y - self.anchor_y, self.anchor_x - self.anchor_x + 50) angle2 = math.atan2(self.anchor_y - self.model.getY(), self.anchor_x - self.model.getY()) final_angle = angle1 - angle2 self.model.setHpr(final_angle, 0, 0) self.line_dir = NodePath(node) self.line_dir.reparentTo(render) return task.again else: self.line_dir.hide() taskMgr.add(self.task_mouse_press_check, "checkMousePress") return task.done def task_mouse_press_check(self, task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): #if self.multi_select == True: self.anchor_x, self.anchor_y = self.model.getX(), self.model.getY() taskMgr.add(self.task_mouse_place, "multibox") return task.done return task.again def mouse_click(self, status): print base.state if status == "1-down": if base.state == "placement": if self.placement_ghost.get_type() == "tower": obj = self.placement_ghost.place("tower", self.model.getX(), self.model.getY()) elif self.placement_ghost.get_type() == "army": obj = self.placement_ghost.place("army", self.model.getX(), self.model.getY()) base.details_box.set_object(obj) base.change_state("modifying") elif base.state == "moving": obj = base.details_box.get_object() obj.set_position(self.pos3d[0], self.pos3d[1]) base.change_state("modifying") elif base.state == "selecting" and self.pickable != None: obj = base.get_obj_from_node(self.pickable) base.details_box.set_object(obj, "selecting") base.change_state("modifying") elif status == "1-up": print "Mouse", status elif status == "3-down": if base.state == "placement": base.change_state("selecting") elif base.state == "selecting": base.change_state("placement")
class CogdoFlyingCollisions(GravityWalker): wantFloorSphere = 0 def __init__(self): GravityWalker.__init__(self, gravity=0.0) def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius = 1.4, floorOffset = 1.0, reach = 1.0): self.cHeadSphereNodePath = None self.cFloorEventSphereNodePath = None self.setupHeadSphere(avatarNodePath) self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius) GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach) def setupWallSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius) cSphereNode = CollisionNode('Flyer.cWallSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) if config.GetBool('want-fluid-pusher', 0): self.pusher = CollisionHandlerFluidPusher() else: self.pusher = CollisionHandlerPusher() self.pusher.addCollider(cSphereNodePath, self.avatarNodePath) self.cWallSphereNodePath = cSphereNodePath def setupEventSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04) cSphere.setTangible(0) cSphereNode = CollisionNode('Flyer.cEventSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.event = CollisionHandlerEvent() self.event.addInPattern('enter%in') self.event.addOutPattern('exit%in') self.cEventSphereNodePath = cSphereNodePath def setupRay(self, bitmask, floorOffset, reach): cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0) cRayNode = CollisionNode('Flyer.cRayNode') cRayNode.addSolid(cRay) self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode) cRayNode.setFromCollideMask(bitmask) cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerGravity() self.lifter.setLegacyMode(self._legacyLifter) self.lifter.setGravity(self.getGravity(0)) self.lifter.addInPattern('%fn-enter-%in') self.lifter.addAgainPattern('%fn-again-%in') self.lifter.addOutPattern('%fn-exit-%in') self.lifter.setOffset(floorOffset) self.lifter.setReach(reach) self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath) def setupHeadSphere(self, avatarNodePath): collSphere = CollisionSphere(0, 0, 0, 1) collSphere.setTangible(1) collNode = CollisionNode('Flyer.cHeadCollSphere') collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask) collNode.setIntoCollideMask(BitMask32.allOff()) collNode.addSolid(collSphere) self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode) self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0) self.headCollisionEvent = CollisionHandlerEvent() self.headCollisionEvent.addInPattern('%fn-enter-%in') self.headCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius): cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75) cSphereNode = CollisionNode('Flyer.cFloorEventSphere') cSphereNode.addSolid(cSphere) cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.floorCollisionEvent = CollisionHandlerEvent() self.floorCollisionEvent.addInPattern('%fn-enter-%in') self.floorCollisionEvent.addAgainPattern('%fn-again-%in') self.floorCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent) self.cFloorEventSphereNodePath = cSphereNodePath def deleteCollisions(self): GravityWalker.deleteCollisions(self) if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) self.cHeadSphereNodePath.detachNode() self.cHeadSphereNodePath = None self.headCollisionsEvent = None if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) self.cFloorEventSphereNodePath.detachNode() self.cFloorEventSphereNodePath = None self.floorCollisionEvent = None self.cRayNodePath.detachNode() del self.cRayNodePath self.cEventSphereNodePath.detachNode() del self.cEventSphereNodePath def setCollisionsActive(self, active = 1): if self.collisionsActive != active: if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) if active: base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) if active: base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent) GravityWalker.setCollisionsActive(self, active) def enableAvatarControls(self): pass def disableAvatarControls(self): pass def handleAvatarControls(self, task): pass
class CogdoFlyingCollisions(GravityWalker): wantFloorSphere = 0 def __init__(self): GravityWalker.__init__(self, gravity=0.0) def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius=1.4, floorOffset=1.0, reach=1.0): self.cHeadSphereNodePath = None self.cFloorEventSphereNodePath = None self.setupHeadSphere(avatarNodePath) self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius) GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach) return def setupWallSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius) cSphereNode = CollisionNode('Flyer.cWallSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) if config.GetBool('want-fluid-pusher', 0): self.pusher = CollisionHandlerFluidPusher() else: self.pusher = CollisionHandlerPusher() self.pusher.addCollider(cSphereNodePath, self.avatarNodePath) self.cWallSphereNodePath = cSphereNodePath def setupEventSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04) cSphere.setTangible(0) cSphereNode = CollisionNode('Flyer.cEventSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.event = CollisionHandlerEvent() self.event.addInPattern('enter%in') self.event.addOutPattern('exit%in') self.cEventSphereNodePath = cSphereNodePath def setupRay(self, bitmask, floorOffset, reach): cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0) cRayNode = CollisionNode('Flyer.cRayNode') cRayNode.addSolid(cRay) self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode) cRayNode.setFromCollideMask(bitmask) cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerGravity() self.lifter.setLegacyMode(self._legacyLifter) self.lifter.setGravity(self.getGravity(0)) self.lifter.addInPattern('%fn-enter-%in') self.lifter.addAgainPattern('%fn-again-%in') self.lifter.addOutPattern('%fn-exit-%in') self.lifter.setOffset(floorOffset) self.lifter.setReach(reach) self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath) def setupHeadSphere(self, avatarNodePath): collSphere = CollisionSphere(0, 0, 0, 1) collSphere.setTangible(1) collNode = CollisionNode('Flyer.cHeadCollSphere') collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask) collNode.setIntoCollideMask(BitMask32.allOff()) collNode.addSolid(collSphere) self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode) self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0) self.headCollisionEvent = CollisionHandlerEvent() self.headCollisionEvent.addInPattern('%fn-enter-%in') self.headCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius): cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75) cSphereNode = CollisionNode('Flyer.cFloorEventSphere') cSphereNode.addSolid(cSphere) cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.floorCollisionEvent = CollisionHandlerEvent() self.floorCollisionEvent.addInPattern('%fn-enter-%in') self.floorCollisionEvent.addAgainPattern('%fn-again-%in') self.floorCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent) self.cFloorEventSphereNodePath = cSphereNodePath def deleteCollisions(self): GravityWalker.deleteCollisions(self) if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) self.cHeadSphereNodePath.detachNode() self.cHeadSphereNodePath = None self.headCollisionsEvent = None if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) self.cFloorEventSphereNodePath.detachNode() self.cFloorEventSphereNodePath = None self.floorCollisionEvent = None self.cRayNodePath.detachNode() del self.cRayNodePath self.cEventSphereNodePath.detachNode() del self.cEventSphereNodePath return def setCollisionsActive(self, active=1): if self.collisionsActive != active: if self.cHeadSphereNodePath != None: base.cTrav.removeCollider(self.cHeadSphereNodePath) if active: base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent) if self.cFloorEventSphereNodePath != None: base.cTrav.removeCollider(self.cFloorEventSphereNodePath) if active: base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent) GravityWalker.setCollisionsActive(self, active) return def enableAvatarControls(self): pass def disableAvatarControls(self): pass def handleAvatarControls(self, task): pass
class CollisionManager: def __init__(self): self.line_dir = NodePath() base.cTrav = CollisionTraverser() self.col_handler = CollisionHandlerEvent() picker_node = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(picker_node) self.pickerRay = CollisionRay() picker_node.addSolid(self.pickerRay) plane_node = CollisionNode("base_plane") plane = base.render.attachNewNode(plane_node) self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) picker_node.addSolid(self.pickerRay) picker_node.setTag("rays","mray") base.cTrav.addCollider(pickerNPos, self.col_handler) self.col_handler.addInPattern("%(rays)ft-into-%(type)it") self.col_handler.addOutPattern("%(rays)ft-out-%(type)it") self.col_handler.addAgainPattern("ray_again_all%(""rays"")fh%(""type"")ih") self.model = loader.loadModel("../models/chest.egg") self.model_node = NodePath("sdfafd") self.model.reparentTo(self.model_node) self.model_node.reparentTo(render) # # self.text_node = TextNode("battle_text") # self.text_node.setText("TEXTYTEXTYTEXTTEXT") # self.text_node_path = render.attachNewNode(self.text_node) # self.text_node_path.reparentTo(render) # self.text_node_path.setPos(0,0,4) # self.text_node_path.setHpr(0,0,0) # self.text_node_path.setScale(1) # #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha) # self.text_node.setTextColor((1,1,1,1)) # self.text_node.setAlign(TextNode.ALeft) self.placement_ghost = EditorObjects.PlacementGhost(0,"tower",base.object_scale) z=0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z)) taskMgr.add(self.ray_update, "updatePicker") taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane") taskMgr.add(self.task_mouse_press_check, "checkMousePress") self.input_init() self.pickable=None def input_init(self): self.DO=DirectObject() self.DO.accept('mouse1', self.mouse_click, ["1-down"]) self.DO.accept('mouse1-up', self.mouse_click, ["1-up"]) self.DO.accept('mouse3', self.mouse_click, ["3-down"]) self.DO.accept('0', self.placement_ghost.change_player, [0]) self.DO.accept('1', self.placement_ghost.change_player, [1]) self.DO.accept('2', self.placement_ghost.change_player, [2]) self.DO.accept('a', self.placement_ghost.change_type, ["army"]) self.DO.accept('t', self.placement_ghost.change_type, ["tower"]) self.DO.accept('control-s', base.xml_manager.save) self.DO.accept('mray-into-army', self.col_in_object) self.DO.accept('mray-out-army', self.col_out_object) self.DO.accept('mray-into-tower', self.col_in_object) self.DO.accept('mray-out-tower', self.col_out_object) self.DO.accept('ray_again_all', self.col_against_object) def col_against_object(self,entry): if entry.getIntoNodePath().getParent() != self.pickable: np_from=entry.getFromNodePath() np_into=entry.getIntoNodePath() self.selected_type = np_into.getTag("type") self.pickable = np_into.getParent() def col_in_object(self,entry): if base.state == "selecting": np_into=entry.getIntoNodePath() np_into.getParent().setColor(0.5,0.5,0.5,1) def col_out_object(self,entry): np_into=entry.getIntoNodePath() try: np_into.getParent().clearColor() except: print "ERROR CLEARING COLOUR" def get_mouse_plane_pos(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine(self.pos3d, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): #print "Mouse ray intersects ground plane at ", self.pos3d self.model_node.setPos(render, self.pos3d) self.placement_ghost.set_position(self.pos3d[0],self.pos3d[1]) return task.again def ray_update(self,task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont def task_mouse_place(self,task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): self.placing_object = True self.place_pos = (self.anchor_x,self.anchor_y) self.line_dir.remove() ls = LineSegs() ls.move_to(self.anchor_x,self.anchor_y,1) ls.draw_to(self.model.getX(),self.model.getY(),1) node = ls.create() angle1 = math.atan2(self.anchor_y - self.anchor_y,self.anchor_x - self.anchor_x+50) angle2 = math.atan2(self.anchor_y - self.model.getY(),self.anchor_x - self.model.getY()); final_angle = angle1-angle2; self.model.setHpr(final_angle,0,0) self.line_dir = NodePath(node) self.line_dir.reparentTo(render) return task.again else: self.line_dir.hide() taskMgr.add(self.task_mouse_press_check, "checkMousePress") return task.done def task_mouse_press_check(self,task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): #if self.multi_select == True: self.anchor_x,self.anchor_y = self.model.getX(),self.model.getY() taskMgr.add(self.task_mouse_place, "multibox") return task.done return task.again def mouse_click(self,status): print base.state if status == "1-down": if base.state == "placement": if self.placement_ghost.get_type() == "tower": obj = self.placement_ghost.place("tower",self.model.getX(),self.model.getY()) elif self.placement_ghost.get_type() == "army": obj = self.placement_ghost.place("army",self.model.getX(),self.model.getY()) base.details_box.set_object(obj) base.change_state("modifying") elif base.state == "moving": obj = base.details_box.get_object() obj.set_position(self.pos3d[0],self.pos3d[1]) base.change_state("modifying") elif base.state == "selecting" and self.pickable != None: obj = base.get_obj_from_node(self.pickable) base.details_box.set_object(obj,"selecting") base.change_state("modifying") elif status == "1-up": print "Mouse",status elif status == "3-down": if base.state == "placement": base.change_state("selecting") elif base.state == "selecting": base.change_state("placement")
class StrategyGame(ShowBase): def __init__(self): ShowBase.__init__(self) self.camera_control() self.REGION_MAP = "maps/italy_provs.png" self.TEXTURE_MAP = "maps/italy_terrain2.png" self.WORLD_MAP = "maps/italy_map.xml" self.SCENARIO_MAP = "scenarios/italy_scen.xml" self.terrainScale = 1 # Currently Broken self.keyboard_setup() self.drawTerrain() self.xml_load_map(self.WORLD_MAP,"WorldMap") self.xml_load_map(self.SCENARIO_MAP,"Scenario") self.init_collisions() self.pickingEnabledObject = None self.taskMgr.add(self.camera_update, "UpdateCameraTask") self.generate_models() self.txtBox = OnscreenText("<No province>") self.setup_collision_calcs() taskMgr.add(self.rayUpdate, "updatePicker") taskMgr.doMethodLater(0.2,self.task_calendar, "calendar") self.init_variables() self.interface() def init_variables(self): self.armies = [[],[]] for n in range(len(self.nations)): self.armies.append(n) self.target = 0 self.army_count = 0 self.selected_prov = -1 self.months = ["January","February","March","April","May","June", "July","August","September","October","November","December"] self.adce = "AD" self.player = 1 self.money_inc = 0 for p in range(len(self.provs)): if self.provs_owner[p] == self.player: self.money_inc += self.provs_money[p] self.men_inc = 0 for p in range(len(self.provs)): if self.provs_owner[p] == self.player: self.men_inc += self.provs_men[p] def draw_card(self,x,y,width,height,colour): cm = CardMaker("CardMaker") cm.setFrame(x, x+width,y+height, y) card = render2d.attachNewNode(cm.generate()) card.setColor(colour) return (card) def interface(self): self.interface_back = self.draw_card(-0.8,-1,1.6,0.4,(100,100,100,100)) self.txt_name = OnscreenText(text = "", pos = (-0.8,-0.7,-0.8)) self.txt_money = OnscreenText(text = "", pos = (-0.8,-0.8,-0.8)) self.txt_men = OnscreenText(text = "", pos = (-0.8,-0.9,-0.8)) self.txt_nation = OnscreenText(text = self.nations[self.player-1], pos = (-1.2,0.9,-0.8)) self.txt_nation_money = OnscreenText(text = "Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc), pos = (-0.4,0.9,-0.8)) self.txt_nation_men = OnscreenText(text = "Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc), pos = (0.4,0.9,-0.8)) self.txt_date = OnscreenText(text = str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce, pos = (-1.0,0.8,-0.8)) def task_calendar(self,task): #task.delayTime = 5 if (self.month == 1 or self.month == 3 or self.month == 5 or self.month == 7 or self.month == 8 or self.month == 10 or self.month == 12): if self.day == 31 and self.month == 12: self.day = 1 self.month = 1 self.year += 1 elif self.day == 31: self.day = 1 self.month += 1 else: self.day += 1 elif (self.month == 4 or self.month == 6 or self.month == 9 or self.month == 11): if self.day == 30: self.day = 1 self.month += 1 else: self.day += 1 elif (self.month == 2): # if isleap: # print self.year/4 # print "LEAP YEAR" # if self.day == 29: # self.day = 1 # self.month = 3 # else: # self.day += 1 # else: print "IS NOT A LEAP YEAR" if self.day == 28: self.day = 1 self.month = 3 else: self.day += 1 self.daypass() return Task.again def daypass(self): self.nations_money[self.player-1] += self.money_inc self.nations_men[self.player-1] += self.men_inc self.update_interface() def update_interface(self): self.txt_date.setText(str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce) self.txt_nation_money.setText("Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc)) self.txt_nation_men.setText("Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc)) if self.selected_prov != -1: self.txt_name.setText("Province: "+self.provs[self.selected_prov]) self.txt_money.setText("Income: "+str(self.provs_money[self.selected_prov])) self.txt_men.setText("Manpower: "+str(self.provs_men[self.selected_prov])) self.interface_back.setColor(self.format_colour_tuple(self.nations_rgb[self.provs_owner[self.selected_prov]-1])) else: self.txt_name.setText("") self.txt_money.setText("") self.txt_men.setText("") self.interface_back.setColor((255,255,255,255)) def army_create(self): id = self.army_count+1 army = self.loader.loadModel("models/man.x") self.armies[0].append(id) army.reparentTo(self.render) army.setName(str(id)) army.setScale(1, 1, 1) x = 50 y = 50 target = self.target target_x = float(self.provs_x[target]) target_y = 257-float(self.provs_y[target]) target_z = float(self.getObjectZ(target_x,target_y)-1) oArmyCol = army.attachNewNode(CollisionNode("BuildingCNode%d"%id)) oArmyCol.setScale((2,2,2)) oArmyCol.node().addSolid(CollisionSphere(0,0,0,1)) oArmyCol.setTag("unit","army") oArmyCol.show() point1 = Point3(x,y,0) point2 = Point3(target_x,target_y,target_z) distance = (point1.getXy() - point2.getXy()).length() myInterval = army.posInterval(distance/10, Point3(target_x,target_y, target_z)) mySequence = Sequence(myInterval) mySequence.start() army.setPos(x, y, self.getObjectZ(x,y)-1) army.setTag("target",str(target)) self.army_count += 1 if (self.target<len(self.provs)-1): self.target += 1 else: self.target = 0 #taskMgr.add() def army_update(self,id): point1 = self.armies[0][id-1].getPos() point2 = Point3(target_x,target_y,target_z) distance = (point1.getXy() - point2.getXy()).length() def init_collisions(self): base.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerEvent() pickerNode = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) pickerNode.setTag("rays","ray1") base.cTrav.addCollider(pickerNPos, self.cHandler) def setup_collision_calcs(self): self.cHandler.addInPattern("%(rays)ft-into-%(prov)it") self.cHandler.addOutPattern("%(rays)ft-out-%(prov)it") self.cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""prov"")ih") self.DO=DirectObject() self.DO.accept('ray1-into-city', self.collideInBuilding) self.DO.accept('ray1-out-city', self.collideOutBuilding) self.DO.accept('ray_again_all', self.collideAgainstBuilds) self.pickingEnabledOject=None self.DO.accept('mouse1', self.mouseClick, ["down"]) self.DO.accept('mouse1-up', self.mouseClick, ["up"]) def camera_control(self): base.disableMouse() self.camera = base.camera self.cam_speed = 3 self.cam_drag = 0.01 self.cam_x_moving = False self.cam_y_moving = False self.cam_z_moving = False self.cam_x_inc = 0 self.cam_y_inc = 0 self.cam_z_inc = 0 self.cameraDistance = -50 self.camHeight = 25 self.camXAngle = 0 self.camYAngle = -25 self.camZAngle = 0 self.camX = 0 self.camY = 0 self.camZ = 100 def camera_update(self,task): if self.cam_x_moving: self.camX+=self.cam_x_inc elif self.cam_x_inc != 0: if (self.cam_x_inc > 0 and self.cam_x_inc-self.cam_drag <= 0) or (self.cam_x_inc < 0 and self.cam_x_inc+self.cam_drag >= 0): self.cam_x_inc = 0 elif self.cam_x_inc > 0: self.cam_x_inc -= self.cam_drag elif self.cam_x_inc < 0: self.cam_x_inc -= self.cam_drag else: print "FUCKUP WITH CAM X INC" if self.cam_y_moving: self.camY+=self.cam_y_inc elif self.cam_y_inc != 0: if (self.cam_y_inc > 0 and self.cam_y_inc-self.cam_drag <= 0) or (self.cam_y_inc < 0 and self.cam_y_inc+self.cam_drag >= 0): self.cam_y_inc = 0 elif self.cam_y_inc > 0: self.cam_y_inc -= self.cam_drag elif self.cam_y_inc < 0: self.cam_y_inc -= self.cam_drag else: print "FUCKUP WITH CAM Y INC" if self.cam_z_moving: self.camZ+=self.cam_z_inc elif self.cam_z_inc != 0: if (self.cam_z_inc > 0 and self.cam_z_inc-self.cam_drag <= 0) or (self.cam_z_inc < 0 and self.cam_z_inc+self.cam_drag >= 0): self.cam_z_inc = 0 elif self.cam_z_inc > 0: self.cam_z_inc -= self.cam_drag elif self.cam_z_inc < 0: self.cam_z_inc -= self.cam_drag else: print "FUCKUP WITH CAM Z INC" self.camera.setPos(self.camX, self.camY, self.camZ) self.camera.setHpr(self.camXAngle, self.camYAngle, self.camZAngle) return Task.cont def camera_move(self, status): if status == "up": self.cam_y_moving = True self.cam_y_inc = self.cam_speed if status == "down": self.cam_y_moving = True self.cam_y_inc = -self.cam_speed if status == "left": self.cam_x_moving = True self.cam_x_inc = -self.cam_speed if status == "right": self.cam_x_moving = True self.cam_x_inc = self.cam_speed if status == "stopX": self.cam_x_moving = False if status == "stopY": self.cam_y_moving = False def keyboard_setup(self): self.accept("w", self.keyW) self.accept("w-up", self.stop_y) self.accept("s", self.keyS) self.accept("s-up", self.stop_y) self.accept("a", self.keyA) self.accept("a-up", self.stop_x) self.accept("d", self.keyD) self.accept("d-up", self.stop_x) self.accept("+", self.ZoomIn) self.accept("c", self.createArmy) def createArmy(self): self.army_create() def ZoomIn(self): self.camZ -= 1 def keyW( self ): self.camera_move("up") def keyS( self ): self.camera_move("down") def keyA( self ): self.camera_move("left") def keyD( self ): self.camera_move("right") def stop_x( self ): self.camera_move("stopX") def stop_y( self ): self.camera_move("stopY") def generate_models(self): for p in range(len(self.provs)): print "Making",self.provs[p] city = self.loader.loadModel("models/house2.x") city.reparentTo(self.render) city.setName(self.provs[p]) city.setScale(2, 2, 2) x = float(self.provs_x[p]*self.terrainScale) y = 257*self.terrainScale-float(self.provs_y[p]*self.terrainScale) city.setPos(x, y, self.getObjectZ(x,y)-1) oCityCol = city.attachNewNode(CollisionNode("BuildingCNode%d"%p)) oCityCol.setScale((3,3,3)) oCityCol.node().addSolid(CollisionSphere(0,0,0,1)) oCityCol.setTag("prov","city") city.setTag("id",str(p+1)) #oCityCol.show() def collideInBuilding(self,entry): np_into=entry.getIntoNodePath() np_into.getParent().setColor(.6,.5,1.0,1) def collideOutBuilding(self,entry): np_into=entry.getIntoNodePath() np_into.getParent().setColor(1.0,1.0,1.0,1) self.pickingEnabledObject = None self.txtBox.setText("<No province>") def collideAgainstBuilds(self,entry): if entry.getIntoNodePath().getParent() <> self.pickingEnabledOject: np_from=entry.getFromNodePath() np_into=entry.getIntoNodePath() self.pickingEnabledObject = np_into.getParent() self.txtBox.setText(self.pickingEnabledObject.getName()) def mouseClick(self,status): if self.pickingEnabledObject: if status == "down": self.pickingEnabledObject.setScale(0.95*2) print self.pickingEnabledObject.getTag("id"),self.provs[int(self.pickingEnabledObject.getTag("id"))-1] self.selected_prov = int(self.pickingEnabledObject.getTag("id"))-1 self.update_interface() if status == "up": self.pickingEnabledObject.setScale(1.0*2) elif self.pickingEnabledObject == None: self.selected_prov = -1 self.update_interface() def rayUpdate(self,task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont def getObjectZ(self, x, y): if ((x > 0) and (x < 257) and (y > 0) and (y < 257)): return(self.terrain.getElevation(x,y)*self.terrainSize) else: return 0 def format_colour_tuple(self,colour): col = string.split(colour) tuple = (int(col[0]),int(col[1]),int(col[2]),255) return tuple def drawTerrain(self): self.terrainSize = 5 heightmap = "maps/italy_heightmap.png" colmap = self.TEXTURE_MAP self.terrain = GeoMipTerrain("terrain") self.terrain.setHeightfield(heightmap) self.terrain.setColorMap(colmap) self.terrain.setBlockSize(64) #self.terrain.setNear(40) #self.terrain.setFar(120) #self.terrain.setMinLevel(1) self.terrain.setBruteforce(True) self.terrain.generate() self.terrain.setAutoFlatten(self.terrain.AFMLight) self.root = self.terrain.getRoot() self.root.reparentTo(render) self.root.setSz(self.terrainSize) #self.root.setScale(self.terrainScale,self.terrainScale,1) def xml_load_map(self,file,type): if type == "WorldMap": tree = xml.parse(file) root = tree.getroot() self.provs = [] self.provs_x = [] self.provs_y = [] self.provs_rgb = [] self.provs_owner = [] self.provs_money = [] self.provs_men = [] counter = 1 for p in root.findall("province"): self.provs.append(self.get_tag(root,"province", counter, "name")) self.provs_x.append(self.get_tag(root, "province", counter, "x")) self.provs_y.append(self.get_tag(root, "province", counter, "y")) self.provs_rgb.append(self.get_tag(root, "province", counter, "rgb")) self.provs_owner.append(0) self.provs_money.append(0) self.provs_men.append(0) counter+=1 elif type == "Scenario": tree = xml.parse(file) root = tree.getroot() self.day = 0 self.month = 0 self.year = 0 self.adce = 0 self.day = int(root.attrib["day"]) self.month = int(root.attrib["month"]) self.year = int(root.attrib["year"]) self.nations = [] self.nations_rgb = [] self.nations_capital = [] self.nations_money = [] self.nations_men = [] self.nations_provs_id = [] counter = 0 for p in root.findall("province"): print p.attrib["id"] for n in root.findall("nation"): for p in n.findall("province"): self.provs_owner[int(p.attrib["id"])-1] = int(p.find("owner").text) self.provs_money[int(p.attrib["id"])-1] = int(p.find("money").text) self.provs_men[int(p.attrib["id"])-1] = int(p.find("men").text) print self.provs_owner[int(p.attrib["id"])-1] counter+=1 counter = 1 for n in root.findall("nation"): self.nations.append(self.get_tag(root, "nation", counter, "name")) self.nations_capital.append(n.attrib["capital"]) #print self.nations_capital self.nations_rgb.append(self.get_tag(root, "nation", counter, "rgb")) self.nations_money.append(int(self.get_tag(root, "nation", counter, "money"))) self.nations_men.append(int(self.get_tag(root, "nation", counter, "men"))) counter += 1 def get_tag(self,root,str_tag,prov_id, prov_tag): prov = root.find('.//'+str_tag+'[@id="'+str(prov_id)+'"]') tag = prov.find(prov_tag).text return tag
base.disableMouse() # ========================================================================= # Main """ While the principles are almost the same for 3D space, picking in 2D require a little change to adapt to the 2D layer, it's aspect and camera view (that is called orthographic). """ # ========================================================================= # ** First big difference: as you may know, we used so far to assign the collision traverser to the global Showbase member cTrav, that is automatically updated (traversed) but it operates under the render nodepath that we know works in the 3D space and thewrefore we'll store the traverser apart in a convenient variable to be manually traversed later by our routine and act in 2d space. customCtrav = CollisionTraverser() collisionHandler = CollisionHandlerEvent() # to keep the stuff simple, we specify fixed pattern strings to just check the into and out of all our colliders, because we know they are just cards and the ray FROM collider collisionHandler.addInPattern("ray-into-cards") collisionHandler.addOutPattern("ray-out-cards") PICKING_MASK = BitMask32.bit(1) # ** Setting the ray collider pickerNode = CollisionNode("mouseraycnode") # another important but obvious difference from step 6 is that this time we parent the ray nodepath in render2d instead render root nodepath, otherwise all the objects we're going to define in 2D won't be seen by the ray. pickerNP = base.render2d.attachNewNode(pickerNode) pickerNP.show() # note that this time we set the ray dimension along the Y axis 2 point long to pierce everything is on the Y=0 position (2D objects are usually placed there) pickerRay = CollisionRay(0, -1, 0, 0, 1, 0) pickerNode.addSolid(pickerRay) pickerNode.setFromCollideMask(PICKING_MASK) pickerNode.setIntoCollideMask(BitMask32.allOff()) # ** put the ray into the traverse cycle customCtrav.addCollider(pickerNP, collisionHandler)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) global carx,cary,d,cor_ans,count self.disableMouse() self.Truck=[0]*6 self.crate=[0]*10 self.posc=[0]*30 self.radX=[0]*60 self.radY=[0]*60 self.radZ=[0]*60 self.sX=[0]*10 self.sY=[0]*10 self.sZ=[0]*10 self.flag=[0]*10 self.ans=[0]*10 self.inst1 = addInstructions(0.89, "Correct Answer: "+str(cor_ans)) self.inst2 = addInstructions(0.95, "Time: "+str(time)) self.inst3 = addInstructions(0.84, "Waste Reamaining "+str(count/2)) #self.title = addTitle("Recycle Game By : Sandeep Sharma") p = 0 file = open("ans.txt") for line in file: #for p in range(30): #print line line = line.split() self.ans[p] = str(line[0]) p=p+1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() p = 0 file = open("sample.txt") for line in file: #for p in range(30): line = line[0:len(line)-1] #print line self.posc[p] = int(line) p=p+1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() p=0 file = open("scale.txt") for line in file: #for p in range(30): line = line.split() #print line self.sX[p] = float(line[0]) self.sY[p] = float(line[1]) self.sZ[p] = float(line[2]) #print self.radY[p] p=p+1 p = 0 file = open("rad.txt") for line in file: #for p in range(30): line = line.split() #print line self.radX[p] = float(line[0]) self.radY[p] = float(line[1]) self.radZ[p] = float(line[2]) #print self.radY[p] p=p+1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() self.CornField=self.loader.loadModel("cornfield") self.CornField.reparentTo(self.render) self.CornField.setScale(1000,1000,0) self.CornField.setPos(0,0,-8) self.WM=self.loader.loadModel("WM/Windmill") self.WM.reparentTo(self.render) self.WM.setScale(2,2,2) self.WM.setPos(354,131,0) self.WM.setHpr(180,0,0) self.F1=self.loader.loadModel("Forest/Forest") self.F1.reparentTo(self.render) self.F1.setScale(0.8,0.5,0.5) self.F1.setPos(-338,-164,0) self.F1.setHpr(90,0,0) self.F2=self.loader.loadModel("Forest/Forest") self.F2.reparentTo(self.render) self.F2.setScale(0.8,0.5,0.5) self.F2.setPos(366,-189,0) self.F2.setHpr(90,0,0) self.castle=self.loader.loadModel("castle") self.castle.reparentTo(self.render) self.castle.setScale(0.6,0.8,0.5) self.castle.setPos(-97,-200,0) self.castle.setHpr(90,0,0) #print self.castle self.church=self.loader.loadModel("church/Church") self.church.reparentTo(self.render) self.church.setScale(2.5,2.5,1) self.church.setPos(90,-200,0) self.church.setHpr(180,0,0) self.Temple=self.loader.loadModel("Temple/TempleFort") self.Temple.reparentTo(self.render) self.Temple.setScale(0.06,0.1,0.18) self.Temple.setPos(210,-109,0) self.house=self.loader.loadModel("BuildingCluster3") self.house.reparentTo(self.render) self.house.setScale(1.5,1.5,1) self.house.setPos(208,86,0) self.CityHall=self.loader.loadModel("cityhall/CityHall") self.CityHall.reparentTo(self.render) self.CityHall.setScale(1.5,1.5,1.5) self.CityHall.setPos(-188,-84,0) self.CityHall.setHpr(90,0,0) self.statue=self.loader.loadModel("statue/statue") self.statue.reparentTo(self.render) self.statue.setScale(4.5,4.5,3.5) self.statue.setPos(-191,105,0) self.statue.setHpr(-90,0,0) self.FarmHouse=self.loader.loadModel("farmhouse/FarmHouse") self.FarmHouse.reparentTo(self.render) self.FarmHouse.setScale(2.8,3.5,2.5) self.FarmHouse.setPos(-66,209,0) self.Fence1=self.loader.loadModel("fence/fence") self.Fence1.reparentTo(self.render) self.Fence1.setScale(70,1,2) self.Fence1.setPos(0,-418,0) self.Fence2=self.loader.loadModel("fence/fence") self.Fence2.reparentTo(self.render) self.Fence2.setScale(70,1,2) self.Fence2.setPos(0,418,0) self.Fence3=self.loader.loadModel("fence/fence") self.Fence3.reparentTo(self.render) self.Fence3.setScale(70,1,2) self.Fence3.setPos(-418,0,0) self.Fence3.setHpr(90,0,0) self.Fence4=self.loader.loadModel("fence/fence") self.Fence4.reparentTo(self.render) self.Fence4.setScale(70,1,2) self.Fence4.setPos(418,0,0) self.Fence4.setHpr(90,0,0) self.CityTerrain=self.loader.loadModel("CityTerrain/CityTerrain") self.CityTerrain.reparentTo(self.render) self.CityTerrain.setScale(0.5,0.5,0.5) self.CityTerrain.setPos(0,0,0) self.BeachTerrain=self.loader.loadModel("BeachTerrain/BeachTerrain") self.BeachTerrain.reparentTo(self.render) self.BeachTerrain.setScale(0.5,0.5,0.5) self.BeachTerrain.setPos(200,750,0) self.BeachTerrain.setHpr(90,0,0) self.school=self.loader.loadModel("school/school") self.school.reparentTo(self.render) self.school.setScale(0.056,0.07,0.05) self.school.setPos(-162,-348,0) self.school.setHpr(90,0,0) self.car = Actor("bvw-f2004--jeep/jeep",{"walk": "bvw-f2004--jeep/jeep-start"}) self.car.setScale(0.5, 0.5, 0.5) self.car.reparentTo(self.render) self.car.setPos(carx,cary,-2) self.car.setHpr(180,0,0) #print self.car for l in range(10): self.crate[l] = self.loader.loadModel("model"+str(l+1)+"/crate"+str(l+1)+".egg") self.crate[l].setScale(self.sX[l], self.sY[l], self.sZ[l]) self.crate[l].reparentTo(self.render) self.crate[l].setPos(self.posc[3*l],self.posc[3*l + 1],2) self.crate[l].setHpr(0,0,0) #self.car.loop("walk") #self.car.reparentTo(self.render) #self.car.setScale(2,2,2) #self.car.setPos(carx,cary,-2) #self.car.setHpr(0,0,0) self.museum = self.loader.loadModel("Museum/Museum") self.museum.reparentTo(self.render) self.museum.setScale(1,2,1.5) self.museum.setPos(100,200,0) self.museum.setHpr(180,0,0) self.PalmTree = self.loader.loadModel("PalmTree/palmtree") self.PalmTree.reparentTo(self.render) self.PalmTree.setScale(2,2,3.5) self.PalmTree.setPos(175,200,0) self.PalmTree.setHpr(0,0,0) self.stadium = self.loader.loadModel("Stadium/stadium") self.stadium.reparentTo(self.render) self.stadium.setScale(0.5,0.5,0.5) self.stadium.setPos(13,0,0) self.stadium.setHpr(0,0,0) self.Junkyard = self.loader.loadModel("Junkyard") self.Junkyard.reparentTo(self.render) self.Junkyard.setScale(0.2,0.4,0.3) self.Junkyard.setPos(150,-650/2 - 25,0) self.Junkyard.setHpr(90,0,0) self.BB1 = self.loader.loadModel("BuildingCluster1") self.BB1.reparentTo(self.render) self.BB1.setScale(0.5,0.5,1) self.BB1.setPos(-100 - 10,650/2 + 20,0) self.BB1.setHpr(270,0,0) self.BB2 = self.loader.loadModel("BB2/BuildingCluster2") self.BB2.reparentTo(self.render) self.BB2.setScale(0.5,0.5,1) self.BB2.setPos(-60 - 10,650/2 + 20,0) self.BB2.setHpr(270,0,0) self.BB3 = self.loader.loadModel("BB3/BuildingCluster3") self.BB3.reparentTo(self.render) self.BB3.setScale(0.5,0.5,1) self.BB3.setPos(-140 - 10,650/2 + 20,0) self.BB3.setHpr(270,0,0) self.BB4 = self.loader.loadModel("BB4/BuildingCluster4") self.BB4.reparentTo(self.render) self.BB4.setScale(0.5,0.5,1) self.BB4.setPos(-25 - 10,650/2 + 20,0) self.BB4.setHpr(270,0,0) self.BB5 = self.loader.loadModel("BB5/BuildingCluster5") self.BB5.reparentTo(self.render) self.BB5.setScale(0.5,0.5,1) self.BB5.setPos(-190 - 10,650/2 + 20,0) self.BB5.setHpr(270,0,0) self.BS = self.loader.loadModel("BS/blue_sky_sphere") self.BS.reparentTo(self.render) self.BS.setScale(1,1,1) self.BS.setPos(-180,0,0) self.flagMain = self.loader.loadModel("Flag/flag") self.flagMain.setScale(0.3,0.3,0.3) self.flagMain.reparentTo(self.render) self.flagMain.setPos(carx-20,cary,10) print self.flagMain for i in range (6): self.Truck[i] = self.loader.loadModel("bvw-f2004--fireengine/fireengine") self.Truck[i].reparentTo(self.render) self.Truck[i].setScale(2,2,2) ##self.Truck[i].setPos(180,0,0) #Create the four lerp intervals needed to walk back and forth self.setTruck() #self.City = self.loader.loadModel("City/course2") #self.City.reparentTo(self.render) #self.City.setScale(2.5,2.5,2.5) #self.City.setPos(500,0,0) self.accept('arrow_down',self.moved,[0]) self.accept('arrow_up',self.move,[0]) self.accept("arrow_left",self.change_dc,[0]) self.accept("arrow_right",self.change_da,[0]) self.accept('arrow_down-up',self.moved,[2]) self.accept('arrow_up-up',self.move,[2]) #self.accept("arrow_left-up",self.change_dc,[2]) #self.accept("arrow_right-up",self.change_da,[2]) self.accept('arrow_down-repeat',self.moved,[1]) self.accept('arrow_up-repeat',self.move,[1]) self.accept("arrow_left-repeat",self.change_dc,[1]) self.accept("arrow_right-repeat",self.change_da,[1]) base.cTrav = CollisionTraverser() self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern('into-%in') self.collHandEvent.addOutPattern('outof-%in') self.collCount = 0 sColl = self.initCollisionSphere(self.car,1,1,1, True) base.cTrav.addCollider(sColl[0], self.collHandEvent) self.accept('into-' + sColl[1] , self.collide) #self.accept('outof-' + sColl[1], self.collide4) i=0 for child in render.getChildren(): if child != self.CornField and child != camera and child != self.CityTerrain and child!= self.BeachTerrain and child != self.BS and child != self.Fence1 and child != self.Fence2 and child != self.Fence3 and child != self.Fence4: #print child tColl = self.initCollisionSphere(child,self.radX[i],self.radY[i],self.radZ[i], True) base.cTrav.addCollider(tColl[0], self.collHandEvent) #print i i=i+1 # Accept the events sent by the collisions. self.accept('into-' + tColl[1] , self.collide) for l in range(10): self.flag[l] = self.loader.loadModel("Flag/flag") self.flag[l].setScale(0.3,0.3,0.3) self.flag[l].reparentTo(self.render) self.flag[l].setPos(self.posc[3*l],self.posc[3*l + 1],10) # self.accept( 'into-' + sColl[1], self.collide) #self.accept('outof-' + tColl[1], self.collide2) # print carx,cary # cs = CollisionSphere(0, 0, 0, 10) # fromObject = self.car.attachNewNode(CollisionNode('cnode')) # fromObject.node().addSolid(cs) # fromObject.show() # pusher = CollisionHandlerPusher() # pusher.addCollider(fromObject, self.car) # base.cTrav = CollisionTraverser() # base.cTrav.addCollider(fromObject, pusher) self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") def collide(self,collEntry): global carx,cary,car_def,a,Num,count #print "Collide" #print collEntry.getFromNodePath().getParent() #for objectc in collEntry: for l in range(10): #print collEntry.getFromNodePath().getParent() if collEntry.getIntoNodePath().getParent() == self.crate[l] : collEntry.getIntoNodePath().getParent().remove() #print "Baba" Num = l count = count - 1 self.flag[l].hide() self.Game_Point() if str(collEntry.getIntoNodePath().getParent()) == "render/flag.egg" and count == 0 and str(collEntry.getFromNodePath().getParent()) == "render/jeepNman_loop_baked": #print "here" self.GameOver() if str(collEntry.getIntoNodePath().getParent()) == "render/jeepNman_loop_baked" or str(collEntry.getFromNodePath().getParent()) == "render/jeepNman_loop_baked": if a==0: if self.car.getH() == 45: carx = carx + car_def cary = cary - car_def if self.car.getH() == 90: carx = carx + car_def if self.car.getH() == 135: carx = carx + car_def cary = cary + car_def if self.car.getH() == 180: cary=cary + car_def if self.car.getH() == 225: carx = carx - car_def cary = cary + car_def if self.car.getH() == 270: carx = carx - car_def if self.car.getH() == 315: carx =carx - car_def cary= cary - car_def if self.car.getH() == 0: cary = cary - car_def if a==1: car_def= -1*car_def if self.car.getH() == 45: carx = carx + car_def cary = cary - car_def if self.car.getH() == 90: carx = carx + car_def if self.car.getH() == 135: carx = carx + car_def cary = cary + car_def if self.car.getH() == 180: cary=cary + car_def if self.car.getH() == 225: carx = carx - car_def cary = cary + car_def if self.car.getH() == 270: carx = carx - car_def if self.car.getH() == 315: carx =carx - car_def cary= cary - car_def if self.car.getH() == 0: cary = cary - car_def car_def= -1*car_def # def collide2(self,collEntry): # # def collide3(self,collEntry): # global carx , cary # carx=carx-2 # cary=cary-2 # def collide4(self,collEntry): # print 4 def initCollisionSphere(self, obj,setX,setY,setZ, show=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() * 0.6 # Create a collision sphere and name it something understandable. collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName() self.collCount += 1 self.accept('arrow_down',self.moved,[0]) self.accept('arrow_up',self.move,[0]) cNode = CollisionNode(collSphereStr) # cNode.setScale(3,3,3) cNode.addSolid(CollisionSphere(center, radius)) cNodepath = obj.attachNewNode(cNode) cNodepath.setScale(setX,setY,setZ) #cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return (cNodepath, collSphereStr) def moved(self,i): global carx,cary,camx,camy,dis,a #print "moved" a=1 if i ==0: #print "Hello" self.car.loop("walk") if i==2: self.car.stop("walk") #print "hello",self.car.getH() #print base.camera.getH() if carx> -410 and carx<410 and cary>-410 and cary<410: if self.car.getH() == 45: carx = carx - car_speed cary = cary + car_speed camx = carx - dis camy = cary + dis if self.car.getH() == 90: carx = carx - car_speed camx = carx - dis if self.car.getH() == 135: carx = carx - car_speed cary = cary - car_speed camx = carx - dis camy = cary -dis if self.car.getH() == 180: cary=cary - car_speed camy = cary - dis if self.car.getH() == 225: carx = carx + car_speed cary = cary - car_speed camx=carx + dis camy=cary - dis if self.car.getH() == 270: carx = carx + car_speed camx =carx + dis if self.car.getH() == 315: carx =carx +car_speed cary= cary +car_speed camx=carx + dis camy =cary +dis if self.car.getH() == 0: cary = cary + car_speed camy = cary + dis else: if carx <= -410: carx = carx-1 if carx >= 410: carx = carx+1 if cary <= -410: cary = cary-1 if cary >= 410: cary = cary+1 def move(self,i): global carx,cary,camx,camy,dis,a a=0 # print "move" # print carx,cary if i ==0: self.car.loop("walk") if i==2: self.car.stop("walk") #print "hello",self.car.getH() #print base.camera.getH() if carx>-410 and carx<410 and cary>-410 and cary<410: if self.car.getH() == 45: carx = carx + car_speed cary = cary - car_speed camx = carx + dis camy = cary - dis if self.car.getH() == 90: carx = carx + car_speed camx = carx + dis if self.car.getH() == 135: carx = carx + car_speed cary = cary + car_speed camx = carx + dis camy = cary +dis if self.car.getH() == 180: cary=cary + car_speed camy = cary + dis if self.car.getH() == 225: carx = carx - car_speed cary = cary + car_speed camx=carx - dis camy=cary + dis if self.car.getH() == 270: carx = carx - car_speed camx =carx - dis if self.car.getH() == 315: carx =carx - car_speed cary= cary - car_speed camx=carx - dis camy =cary - dis if self.car.getH() == 0: cary = cary - car_speed camy = cary - car_speed else: if carx<=-410: carx = carx+1 if carx>=410: carx= carx-1 if cary<=-410: cary = cary+1 if cary>=410: cary=cary -1 # self.car.loop("walk") def change_dc(self,i): global d #if i ==0: # print "Hello" # self.car.loop("walk") #if i==2: # self.car.stop("walk") d=d + 45 d=d % 360 def change_da(self,i): global d #if i ==0: # print "Hello" # self.car.loop("walk") #if i==2: # self.car.stop("walk") d = d - 45 d=d%360 #for j in range(9): # d=d - 5 # # d=d % 360 # self.car.setHpr(d , 0 , 0) # time.sleep(0.1) #messenger.send('arrow_up-repeat') def spinCameraTask(self, task): global time,carx,cary,d,dis,camx,camy,count,cor_ans time = int(task.time) #r = d * (pi / 180.0) #print carx,cary if self.car.getH() == 45: camx = carx - dis camy = cary + dis if self.car.getH() == 90: camx = carx - 1.41*dis camy = cary if self.car.getH() == 135: camx = carx - dis camy = cary -dis if self.car.getH() == 180: camy = cary - 1.41*dis camx =carx if self.car.getH() == 225: camx=carx + dis camy=cary - dis if self.car.getH() == 270: camx =carx + 1.41*dis camy=cary if self.car.getH() == 315: camx=carx + dis camy =cary +dis if self.car.getH() == 0: camy = cary + 1.41*dis camx=carx if h==0: self.inst1.destroy() self.inst2.destroy() self.inst3.destroy() self.inst1 = addInstructions(0.89, "Correct Answer: "+str(cor_ans)) self.inst2 = addInstructions(0.95, "Time: "+str(time)) self.inst3 = addInstructions(0.84, "Waste Reamaining "+str(count/2)) self.car.setPos(carx,cary,0) self.car.setHpr(d , 0 , 0) base.camera.setPos(camx ,camy,5) base.camera.setHpr(d + 180, 0 , 0) #base.camera.setPos(0,0,1700) #base.camera.setHpr(0, -90 , 0) return Task.cont # base.camera.setPos(0,-40,3) # return Task.cont def setTruck(self): pandaPosInterval01= self.Truck[0].posInterval(11,Point3(18,138,0), startPos=Point3(21,390,0)) pandaPosInterval02= self.Truck[0].posInterval(5,Point3(140,132,0), startPos=Point3(18,138,0)) pandaPosInterval03= self.Truck[0].posInterval(10,Point3(140,-123,0), startPos=Point3(140,132,0)) pandaPosInterval04= self.Truck[0].posInterval(5,Point3(-7,-126,0), startPos=Point3(140,-123,0)) pandaPosInterval05= self.Truck[0].posInterval(11,Point3(-10,-399,0), startPos=Point3(-7,-126,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval00= self.Truck[0].hprInterval(1,Point3(180,0,0), startHpr=Point3(0,0,0)) pandaHprInterval01= self.Truck[0].hprInterval(3,Point3(-90,0,0), startHpr=Point3(180,0,0)) pandaHprInterval02= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(-90,0,0)) pandaHprInterval03= self.Truck[0].hprInterval(3,Point3(90,0,0), startHpr=Point3(180,0,0)) pandaHprInterval04= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0)) #pandaHprInterval5= self.Truck[0].hprInterif collEntry.getIntoNodePath().getParent() == self.crate[l]:val(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace0 = Sequence(pandaHprInterval00,pandaPosInterval01, pandaHprInterval01, pandaPosInterval02, pandaHprInterval02,pandaPosInterval03,pandaHprInterval03,pandaPosInterval04,pandaHprInterval04,pandaPosInterval05, name = "pandaPace0") pandaPace0.loop() pandaPosInterval11= self.Truck[1].posInterval(11,Point3(-126,14,0), startPos=Point3(-411,14,0)) pandaPosInterval12= self.Truck[1].posInterval(5,Point3(-117,145,0), startPos=Point3(-126,14,0)) pandaPosInterval13= self.Truck[1].posInterval(10,Point3(148,130,0), startPos=Point3(-117,145,0)) pandaPosInterval14= self.Truck[1].posInterval(5,Point3(145,-5,0), startPos=Point3(148,130,0)) pandaPosInterval15= self.Truck[1].posInterval(11,Point3(394,-8,0), startPos=Point3(145,-5,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval10= self.Truck[1].hprInterval(1,Point3(-90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval11= self.Truck[1].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0)) pandaHprInterval12= self.Truck[1].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval13= self.Truck[1].hprInterval(3,Point3(180,0,0), startHpr=Point3(-90,0,0)) pandaHprInterval14= self.Truck[1].hprInterval(3,Point3(-90,0,0), startHpr=Point3(180,0,0)) #pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace1 = Sequence(pandaHprInterval10,pandaPosInterval11, pandaHprInterval11, pandaPosInterval12, pandaHprInterval12,pandaPosInterval13,pandaHprInterval13,pandaPosInterval14,pandaHprInterval14,pandaPosInterval15, name = "pandaPace1") pandaPace1.loop() pandaPosInterval21= self.Truck[2].posInterval(11,Point3(-9,-144,0), startPos=Point3(-6,-358,0)) pandaPosInterval22= self.Truck[2].posInterval(5,Point3(-129,-137,0), startPos=Point3(-9,-144,0)) pandaPosInterval23= self.Truck[2].posInterval(10,Point3(-129,142,0), startPos=Point3(-129,-137,0)) pandaPosInterval24= self.Truck[2].posInterval(5,Point3(5,145,0), startPos=Point3(-129,142,0)) pandaPosInterval25= self.Truck[2].posInterval(11,Point3(20,395,0), startPos=Point3(5,145,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval20= self.Truck[2].hprInterval(1,Point3(0,0,0), startHpr=Point3(0,0,0)) pandaHprInterval21= self.Truck[2].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval22= self.Truck[2].hprInterval(3,Point3(0,0,0), startHpr=Point3(90,0,0)) pandaHprInterval23= self.Truck[2].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval24= self.Truck[2].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0)) #pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace2 = Sequence(pandaHprInterval20,pandaPosInterval21, pandaHprInterval21, pandaPosInterval22, pandaHprInterval22,pandaPosInterval23,pandaHprInterval23,pandaPosInterval24,pandaHprInterval24,pandaPosInterval25, name = "pandaPace2") pandaPace2.loop() pandaPosInterval31= self.Truck[3].posInterval(11,Point3(150,-18,0), startPos=Point3(408,-18,0)) pandaPosInterval32= self.Truck[3].posInterval(5,Point3(147,-135,0), startPos=Point3(150,-18,0)) pandaPosInterval33= self.Truck[3].posInterval(10,Point3(-120,-138,0), startPos=Point3(147,-135,0)) pandaPosInterval34= self.Truck[3].posInterval(5,Point3(-123,-6,0), startPos=Point3(-120,-138,0)) pandaPosInterval35= self.Truck[3].posInterval(11,Point3(-396,10,0), startPos=Point3(-123,-6,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval31= self.Truck[3].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0)) pandaHprInterval32= self.Truck[3].hprInterval(3,Point3(90,0,0), startHpr=Point3(180,0,0)) pandaHprInterval33= self.Truck[3].hprInterval(3,Point3(0,0,0), startHpr=Point3(90,0,0)) pandaHprInterval34= self.Truck[3].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace4 = Sequence(pandaHprInterval30,pandaPosInterval31, pandaHprInterval31, pandaPosInterval32, pandaHprInterval32,pandaPosInterval33,pandaHprInterval33,pandaPosInterval34,pandaHprInterval34,pandaPosInterval35, name = "pandaPace4") pandaPace4.loop() pandaPosInterval41= self.Truck[4].posInterval(12,Point3(298,-282,0), startPos=Point3(-276,-282,0)) pandaPosInterval42= self.Truck[4].posInterval(12,Point3(286,280,0), startPos=Point3(298,-282,0)) pandaPosInterval43= self.Truck[4].posInterval(12,Point3(-268,280,0), startPos=Point3(286,280,0)) pandaPosInterval44= self.Truck[4].posInterval(12,Point3(-276,-282,0), startPos=Point3(-268,280,0)) #pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval41= self.Truck[4].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval42= self.Truck[4].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0)) pandaHprInterval43= self.Truck[4].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval44= self.Truck[4].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace5 = Sequence(pandaHprInterval41,pandaPosInterval41, pandaHprInterval42, pandaPosInterval42, pandaHprInterval43,pandaPosInterval43,pandaHprInterval44,pandaPosInterval44, name = "pandaPace5") pandaPace5.loop() pandaPosInterval51= self.Truck[5].posInterval(12,Point3(-268,280,0), startPos=Point3(286,280,0)) pandaPosInterval52= self.Truck[5].posInterval(12,Point3(-276,-282,0), startPos=Point3(-268,280,0)) pandaPosInterval53= self.Truck[5].posInterval(12,Point3(298,-282,0), startPos=Point3(-276,-282,0)) pandaPosInterval54= self.Truck[5].posInterval(12,Point3(286,280,0), startPos=Point3(298,-282,0)) #pandaPosInterval55= self.Truck[5].posInterval(13,Point3(-396,10,0), startPos=Point3(-123,-6,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) #pandaHprInterval50= self.Truck[5].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval51= self.Truck[5].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval52= self.Truck[5].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0)) pandaHprInterval53= self.Truck[5].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval54= self.Truck[5].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace6 = Sequence(pandaHprInterval51,pandaPosInterval51, pandaHprInterval52, pandaPosInterval52, pandaHprInterval53,pandaPosInterval53,pandaHprInterval54,pandaPosInterval54, name = "pandaPace6") pandaPace6.loop() def Game_Point(self): self.ignore("arrow_down") self.ignore("arrow_up") self.ignore("arrow_down-repeat") self.ignore("arrow_up-repeat") #self.text1 = addInstructions(0.5,"Is this Recyclable") self.text1 = TextNode('t1') self.text1.setText("is This Recyclable") self.text1.setTextColor(0,0,0,1) self.textNodePath1 = aspect2d.attachNewNode(self.text1) self.textNodePath1.setScale(0.07) self.textNodePath1.setPos(-0.1,-0.1,0.1) #text1.setTextColor(1,1,1) self.text1.setFrameColor(1, 0, 0, 1) self.text1.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.text2 = TextNode('t2') self.text2.setText("Y/N") self.text2.setTextColor(0,0,0,1) self.textNodePath2 = aspect2d.attachNewNode(self.text2) self.textNodePath2.setScale(0.07) self.textNodePath2.setPos(0,0,0) #textNodePath2.setTextColor(1,1,1) self.text2.setFrameColor(1, 0, 0, 1) self.text2.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.accept('y',self.answer,[0]) self.accept('n',self.answer,[1]) def answer(self,n): global Num,cor_ans #print self.ans[Num] self.accept('arrow_down',self.moved,[0]) self.accept('arrow_up',self.move,[0]) self.accept('arrow_down-repeat',self.moved,[1]) self.accept('arrow_up-repeat',self.move,[1]) aspect2d.getChildren().detach() if n == 0: if self.ans[Num] == 'Y': cor_ans = cor_ans + 1 if n == 1: if self.ans[Num] == 'N': #print "Correct" cor_ans = cor_ans + 1 self.ignore('y') self.ignore('n') #print "Hello" def GameOver(self): global cor_ans,time,h h=1 #print time for x in self.render.getChildren(): x.detachNode() self.inst1.destroy() self.inst2.destroy() self.inst3.destroy() self.text3 = TextNode('t1') self.text3.setText("Game Over ") self.text3.setTextColor(1,0,0,1) self.textNodePath3 = aspect2d.attachNewNode(self.text3) self.textNodePath3.setScale(0.1) self.textNodePath3.setPos(-0.1,-0.1,0.2) #text1.setTextColor(1,1,1) #self.text3.setFrameColor(1, 0, 0, 1) #self.text3.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.text5 = TextNode('t1') self.text5.setText("Time Taken: "+ str(time)) self.text5.setTextColor(1,0,0,1) self.textNodePath5 = aspect2d.attachNewNode(self.text5) self.textNodePath5.setScale(0.1) self.textNodePath5.setPos(-0.1,-0.1,0) self.text6 = TextNode('t1') self.text6.setText("correct answer: " + str(cor_ans)) self.text6.setTextColor(1,0,0,1) self.textNodePath6 = aspect2d.attachNewNode(self.text6) self.textNodePath6.setScale(0.1) self.textNodePath6.setPos(-0.1,-0.1,-0.2) self.text4 = TextNode('t2') self.text4.setText("Score: " + str(5000/time + (cor_ans * 10))) self.text4.setTextColor(1,0,0,1) self.textNodePath4 = aspect2d.attachNewNode(self.text4) self.textNodePath4.setScale(0.1) self.textNodePath4.setPos(-0.1,-0.1,-0.4)
class Level2World(object): def __init__(self, render, loader, theBase, world, hopper): self.render = render self.loader = loader base = theBase self.world = world self.hopper = hopper base.disableMouse() #----- Play Music ----- self.backgroundMusic = base.loader.loadSfx("sounds/deathDanceMusic.mp3") self.backgroundMusic.play() self.failSound = base.loader.loadSfx("sounds/fail.wav") #------ State Variables ----- self.isLit = False #----- Setup Visible World ----- self.platforms = [] self.spinningPlatforms = [] self.spinners = [] self.berries = [] self.coins = [] self.enemies = [] self.setupPlatforms() self.setupCoins() self.setupBerries() self.setupEnemies() self.endToken = Coin(self.render, self.world, self.hopper, 0, 0.6, 0.6, Vec3(0, 0, 1)) self.endToken.coinNP.reparentTo(self.platforms[-1].platformBulletNode) self.wizardLair = WizardLair(self.render, self.world, self.loader, self.hopper) self.wizardLair.wizardGate.reparentTo(self.platforms[1].platformBulletNode) self.wizardLair.castle.reparentTo(self.platforms[6].platformBulletNode) self.wizardLair.lair.reparentTo(self.platforms[11].platformBulletNode) self.sky = loader.loadModel("models/art/cat-skies/alice-skies--celestial/celestial.egg") self.sky.setPos(0, 0, 0) self.sky.setP(90) self.sky.setScale(1) self.sky.reparentTo(self.render) #----- Setup Light ----- self.directionalLight2 = DirectionalLight( "directionalLight" ) self.directionalLight2.setColor( Vec4( 1, 1, 1, 1 ) ) self.directionalLight2.setDirection(Vec3(0, 0, -1)) self.directionalLightNP = self.render.attachNewNode(self.directionalLight2) #----- Collision Handling ----- base.cTrav = CollisionTraverser() self.collisionHandler = CollisionHandlerEvent() self.pickerNode = CollisionNode('mouseRayCollisionNode') self.pickerNP = base.camera.attachNewNode(self.pickerNode) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerNP, self.collisionHandler) self.collisionHandler.addInPattern("mouseRayIntoEnemy") self.collisionHandler.addOutPattern("mouseRayOutEnemy") self.pickingEnabledObject = None #----- Tasks ----- def update(self, task): self.hopper.processInput() for enemy in self.enemies: if enemy.getHealth() != 0: enemy.pace() dt = globalClock.getDt() self.world.doPhysics(dt, 10, 1/180.0) return task.cont def simulateWater(self, task): if self.hopper.hopperNP.getZ() < 0: self.hopper.freeze = True return task.done else: return task.cont def rayUpdate(self, task): if base.mouseWatcherNode.hasMouse(): mPos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mPos.getX(), mPos.getY()) return task.cont #----- Setup Enemy Functions ----- def setupEnemies(self): enemy1 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 1) enemy1.enemyNP.reparentTo(self.platforms[3].platformBulletNode) enemy2 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 2) enemy2.enemyNP.reparentTo(self.platforms[4].platformBulletNode) self.enemies.append(enemy1) self.enemies.append(enemy2) #----- Lair Enemies ----- enemy = Enemy(self.render, self.world, base, Point3(3, 16, 1), self.hopper, 1, strength = 2, size = 1.3) enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode) self.enemies.append(enemy) enemy = Enemy(self.render, self.world, base, Point3(3, -16, 1), self.hopper, 1, strength = 2, size = 1.3) enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode) self.enemies.append(enemy) enemy = Enemy(self.render, self.world, base, Point3(13, 3, 1), self.hopper, 1, strength = 2, size = 1.3) enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode) self.enemies.append(enemy) enemy = Enemy(self.render, self.world, base, Point3(-13, 3, 1), self.hopper, 1, strength = 2, size = 1.3) enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode) self.enemies.append(enemy) def resetEnemies(self): for enemy in self.enemies: enemy.enemyNP.remove_node() self.enemies = [] self.setupEnemies() def collideEventIn(self, entry): print "Selected enemy!" np_from = entry.getFromNodePath() np_into = entry.getIntoNodePath() np_into.getParent().setColor(.6, 0.5, 1.0, 1) self.pickingEnabledObject = np_into def collideEventOut(self, entry): print "Deselected enemy!" self.pickingEnabledObject = None np_into = entry.getIntoNodePath() np_into.getParent().setColor(1.0, 1.0, 1.0, 1) def mousePick(self, status): if self.pickingEnabledObject: if status == 'down': idNum = self.pickingEnabledObject.getTag("id") self.enemies[int(idNum)-1].lowerHealth() if status == 'up': pass #----- Setup Item Functions ----- def setupPlatforms(self): path = "images/wizardFloor.jpg" platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-2, 3, -1), tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-13, 3, -1), tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-24, 3, 0), roll = 20, tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-38, 3, 3), tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-50, 3, 4), tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-62, 3, 5), tex = path) self.platforms.append(platform) platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(-72, 3, 6), tex = path) self.platforms.append(platform) x = -68; y = 3; z = 5 heading = 0 for i in range(4): platform = Platform(self.render, self.world, heading, Vec3(7, 6, 0.5), Point3(x, y, z), tex = path) self.platforms.append(platform) self.spinningPlatforms.append(platform) x -= 8; z += 1.8 platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(x - 40, -15, z), tex = path) self.platforms.append(platform) x -= 40; y = 3 heading = 45 for i in range(4): platform = Platform(self.render, self.world, heading, Vec3(9, 7, 0.5), Point3(x, y, z), tex = path) self.platforms.append(platform) if i == 0 or i == 2: spinner = Spinner(self.render, self.world, 90, 25, Vec3(2.2, 0.3, 1), Point3(x+9, y+7, z+2)) self.spinners.append(spinner) x -= 10; y -= 10; z += 1.8 def setupCoins(self): #----- Castle Coins ----- x = 3 for i in range(9): coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -8, 2)) coin.coinNP.reparentTo(self.platforms[6].platformBulletNode) self.coins.append(coin) x -= 2 #----- Lair Coins ----- x = 3 for i in range(8): coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -12, 2)) coin.coinNP.reparentTo(self.platforms[11].platformBulletNode) self.coins.append(coin) x -= 2 index = 2 for i in range(4): coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(0, 0, 2)) coin.coinNP.reparentTo(self.platforms[index].platformBulletNode) self.coins.append(coin) index += 4 def resetCoins(self): print "Inside coins; NOT removing a coin but initializing list to 0" self.coins = [] self.setupCoins() def setupBerries(self): index = 3 mult = 1 for i in range(4): berry1 = Berry(self.render, self.world, self.hopper, 10*mult, 0.35, 0.35, Point3(0, 0, 2)) berry1.berryNP.reparentTo(self.platforms[index].platformBulletNode) self.berries.append(berry1) index += 3 mult *= -1 if mult > 0: mult *= 2 else: mult /= 2 def resetBerries(self): self.berries = [] self.setupBerries() #----- Light Functions ----- def addLight(self): self.dlight = DirectionalLight('dlight') self.dlight.setColor(VBase4(0.9, 0.9, 0.8, 1)) self.dlnp = self.render.attachNewNode(self.dlight) self.dlnp.setHpr(90, -30, 0) self.render.setLight(self.dlnp) self.slight = Spotlight('slight') slens = PerspectiveLens() self.slight.setLens(slens) self.slight.setColor(Vec4(1, 1, 1, 1)) self.slnp = self.render.attachNewNode(self.slight) self.slnp.reparentTo(self.hopper.hopperNP) self.slnp.setPos(0, 40, 50) self.slnp.lookAt(self.hopper.hopperNP) self.render.setLight(self.slnp) self.alight = AmbientLight('alight') self.alight.setColor(VBase4(0.2, 0.4, 1, 1)) self.alnp = self.render.attachNewNode(self.alight) self.render.setLight(self.alnp) self.render.setShaderAuto() self.slight.setShadowCaster(True) for platform in self.platforms: platform.removeNormal() def destroyLight(self): self.render.clearLight(self.dlnp) self.render.clearLight(self.alnp) self.render.clearLight(self.slnp) for platform in self.platforms: platform.addNormal() def destroyWorld(self): for platform in self.platforms: self.world.removeRigidBody(platform.platformBulletNode.node()) platform.platformBulletNode.remove_node() for spinner in self.spinners: self.world.removeRigidBody(spinner.spinnerBulletNode.node()) spinner.spinnerBulletNode.remove_node() for coin in self.coins: self.world.removeGhost(coin.ghostNode) coin.removeCoin() for enemy in self.enemies: enemy.enemyNP.remove_node()
base.disableMouse() #========================================================================= # Main """ While the principles are almost the same for 3D space, picking in 2D require a little change to adapt to the 2D layer, it's aspect and camera view (that is called orthographic). """ #========================================================================= #** First big difference: as you may know, we used so far to assign the collision traverser to the global Showbase member cTrav, that is automatically updated (traversed) but it operates under the render nodepath that we know works in the 3D space and thewrefore we'll store the traverser apart in a convenient variable to be manually traversed later by our routine and act in 2d space. customCtrav = CollisionTraverser() collisionHandler = CollisionHandlerEvent() # to keep the stuff simple, we specify fixed pattern strings to just check the into and out of all our colliders, because we know they are just cards and the ray FROM collider collisionHandler.addInPattern("ray-into-cards") collisionHandler.addOutPattern("ray-out-cards") PICKING_MASK = BitMask32.bit(1) #** Setting the ray collider pickerNode = CollisionNode('mouseraycnode') # another important but obvious difference from step 6 is that this time we parent the ray nodepath in render2d instead render root nodepath, otherwise all the objects we're going to define in 2D won't be seen by the ray. pickerNP = base.render2d.attachNewNode(pickerNode) pickerNP.show() # note that this time we set the ray dimension along the Y axis 2 point long to pierce everything is on the Y=0 position (2D objects are usually placed there) pickerRay = CollisionRay(0, -1, 0, 0, 1, 0) pickerNode.addSolid(pickerRay) pickerNode.setFromCollideMask(PICKING_MASK) pickerNode.setIntoCollideMask(BitMask32.allOff()) #** put the ray into the traverse cycle customCtrav.addCollider(pickerNP, collisionHandler)
class MyApp(ShowBase): def cleanUpStartScreen( self ): self.startButton.destroy( ) # get rid of the button self.logoModel.detachNode( ) # detach the logo model from the render self.loadGame( ) # load the actual game # end cleanUpStartScreen def addInstructions(pos, msg): return OnscreenText(text=msg, style=1, fg=(1,1,1,1),pos=(-1.3, pos), align=TextNode.ALeft, scale = .05) def __init__(self): global x,y,z #self.loadStartScreen() ShowBase.__init__(self) #self.setupBackgroundColor(1,1,1) # set the camera position #camera.setPosHpr( Vec3( 0, -10, 0 ), Vec3( 0, 0, 0 ) ) # load our logo model self.logoModel = loader.loadModel("bvw-f2004--truck/cartruck.egg") self.logoModel.reparentTo( render ) # set the logo model's position self.logoModel.setPosHpr( Vec3( 0, 15, 0 ), Vec3( 0, 0, 0 ) ) # create and display a start button self.startButton = DirectButton( text = "Go!", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( 1.0, 0.0, -0.8 ), command = self.cleanUpStartScreen ) self.disableMouse() self.obs = [None] * 100 self.keyMap = {"forward":0, "slow":0, "left":0, "right":0} #self.environ = [None]*100 self.grb= [None] * 100 self.env= [None] * 20 self.env1= [None] * 20 self.envx= [None] * 20 self.envy= [None] * 20 self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True) self.title1 = OnscreenText(text="LIVES: " + str(int (gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95,0.7), scale = .07, mayChange = True) self.timeleft = OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True) self.model= self.loader.loadModel("alice-farm--cornfield/cornfield.egg") self.model.reparentTo(self.render) self.model.setPos(-8, 42, 0) self.model.setScale(20,1000,20) # Reparent the model to render. self.environ2 = self.loader.loadModel("bvw-f2004--building/building.egg") self.environ2.reparentTo(self.render) self.environ2.setPos(S1x, S1y, S1z) self.environ2.setScale(0.2, 0.2, 0.2) for i in range(0,100): self.obs[i]= self.loader.loadModel("alice-objects--anvil/anvil.egg") self.obs[i].reparentTo(self.render) self.obs[i].setX(random.choice([0, 10])) self.obs[i].setY(random.randint(100,100000)) self.obs[i].setZ(3) self.obs[i].setScale(10,20,10) for j in range(0,100): self.grb[j]= self.loader.loadModel("alice-shapes--icosahedron/icosahedron.egg") self.grb[j].reparentTo(self.render) self.grb[j].setX(random.choice([0, 10])) self.grb[j].setY(random.randint(100, 100000)) self.grb[j].setZ(3) self.grb[j].setScale(0.8,3,0.8) for k in range(0,20): self.envx[k]= self.loader.loadModel("bvw-f2004--building/building.egg") self.envx[k].reparentTo(self.render) self.envx[k].setX(random.choice([-60, 60])) self.envx[k].setY(random.randint(13000, 35000)) self.envx[k].setZ(0) self.envx[k].setScale(0.8, 0.8, 0.8) for k in range(0,20): self.envy[k]= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg") self.envy[k].reparentTo(self.render) self.envy[k].setX(random.choice([-100, 100])) self.envy[k].setY(random.randint(38000, 60000)) self.envy[k].setZ(0) self.envy[k].setScale(0.8, 0.8, 0.8) self.environ4 = self.loader.loadModel("alice-city--townhouse1/townhouse1.egg") self.environ4.reparentTo(self.render) self.environ4.setPos(T1x, T1y, T1z) self.environ4.setScale(0.6, 0.6, 0.6) self.BS = self.loader.loadModel("alice-skies--bluesky/bluesky.egg") self.BS.reparentTo(self.render) self.BS.setScale(10,10,10) self.BS.setPos(-180,0,0) self.barn= self.loader.loadModel("alice-farm--farmhouse/farmhouse.egg") self.barn.reparentTo(self.render) self.barn.setScale(0.5, 0.5, 0.5) self.barn.setPos(30,500,0) self.barn1= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg") self.barn1.reparentTo(self.render) self.barn1.setScale(0.5, 0.5, 0.5) self.barn1.setPos(40,200,0) self.barn2= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg") self.barn2.reparentTo(self.render) self.barn2.setScale(0.5,0.5,0.5) self.barn2.setPos(70,1700,0) self.barn3= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg") self.barn3.reparentTo(self.render) self.barn3.setScale(0.5,0.5,0.5) self.barn3.setPos(-90,1500,0) self.barn5= self.loader.loadModel("bvw-f2004--course1/course1.egg") self.barn5.reparentTo(self.render) self.barn5.setScale(0.25, 0.25, 0.25) self.barn5.setPos(-100,900,0) # Apply scale and position transforms on the model. self.environ1= self.loader.loadModel("alice-vehicles--zamboni/zamboni.egg") self.environ1.reparentTo(self.render) self.environ1.setPos(E1posX, E1posY, E1posZ) self.environ1.setScale(0.3, 0.3, 0.3) print E1posY def loadGame(self): self.camera.setPos(CposX, CposY, CposZ) self.camera.setHpr(0,0,0) #for j in range(0, 100): #self.environ[j] = self.loader.loadModel("CityTerrain/CityTerrain") #self.environ[j].reparentTo(self.render) #self.environ[j].setPos(-8,42 + 210*j,0) #self.environ[j].setScale(0.25,0.25,0.25) self.accept("arrow_up-repeat", self.setKey, ["forward", 1]) self.accept("arrow_down-repeat", self.setKey, ["slow", 1]) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_right", self.setKey, ["right", 1]) base.cTrav = CollisionTraverser() self.collHandEvent = CollisionHandlerEvent() self.collCount=0 self.collHandEvent.addInPattern('into-%in') self.collHandEvent.addOutPattern('outof-%in') sColl = self.initCollisionSphere(self.environ1, True) base.cTrav.addCollider(sColl[0], self.collHandEvent) for child in render.getChildren(): if child != camera and child != self.environ2 and child!= self.environ4 and child != self.BS and child!= self.model and child!= self.barn and child!= self.barn1 and child!= self.barn2 and child!= self.barn3 and child!= self.barn5: #print child tColl = self.initCollisionSphere(child, True) base.cTrav.addCollider(tColl[0], self.collHandEvent) self.accept('into-' + tColl[1] , self.collide) ## for m in range(0,100): ## tgrb= self.initCollisionSphere(self.grb[i], True) ## base.cTrav.addCollider(tgrb[0], self.collHandEvent) ## self.accept('into-' + tgrb[1], self.collide) ## ## for n in range(0,100): ## tobs= self.initCollisionSphere(self.obs[i], True) ## base.cTrav.addCollider(tobs[0], self.collHandEvent) ## self.accept('into-' + tobs[1], self.collide) self.taskMgr.add(self.move, "moveTask") def initCollisionSphere(self, obj,show=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() *0.5 # Create a collison sphere collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName() self.collCount += 1 cNode = CollisionNode(collSphereStr) cNode.addSolid(CollisionSphere(center, radius)) cNodepath = obj.attachNewNode(cNode) #cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return (cNodepath, collSphereStr) def collide(self, collEntry): global score,E1posY,gameover,adj, CposY if self.environ1.getY()==-100: return if(collEntry.getIntoNodePath().getParent().getName()== "icosahedron.egg"): #print collEntry.getIntoNodePath().getParent().getName() collEntry.getIntoNodePath().getParent().remove() score= score +10 print score self.title.detachNode() self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True) elif(collEntry.getIntoNodePath().getParent().getName()== "anvil.egg"): E1posY= E1posY-50 CposY= CposY-50 self.camera.setPos(CposX, CposY, CposZ) self.environ1.setPos(E1posX, E1posY, E1posZ) gameover= gameover - 1 self.title1.detachNode() self.title1= OnscreenText(text="LIVES: " + str(int(gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95, 0.7), scale = .07, mayChange = True) print gameover if(gameover<=0): print "Game Over" ## time2= int(time-(task.time*0.5)) ## if time1!=time2: ## self.inst2.detachNode() ## self.inst2 = addInstructions(0.89, "Time: "+str(time2)) ## time1=time2 ## if time2==0: OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35) OnscreenText(text= "Your Final Score is " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.015) #time.sleep(10) #sys.exit self.environ1.detachNode() self.camera.detachNode() def setKey(self, key, value): self.keyMap[key]= value def move(self, task): global E1posX, E1posY, E1posY, CposX, CposY, CposZ, S1y, S2y, T1y, n, y,speed, time self.over=0 ts= int(task.time) time= 120 -ts print time,ts self.timeleft.detachNode() self.timeleft= OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True) if(time<=0): time=0 OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35) OnscreenText(text= "Your Final Score is " + str(score), style=1,fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.02) #time.sleep(10) #sys.exit self.environ1.detachNode() self.over=1 if(self.keyMap["forward"]==1): self.keyMap["forward"]=0 speed= 10 if speed>=10: speed= 20 elif speed>=20: speed= 30 dist= speed print dist E1posY= E1posY + dist CposY= CposY + dist S1y= S1y + dist S2y= S2y + dist T1y= T1y + dist y= y+ dist self.environ1.setPos(E1posX, E1posY, E1posZ) self.camera.setPos(CposX, CposY, CposZ) if(E1posY==7500 * n or E1posY== 7500 *n +20): n= n+1 self.environ4.setPos(T1x, T1y, T1z) #self.environ3.setPos(S2x, S2y, S2z) self.environ2.setPos(S1x, S1y, S1z) self.model.setPos(x,y + 550,z) print E1posX, E1posY, E1posZ, CposX, CposY, CposZ, x, y, z elif(self.keyMap["slow"]==1): global slowadj self.keyMap["slow"]=0 if slowadj<100: slowadj+= slowadj speed= speed-10 if speed<0: speed=0 elif slowadj<200: slowadj+= slowadj speed= speed-10 if speed<0: speed=0 elif slowadj<300: slowadj+= slowadj speed= speed-10 if speed<0: speed=0 elif slowadj>=300: speed=0 print speed E1posY= E1posY + speed CposY= CposY + speed S1y= S1y + speed S2y= S2y + speed T1y= T1y + speed y= y + speed self.environ1.setPos(E1posX, E1posY, E1posZ) self.camera.setPos(CposX, CposY, CposZ) if(E1posY>=7700 * n and E1posY<= 7700 *n + 30): n= n+1 self.environ4.setPos(T1x, T1y, T1z) self.environ3.setPos(S2x, S2y, S2z) self.environ2.setPos(S1x, S1y, S1z) self.model.setPos(x,y + 550,z) print E1posX, E1posY, E1posZ, CposX, CposY, CposZ elif(self.keyMap["left"]==1): self.keyMap["left"]=0 if(E1posX!=0): E1posX=0 CposX=0 self.environ1.setPos(E1posX, E1posY, E1posZ) self.camera.setPos(CposX, CposY, CposZ) elif(self.keyMap["right"]==1): self.keyMap["right"]=0 if(E1posX!=10): E1posX=10 CposX=10 self.environ1.setPos(E1posX, E1posY, E1posZ) self.camera.setPos(CposX, CposY, CposZ) elif(self.keyMap["forward"]==0): if(self.over==1): CposY= CposY elif(self.over==0): print E1posY, CposY, speed E1posY= E1posY + speed CposY= CposY + speed S1y= S1y + speed S2y= S2y + speed T1y= T1y + speed y= y + speed self.environ1.setPos(E1posX, E1posY, E1posZ) self.camera.setPos(CposX, CposY, CposZ) if(E1posY>=7500 * n and E1posY<= 7500 *n + 30): n= n+1 self.environ4.setPos(T1x, T1y, T1z) #self.environ3.setPos(S2x, S2y, S2z) self.environ2.setPos(S1x, S1y, S1z) self.model.setPos(x,y + 550,z) return Task.cont
"""This file handles all the collision events of our game """ # base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame) base.cTrav = CollisionTraverser() # collisionHandler specifies what to do when a collision event is detected collisionHandler = CollisionHandlerEvent() # "In" event: when there is a collision in the current frame, but it didn't in the previous frame collisionHandler.addInPattern("%fn-into-%in") # "Again" event: when there is a collision in the current frame, the same that happened in the previous frame collisionHandler.addAgainPattern("%fn-again-%in") # "Out" event: when there isn't a collision in the current frame, but there was in the previous frame collisionHandler.addOutPattern("%fn-out-%in") # self.collision3DPoint is the point where the collision occurs collision3DPoint = [0, 0, 0] # self.addCollider(mousePicking.pickerNP) # self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP) DO = DirectObject() def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]): # Let's manage now the collision events: DO.accept(fromName + "-again-" + intoName, function, extraArgs)
'''This file handles all the collision events of our game ''' #base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame) base.cTrav=CollisionTraverser() #collisionHandler specifies what to do when a collision event is detected collisionHandler = CollisionHandlerEvent() #"In" event: when there is a collision in the current frame, but it didn't in the previous frame collisionHandler.addInPattern('%fn-into-%in') #"Again" event: when there is a collision in the current frame, the same that happened in the previous frame collisionHandler.addAgainPattern('%fn-again-%in') #"Out" event: when there isn't a collision in the current frame, but there was in the previous frame collisionHandler.addOutPattern('%fn-out-%in') #self.collision3DPoint is the point where the collision occurs collision3DPoint = [0,0,0] #self.addCollider(mousePicking.pickerNP) #self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP) DO = DirectObject() def addCollisionEventAgain(fromName, intoName, function, extraArgs = []): #Let's manage now the collision events: DO.accept(fromName+"-again-"+intoName, function, extraArgs)
class World(DirectObject): def __init__(self): # Initialize the traverser. base.cTrav = CollisionTraverser() # Initialize the handler. self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern("into-%in") self.collHandEvent.addOutPattern("outof-%in") # Make a variable to store the unique collision string count. self.collCount = 0 # Load a model. Reparent it to the camera so we can move it. s = loader.loadModel("smiley") s.reparentTo(camera) s.setPos(0, 25, 0) # Setup a collision solid for this model. sColl = self.initCollisionSphere(s, True) # Add this object to the traverser. base.cTrav.addCollider(sColl[0], self.collHandEvent) # Accept the events sent by the collisions. self.accept("into-" + sColl[1], self.collide3) self.accept("outof-" + sColl[1], self.collide4) print(sColl[1]) # Load another model. t = loader.loadModel("smiley") t.reparentTo(render) t.setPos(5, 25, 0) # Setup a collision solid for this model. tColl = self.initCollisionSphere(t, True) # Add this object to the traverser. base.cTrav.addCollider(tColl[0], self.collHandEvent) # Accept the events sent by the collisions. self.accept("into-" + tColl[1], self.collide) self.accept("outof-" + tColl[1], self.collide2) print(tColl[1]) print("WERT") def collide(self, collEntry): print("WERT: object has collided into another object") Sequence( Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 0, 0, 1)), Wait(0.2), Func(collEntry.getFromNodePath().getParent().setColor, VBase4(0, 1, 0, 1)), Wait(0.2), Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 1, 1, 1)), ).start() def collide2(self, collEntry): print("WERT.: object is no longer colliding with another object") def collide3(self, collEntry): print("WERT2: object has collided into another object") def collide4(self, collEntry): print("WERT2: object is no longer colliding with another object") def initCollisionSphere(self, obj, show=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() * 1.1 # Create a collision sphere and name it something understandable. collSphereStr = "CollisionHull" + str(self.collCount) + "_" + obj.getName() self.collCount += 1 cNode = CollisionNode(collSphereStr) cNode.addSolid(CollisionSphere(center, radius)) cNodepath = obj.attachNewNode(cNode) if show: cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return (cNodepath, collSphereStr)
from pandaImports import DirectObject from tower import * '''This file handles all the collision events of our game ''' #base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame) base.cTrav = CollisionTraverser() #collisionHandler specifies what to do when a collision event is detected collisionHandler = CollisionHandlerEvent() #"In" event: when there is a collision in the current frame, but it didn't in the previous frame collisionHandler.addInPattern('%fn-into-%in') #"Again" event: when there is a collision in the current frame, the same that happened in the previous frame collisionHandler.addAgainPattern('%fn-again-%in') #"Out" event: when there isn't a collision in the current frame, but there was in the previous frame collisionHandler.addOutPattern('%fn-out-%in') #self.collision3DPoint is the point where the collision occurs collision3DPoint = [0, 0, 0] #self.addCollider(mousePicking.pickerNP) #self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP) DO = DirectObject() def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]): #Let's manage now the collision events: DO.accept(fromName + "-again-" + intoName, function, extraArgs)
squareGeom=Geom(vdata) squareGeom.addPrimitive(tris) #now put squareGeom in a GeomNode. You can now position your geometry in the scene graph. squareGN=GeomNode("square") squareGN.addGeom(squareGeom) terrainNode = NodePath("terrNode") terrainNode.reparentTo(render) terrainNode.attachNewNode(squareGN) terrainNode.setX(-width/2) texGrass = loader.loadTexture("textures/envir-ground.jpg") terrainNode.setTexture(texGrass) cHandler.addInPattern("%(rays)ft-into-%(building)it") cHandler.addOutPattern("%(rays)ft-out-%(building)it") cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""building"")ih") DO=DirectObject() DO.accept('ray1-into-buildPlayer1', collideInBuilding) DO.accept('ray1-out-buildPlayer1', collideOutBuilding) DO.accept('ray_again_all', collideAgainstBuilds) pickingEnabledOject=None DO.accept('mouse1', mouseClick, ["down"]) DO.accept('mouse1-up', mouseClick, ["up"])
class World(DirectObject): def __init__(self): # Initialize the traverser. base.cTrav = CollisionTraverser() # Initialize the handler. self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern('into-%in') self.collHandEvent.addOutPattern('outof-%in') # Make a variable to store the unique collision string count. self.collCount = 0 # Load a model. Reparent it to the camera so we can move it. s = loader.loadModel('smiley') s.reparentTo(camera) s.setPos(0, 25, 0) # Setup a collision solid for this model. sColl = self.initCollisionSphere(s, True) # Add this object to the traverser. base.cTrav.addCollider(sColl[0], self.collHandEvent) # Accept the events sent by the collisions. self.accept('into-' + sColl[1], self.collide3) self.accept('outof-' + sColl[1], self.collide4) print(sColl[1]) # Load another model. t = loader.loadModel('smiley') t.reparentTo(render) t.setPos(5, 25, 0) # Setup a collision solid for this model. tColl = self.initCollisionSphere(t, True) # Add this object to the traverser. base.cTrav.addCollider(tColl[0], self.collHandEvent) # Accept the events sent by the collisions. self.accept('into-' + tColl[1], self.collide) self.accept('outof-' + tColl[1], self.collide2) print(tColl[1]) print("WERT") def collide(self, collEntry): print("WERT: object has collided into another object") Sequence( Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 0, 0, 1)), Wait(0.2), Func(collEntry.getFromNodePath().getParent().setColor, VBase4(0, 1, 0, 1)), Wait(0.2), Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 1, 1, 1))).start() def collide2(self, collEntry): print("WERT.: object is no longer colliding with another object") def collide3(self, collEntry): print("WERT2: object has collided into another object") def collide4(self, collEntry): print("WERT2: object is no longer colliding with another object") def initCollisionSphere(self, obj, show=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() * 1.1 # Create a collision sphere and name it something understandable. collSphereStr = 'CollisionHull' + str( self.collCount) + "_" + obj.getName() self.collCount += 1 cNode = CollisionNode(collSphereStr) cNode.addSolid(CollisionSphere(center, radius)) cNodepath = obj.attachNewNode(cNode) if show: cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return (cNodepath, collSphereStr)
if status == 'up': pickingEnabledOject.setScale(1.0) #** This is a task function called each frame, where the collision ray position is syncronized with the mouse pointer position def rayupdate(task): if base.mouseWatcherNode.hasMouse(): mpos=base.mouseWatcherNode.getMouse() # this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont #** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'. # That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events... collisionHandler.addInPattern("%(rays)ft-into-%(balls)it") # ...and here for the OUT events collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it") #** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below. collisionHandler.addAgainPattern( "ray_again_all%(""rays"")fh%(""balls"")ih" ) """ Note that we could have been done the same using this form as well: collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it") but then we should have used 2 accepts like this: DO.accept('ray1-again-smileys', collideAgainBalls) DO.accept('ray1-again-frowney', collideAgainBalls) instead of just one as we did below, and this don't hurt very much in this snippet cos' we got just 2 groups, but could be complicated if we need to use a lot more groups.
class CollisionManager: def __init__(self): base.cTrav = CollisionTraverser() self.col_handler = CollisionHandlerEvent() self.selected = -1 self.selected_node = None self.selecteds = [] self.multi_select = False self.multi_selecting = False self.select_box = NodePath() picker_node = CollisionNode("mouseRayNode") pickerNPos = base.camera.attachNewNode(picker_node) self.pickerRay = CollisionRay() picker_node.addSolid(self.pickerRay) plane_node = CollisionNode("base_plane") plane = base.render.attachNewNode(plane_node) self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) picker_node.addSolid(self.pickerRay) picker_node.setTag("rays", "mray") base.cTrav.addCollider(pickerNPos, self.col_handler) self.col_handler.addInPattern("%(rays)ft-into-%(type)it") self.col_handler.addOutPattern("%(rays)ft-out-%(type)it") self.col_handler.addAgainPattern("ray_again_all%(" "rays" ")fh%(" "type" ")ih") self.DO = DirectObject() self.DO.accept('mray-into-army', self.col_in_object) self.DO.accept('mray-out-army', self.col_out_object) self.DO.accept('mray-into-battle', self.col_in_object) self.DO.accept('mray-out-battle', self.col_out_object) self.DO.accept('mray-into-tower', self.col_in_object) self.DO.accept('mray-out-tower', self.col_out_object) self.DO.accept('ray_again_all', self.col_against_object) if base.client == False: self.col_handler.addInPattern("%(player)ft-into-%(player)it") self.col_handler.addInPattern("%(type)ft-into-%(type)it") self.DO.accept('army-into-battle', self.col_army_against_battle) self.DO.accept('army-into-tower', self.col_army_against_tower) self.DO.accept('1-into-2', self.col_p1_into_p2) self.pickable = None self.DO.accept('mouse1', self.mouse_click, ["down"]) self.DO.accept('mouse1-up', self.mouse_click, ["up"]) self.DO.accept('mouse3-up', self.mouse_order) taskMgr.add(self.ray_update, "updatePicker") taskMgr.add(self.task_select_check, "updatePicker") taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane") z = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z)) self.model = loader.loadModel("models/chest.egg") self.model.reparentTo(render) self.model.hide() cm = CardMaker("blah") cm.setFrame(-100, 100, -100, 100) pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1) pnode.hide() def col_army_against_battle(self, entry): print "Army Joins!" #base.net_manager.battle_join(bat,army) army = entry.getFromNodePath() a_id = int(army.getParent().getTag("id")) a = base.armies[a_id] if a.state == "normal": battle = entry.getIntoNodePath() b_id = int(battle.getParent().getTag("id")) if base.single_player == False: base.net_manager.server_messager( "battle_armyadd", [b_id, a_id, a.node_path.getX(), a.node_path.getY()]) a = base.armies[a_id] b = base.battles[b_id] b.add_army(a) def col_p1_into_p2(self, entry): if entry.getFromNodePath().getTag( "state") == "normal" and entry.getIntoNodePath().getTag( "state") == "normal" and entry.getIntoNodePath().getTag( "type") == "army" and entry.getFromNodePath().getTag( "type") == "army": #base.net_manager.battle_start(a1,a2) army1 = entry.getFromNodePath() army2 = entry.getIntoNodePath() a1_id = int(army1.getParent().getTag("id")) a2_id = int(army2.getParent().getTag("id")) a1 = base.armies[a1_id] a2 = base.armies[a2_id] a1.stop() a2.stop() base.battles.append(TimObjects.Battle([a1, a2])) def col_army_against_tower(self, entry): print "TOWER COLLIDE", entry.getIntoNodePath().getParent().getTag("id") print entry.getIntoNodePath().getParent().getTag( "player"), "vs", entry.getFromNodePath().getParent().getTag( "player") if entry.getIntoNodePath().getParent().getTag( "player") != entry.getFromNodePath().getParent().getTag( "player"): tower = entry.getIntoNodePath() tower_id = int(tower.getParent().getTag("id")) invader = int(entry.getFromNodePath().getParent().getTag("player")) if base.client == False and base.towers[tower_id].capture_check(): base.towers[tower_id].change_owner(invader) if base.single_player == False: base.net_manager.server_messager("tower_capture", [tower_id, invader]) def col_in_object(self, entry): np_into = entry.getIntoNodePath() np_into.getParent().setColor(0.5, 0.5, 0.5, 0.1) #self.global_text.setText(np_into.getName()) if np_into.getTag("type") == "battle": print "You're in a battle" #print "in" def col_out_object(self, entry): np_into = entry.getIntoNodePath() #print "out" try: np_into.getParent().setColor(1, 1, 1, 1) except: print "ERROR CLEARING COLOUR" #self.global_text.setText("") self.pickable = None self.selected_type = "none" def col_against_object(self, entry): if entry.getIntoNodePath().getParent() != self.pickable: np_from = entry.getFromNodePath() np_into = entry.getIntoNodePath() self.selected_type = np_into.getTag("type") self.pickable = np_into.getParent() def mouse_click(self, status): print "click" in_statbar = base.vis_manager.statbar.mouse_in_bar() if self.pickable and in_statbar == False: if status == "down": if self.selected_type == "army": if base.armies[int(self.pickable.getTag( "id"))].state == "normal" or base.armies[int( self.pickable.getTag("id"))].state == "new": for obj in self.selecteds: obj.deselect() print obj.my_id, "deselected" self.selecteds = [] self.pickable.setScale(0.95 * 10) self.selected = int(self.pickable.getTag("id")) self.selected_node = self.pickable self.selecteds.append(base.armies[self.selected]) base.armies[self.selected].select() print "You clicked on Army" + str(self.selected) base.vis_manager.statbar.show_army(self.selected) elif self.selected_type == "tower": for obj in self.selecteds: obj.deselect() print obj.my_id, "deselected" self.selecteds = [] self.selected = int(self.pickable.getTag("id")) self.selected_node = self.pickable self.selecteds.append(base.towers[self.selected]) base.towers[self.selected].select() print "You clicked on a tower" base.vis_manager.statbar.show_tower(self.selected) elif self.selected_type == "battle": self.selected = int(self.pickable.getTag("id")) self.selected_node = self.pickable print "You clicked on a battle" base.vis_manager.statbar.show_battle(self.selected) if status == "up": if self.selected_type == "army": self.pickable.setScale(1.0 * 10) elif status == "up" and self.multi_select == True: self.multi_select = False self.select_all_in_box() elif in_statbar == True: print "in box" elif self.pickable == None: for obj in self.selecteds: obj.deselect() print obj.my_id, "deselected" self.selecteds = [] self.selected = -1 self.selected_node = None base.vis_manager.statbar.reset_statbar() def select_all_in_box(self): for obj in self.selecteds: obj.deselect() print obj.my_id, "deselected" self.selecteds = [] print "select units in box" for a in base.armies: if a.node_col.getTag("type") == "army" and ( a.state == "normal" or a.state == "new") and a.player == base.player: x = a.get_x() y = a.get_y() if self.box_x < self.model.getX( ) and self.box_y > self.model.getY(): if x < self.model.getX( ) and x > self.box_x and y > self.model.getY( ) and y < self.box_y: self.selecteds.append(a) a.select() elif self.box_x < self.model.getX( ) and self.box_y < self.model.getY(): if x < self.model.getX( ) and x > self.box_x and y < self.model.getY( ) and y > self.box_y: self.selecteds.append(a) a.select() elif self.box_x > self.model.getX( ) and self.box_y < self.model.getY(): if x > self.model.getX( ) and x < self.box_x and y < self.model.getY( ) and y > self.box_y: self.selecteds.append(a) a.select() elif self.box_x > self.model.getX( ) and self.box_y > self.model.getY(): if x > self.model.getX( ) and x < self.box_x and y > self.model.getY( ) and y < self.box_y: self.selecteds.append(a) a.select() def task_select_check(self, task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): #if self.multi_select == True: self.box_x, self.box_y = self.model.getX(), self.model.getY() taskMgr.add(self.draw_multiselect_box, "multibox") return task.done return task.cont def draw_multiselect_box(self, task): if base.mouseWatcherNode.isButtonDown(MouseButton.one()): self.multi_select = True self.select_box.remove() ls = LineSegs() ls.move_to(self.box_x, self.box_y, 1) ls.draw_to(self.model.getX(), self.box_y, 1) ls.draw_to(self.model.getX(), self.model.getY(), 1) ls.draw_to(self.box_x, self.model.getY(), 1) ls.draw_to(self.box_x, self.box_y, 1) node = ls.create() #text = TextNode('text') #text.setText(str(self.box_x)+","+str(self.box_y)+"\n"+str(self.model.getX())+","+str(self.model.getY())) #textnp = NodePath(text) #textnp.setPos(self.box_x,self.box_y,1) #textnp.setHpr(0,-90,0) #textnp.setScale(20.0) self.select_box = NodePath(node) #textnp.reparentTo(self.select_box) self.select_box.reparentTo(render) return task.cont else: self.select_box.hide() taskMgr.add(self.task_select_check, "updatePicker") return task.done def mouse_order(self): print "mouse_order" # if self.selected != -1 and base.armies[self.selected].state == "normal": # print "orders sent" for a in self.selecteds: if a.node_col.getTag("type") == "army": if len(self.selecteds) > 1: randomness = (len(self.selecteds) - 1) * 10 a.set_target( True, self.pos3d.getX() + random.randint(0, randomness) - randomness / 2, self.pos3d.getY() + random.randint(0, randomness) - randomness / 2) else: a.set_target(True, self.pos3d.getX(), self.pos3d.getY()) def get_mouse_plane_pos(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine( self.pos3d, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): #print "Mouse ray intersects ground plane at ", self.pos3d self.model.setPos(render, self.pos3d) return task.again def ray_update(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) return task.cont
avatarCollider.node().addSolid(CollisionSphere(0, 0, 0, 1)) avatarCollider.node().setFromCollideMask(WALL_MASK) avatarCollider.node().setIntoCollideMask(BitMask32.allOff()) #** the avatar's fallout sensor - stuff already seen in former snippets, but this time we'll use it for more that to detect the fallout impact force, so we'll add another mask to look out avatarSensor = avatarNP.attachNewNode(CollisionNode('yolkysensor')) cs = CollisionSphere(0, 0, 0, 1.2) avatarSensor.node().addSolid(cs) # here the masking: note that this sensor will look for floor bashing but also for other geometries masked with TRIGGER_MASK. avatarSensor.node().setFromCollideMask(FLOOR_MASK | TRIGGER_MASK) avatarSensor.node().setIntoCollideMask(BitMask32.allOff()) cs.setTangible(0) #** here's how to read the events fired by the 'sensor' while colliding with geometry we enable to collide with it. collisionEvent.addInPattern('%fn-into') collisionEvent.addOutPattern('%fn-out') #** the floor ray collider for the avatar avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay')) avatarRay.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1)) avatarRay.node().setFromCollideMask(FLOOR_MASK) avatarRay.node().setIntoCollideMask(BitMask32.allOff()) #** This is the scene map - we'll gather off here almost every element of the map: scenery, ground colliders, walls, and also triggers and spawn points. See the .blend source for details on the scene components. scene = loader.loadModel("windmill") scene.reparentTo(render) scene.setCollideMask(BitMask32.allOff()) scene.setScale(10) # Let's mask our main collision surfaces floorcollider = scene.find("**/floor0/floor_collide*") floorcollider.node().setIntoCollideMask(FLOOR_MASK)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) global carx, cary, d, cor_ans, count self.disableMouse() self.Truck = [0] * 6 self.crate = [0] * 10 self.posc = [0] * 30 self.radX = [0] * 60 self.radY = [0] * 60 self.radZ = [0] * 60 self.sX = [0] * 10 self.sY = [0] * 10 self.sZ = [0] * 10 self.flag = [0] * 10 self.ans = [0] * 10 self.inst1 = addInstructions(0.89, "Correct Answer: " + str(cor_ans)) self.inst2 = addInstructions(0.95, "Time: " + str(time)) self.inst3 = addInstructions(0.84, "Waste Reamaining " + str(count / 2)) #self.title = addTitle("Recycle Game By : Sandeep Sharma") p = 0 file = open("ans.txt") for line in file: #for p in range(30): #print line line = line.split() self.ans[p] = str(line[0]) p = p + 1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() p = 0 file = open("sample.txt") for line in file: #for p in range(30): line = line[0:len(line) - 1] #print line self.posc[p] = int(line) p = p + 1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() p = 0 file = open("scale.txt") for line in file: #for p in range(30): line = line.split() #print line self.sX[p] = float(line[0]) self.sY[p] = float(line[1]) self.sZ[p] = float(line[2]) #print self.radY[p] p = p + 1 p = 0 file = open("rad.txt") for line in file: #for p in range(30): line = line.split() #print line self.radX[p] = float(line[0]) self.radY[p] = float(line[1]) self.radZ[p] = float(line[2]) #print self.radY[p] p = p + 1 # self.posc[p]= int(line) #print self.posc[p] #break file.close() self.CornField = self.loader.loadModel("cornfield") self.CornField.reparentTo(self.render) self.CornField.setScale(1000, 1000, 0) self.CornField.setPos(0, 0, -8) self.WM = self.loader.loadModel("WM/Windmill") self.WM.reparentTo(self.render) self.WM.setScale(2, 2, 2) self.WM.setPos(354, 131, 0) self.WM.setHpr(180, 0, 0) self.F1 = self.loader.loadModel("Forest/Forest") self.F1.reparentTo(self.render) self.F1.setScale(0.8, 0.5, 0.5) self.F1.setPos(-338, -164, 0) self.F1.setHpr(90, 0, 0) self.F2 = self.loader.loadModel("Forest/Forest") self.F2.reparentTo(self.render) self.F2.setScale(0.8, 0.5, 0.5) self.F2.setPos(366, -189, 0) self.F2.setHpr(90, 0, 0) self.castle = self.loader.loadModel("castle") self.castle.reparentTo(self.render) self.castle.setScale(0.6, 0.8, 0.5) self.castle.setPos(-97, -200, 0) self.castle.setHpr(90, 0, 0) #print self.castle self.church = self.loader.loadModel("church/Church") self.church.reparentTo(self.render) self.church.setScale(2.5, 2.5, 1) self.church.setPos(90, -200, 0) self.church.setHpr(180, 0, 0) self.Temple = self.loader.loadModel("Temple/TempleFort") self.Temple.reparentTo(self.render) self.Temple.setScale(0.06, 0.1, 0.18) self.Temple.setPos(210, -109, 0) self.house = self.loader.loadModel("BuildingCluster3") self.house.reparentTo(self.render) self.house.setScale(1.5, 1.5, 1) self.house.setPos(208, 86, 0) self.CityHall = self.loader.loadModel("cityhall/CityHall") self.CityHall.reparentTo(self.render) self.CityHall.setScale(1.5, 1.5, 1.5) self.CityHall.setPos(-188, -84, 0) self.CityHall.setHpr(90, 0, 0) self.statue = self.loader.loadModel("statue/statue") self.statue.reparentTo(self.render) self.statue.setScale(4.5, 4.5, 3.5) self.statue.setPos(-191, 105, 0) self.statue.setHpr(-90, 0, 0) self.FarmHouse = self.loader.loadModel("farmhouse/FarmHouse") self.FarmHouse.reparentTo(self.render) self.FarmHouse.setScale(2.8, 3.5, 2.5) self.FarmHouse.setPos(-66, 209, 0) self.Fence1 = self.loader.loadModel("fence/fence") self.Fence1.reparentTo(self.render) self.Fence1.setScale(70, 1, 2) self.Fence1.setPos(0, -418, 0) self.Fence2 = self.loader.loadModel("fence/fence") self.Fence2.reparentTo(self.render) self.Fence2.setScale(70, 1, 2) self.Fence2.setPos(0, 418, 0) self.Fence3 = self.loader.loadModel("fence/fence") self.Fence3.reparentTo(self.render) self.Fence3.setScale(70, 1, 2) self.Fence3.setPos(-418, 0, 0) self.Fence3.setHpr(90, 0, 0) self.Fence4 = self.loader.loadModel("fence/fence") self.Fence4.reparentTo(self.render) self.Fence4.setScale(70, 1, 2) self.Fence4.setPos(418, 0, 0) self.Fence4.setHpr(90, 0, 0) self.CityTerrain = self.loader.loadModel("CityTerrain/CityTerrain") self.CityTerrain.reparentTo(self.render) self.CityTerrain.setScale(0.5, 0.5, 0.5) self.CityTerrain.setPos(0, 0, 0) self.BeachTerrain = self.loader.loadModel("BeachTerrain/BeachTerrain") self.BeachTerrain.reparentTo(self.render) self.BeachTerrain.setScale(0.5, 0.5, 0.5) self.BeachTerrain.setPos(200, 750, 0) self.BeachTerrain.setHpr(90, 0, 0) self.school = self.loader.loadModel("school/school") self.school.reparentTo(self.render) self.school.setScale(0.056, 0.07, 0.05) self.school.setPos(-162, -348, 0) self.school.setHpr(90, 0, 0) self.car = Actor("bvw-f2004--jeep/jeep", {"walk": "bvw-f2004--jeep/jeep-start"}) self.car.setScale(0.5, 0.5, 0.5) self.car.reparentTo(self.render) self.car.setPos(carx, cary, -2) self.car.setHpr(180, 0, 0) #print self.car for l in range(10): self.crate[l] = self.loader.loadModel("model" + str(l + 1) + "/crate" + str(l + 1) + ".egg") self.crate[l].setScale(self.sX[l], self.sY[l], self.sZ[l]) self.crate[l].reparentTo(self.render) self.crate[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 2) self.crate[l].setHpr(0, 0, 0) #self.car.loop("walk") #self.car.reparentTo(self.render) #self.car.setScale(2,2,2) #self.car.setPos(carx,cary,-2) #self.car.setHpr(0,0,0) self.museum = self.loader.loadModel("Museum/Museum") self.museum.reparentTo(self.render) self.museum.setScale(1, 2, 1.5) self.museum.setPos(100, 200, 0) self.museum.setHpr(180, 0, 0) self.PalmTree = self.loader.loadModel("PalmTree/palmtree") self.PalmTree.reparentTo(self.render) self.PalmTree.setScale(2, 2, 3.5) self.PalmTree.setPos(175, 200, 0) self.PalmTree.setHpr(0, 0, 0) self.stadium = self.loader.loadModel("Stadium/stadium") self.stadium.reparentTo(self.render) self.stadium.setScale(0.5, 0.5, 0.5) self.stadium.setPos(13, 0, 0) self.stadium.setHpr(0, 0, 0) self.Junkyard = self.loader.loadModel("Junkyard") self.Junkyard.reparentTo(self.render) self.Junkyard.setScale(0.2, 0.4, 0.3) self.Junkyard.setPos(150, -650 / 2 - 25, 0) self.Junkyard.setHpr(90, 0, 0) self.BB1 = self.loader.loadModel("BuildingCluster1") self.BB1.reparentTo(self.render) self.BB1.setScale(0.5, 0.5, 1) self.BB1.setPos(-100 - 10, 650 / 2 + 20, 0) self.BB1.setHpr(270, 0, 0) self.BB2 = self.loader.loadModel("BB2/BuildingCluster2") self.BB2.reparentTo(self.render) self.BB2.setScale(0.5, 0.5, 1) self.BB2.setPos(-60 - 10, 650 / 2 + 20, 0) self.BB2.setHpr(270, 0, 0) self.BB3 = self.loader.loadModel("BB3/BuildingCluster3") self.BB3.reparentTo(self.render) self.BB3.setScale(0.5, 0.5, 1) self.BB3.setPos(-140 - 10, 650 / 2 + 20, 0) self.BB3.setHpr(270, 0, 0) self.BB4 = self.loader.loadModel("BB4/BuildingCluster4") self.BB4.reparentTo(self.render) self.BB4.setScale(0.5, 0.5, 1) self.BB4.setPos(-25 - 10, 650 / 2 + 20, 0) self.BB4.setHpr(270, 0, 0) self.BB5 = self.loader.loadModel("BB5/BuildingCluster5") self.BB5.reparentTo(self.render) self.BB5.setScale(0.5, 0.5, 1) self.BB5.setPos(-190 - 10, 650 / 2 + 20, 0) self.BB5.setHpr(270, 0, 0) self.BS = self.loader.loadModel("BS/blue_sky_sphere") self.BS.reparentTo(self.render) self.BS.setScale(1, 1, 1) self.BS.setPos(-180, 0, 0) self.flagMain = self.loader.loadModel("Flag/flag") self.flagMain.setScale(0.3, 0.3, 0.3) self.flagMain.reparentTo(self.render) self.flagMain.setPos(carx - 20, cary, 10) print self.flagMain for i in range(6): self.Truck[i] = self.loader.loadModel( "bvw-f2004--fireengine/fireengine") self.Truck[i].reparentTo(self.render) self.Truck[i].setScale(2, 2, 2) ##self.Truck[i].setPos(180,0,0) #Create the four lerp intervals needed to walk back and forth self.setTruck() #self.City = self.loader.loadModel("City/course2") #self.City.reparentTo(self.render) #self.City.setScale(2.5,2.5,2.5) #self.City.setPos(500,0,0) self.accept('arrow_down', self.moved, [0]) self.accept('arrow_up', self.move, [0]) self.accept("arrow_left", self.change_dc, [0]) self.accept("arrow_right", self.change_da, [0]) self.accept('arrow_down-up', self.moved, [2]) self.accept('arrow_up-up', self.move, [2]) #self.accept("arrow_left-up",self.change_dc,[2]) #self.accept("arrow_right-up",self.change_da,[2]) self.accept('arrow_down-repeat', self.moved, [1]) self.accept('arrow_up-repeat', self.move, [1]) self.accept("arrow_left-repeat", self.change_dc, [1]) self.accept("arrow_right-repeat", self.change_da, [1]) base.cTrav = CollisionTraverser() self.collHandEvent = CollisionHandlerEvent() self.collHandEvent.addInPattern('into-%in') self.collHandEvent.addOutPattern('outof-%in') self.collCount = 0 sColl = self.initCollisionSphere(self.car, 1, 1, 1, True) base.cTrav.addCollider(sColl[0], self.collHandEvent) self.accept('into-' + sColl[1], self.collide) #self.accept('outof-' + sColl[1], self.collide4) i = 0 for child in render.getChildren(): if child != self.CornField and child != camera and child != self.CityTerrain and child != self.BeachTerrain and child != self.BS and child != self.Fence1 and child != self.Fence2 and child != self.Fence3 and child != self.Fence4: #print child tColl = self.initCollisionSphere(child, self.radX[i], self.radY[i], self.radZ[i], True) base.cTrav.addCollider(tColl[0], self.collHandEvent) #print i i = i + 1 # Accept the events sent by the collisions. self.accept('into-' + tColl[1], self.collide) for l in range(10): self.flag[l] = self.loader.loadModel("Flag/flag") self.flag[l].setScale(0.3, 0.3, 0.3) self.flag[l].reparentTo(self.render) self.flag[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 10) # self.accept( 'into-' + sColl[1], self.collide) #self.accept('outof-' + tColl[1], self.collide2) # print carx,cary # cs = CollisionSphere(0, 0, 0, 10) # fromObject = self.car.attachNewNode(CollisionNode('cnode')) # fromObject.node().addSolid(cs) # fromObject.show() # pusher = CollisionHandlerPusher() # pusher.addCollider(fromObject, self.car) # base.cTrav = CollisionTraverser() # base.cTrav.addCollider(fromObject, pusher) self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") def collide(self, collEntry): global carx, cary, car_def, a, Num, count #print "Collide" #print collEntry.getFromNodePath().getParent() #for objectc in collEntry: for l in range(10): #print collEntry.getFromNodePath().getParent() if collEntry.getIntoNodePath().getParent() == self.crate[l]: collEntry.getIntoNodePath().getParent().remove() #print "Baba" Num = l count = count - 1 self.flag[l].hide() self.Game_Point() if str(collEntry.getIntoNodePath().getParent() ) == "render/flag.egg" and count == 0 and str( collEntry.getFromNodePath().getParent( )) == "render/jeepNman_loop_baked": #print "here" self.GameOver() if str(collEntry.getIntoNodePath().getParent( )) == "render/jeepNman_loop_baked" or str(collEntry.getFromNodePath( ).getParent()) == "render/jeepNman_loop_baked": if a == 0: if self.car.getH() == 45: carx = carx + car_def cary = cary - car_def if self.car.getH() == 90: carx = carx + car_def if self.car.getH() == 135: carx = carx + car_def cary = cary + car_def if self.car.getH() == 180: cary = cary + car_def if self.car.getH() == 225: carx = carx - car_def cary = cary + car_def if self.car.getH() == 270: carx = carx - car_def if self.car.getH() == 315: carx = carx - car_def cary = cary - car_def if self.car.getH() == 0: cary = cary - car_def if a == 1: car_def = -1 * car_def if self.car.getH() == 45: carx = carx + car_def cary = cary - car_def if self.car.getH() == 90: carx = carx + car_def if self.car.getH() == 135: carx = carx + car_def cary = cary + car_def if self.car.getH() == 180: cary = cary + car_def if self.car.getH() == 225: carx = carx - car_def cary = cary + car_def if self.car.getH() == 270: carx = carx - car_def if self.car.getH() == 315: carx = carx - car_def cary = cary - car_def if self.car.getH() == 0: cary = cary - car_def car_def = -1 * car_def # def collide2(self,collEntry): # # def collide3(self,collEntry): # global carx , cary # carx=carx-2 # cary=cary-2 # def collide4(self,collEntry): # print 4 def initCollisionSphere(self, obj, setX, setY, setZ, show=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() * 0.6 # Create a collision sphere and name it something understandable. collSphereStr = 'CollisionHull' + str( self.collCount) + "_" + obj.getName() self.collCount += 1 self.accept('arrow_down', self.moved, [0]) self.accept('arrow_up', self.move, [0]) cNode = CollisionNode(collSphereStr) # cNode.setScale(3,3,3) cNode.addSolid(CollisionSphere(center, radius)) cNodepath = obj.attachNewNode(cNode) cNodepath.setScale(setX, setY, setZ) #cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return (cNodepath, collSphereStr) def moved(self, i): global carx, cary, camx, camy, dis, a #print "moved" a = 1 if i == 0: #print "Hello" self.car.loop("walk") if i == 2: self.car.stop("walk") #print "hello",self.car.getH() #print base.camera.getH() if carx > -410 and carx < 410 and cary > -410 and cary < 410: if self.car.getH() == 45: carx = carx - car_speed cary = cary + car_speed camx = carx - dis camy = cary + dis if self.car.getH() == 90: carx = carx - car_speed camx = carx - dis if self.car.getH() == 135: carx = carx - car_speed cary = cary - car_speed camx = carx - dis camy = cary - dis if self.car.getH() == 180: cary = cary - car_speed camy = cary - dis if self.car.getH() == 225: carx = carx + car_speed cary = cary - car_speed camx = carx + dis camy = cary - dis if self.car.getH() == 270: carx = carx + car_speed camx = carx + dis if self.car.getH() == 315: carx = carx + car_speed cary = cary + car_speed camx = carx + dis camy = cary + dis if self.car.getH() == 0: cary = cary + car_speed camy = cary + dis else: if carx <= -410: carx = carx - 1 if carx >= 410: carx = carx + 1 if cary <= -410: cary = cary - 1 if cary >= 410: cary = cary + 1 def move(self, i): global carx, cary, camx, camy, dis, a a = 0 # print "move" # print carx,cary if i == 0: self.car.loop("walk") if i == 2: self.car.stop("walk") #print "hello",self.car.getH() #print base.camera.getH() if carx > -410 and carx < 410 and cary > -410 and cary < 410: if self.car.getH() == 45: carx = carx + car_speed cary = cary - car_speed camx = carx + dis camy = cary - dis if self.car.getH() == 90: carx = carx + car_speed camx = carx + dis if self.car.getH() == 135: carx = carx + car_speed cary = cary + car_speed camx = carx + dis camy = cary + dis if self.car.getH() == 180: cary = cary + car_speed camy = cary + dis if self.car.getH() == 225: carx = carx - car_speed cary = cary + car_speed camx = carx - dis camy = cary + dis if self.car.getH() == 270: carx = carx - car_speed camx = carx - dis if self.car.getH() == 315: carx = carx - car_speed cary = cary - car_speed camx = carx - dis camy = cary - dis if self.car.getH() == 0: cary = cary - car_speed camy = cary - car_speed else: if carx <= -410: carx = carx + 1 if carx >= 410: carx = carx - 1 if cary <= -410: cary = cary + 1 if cary >= 410: cary = cary - 1 # self.car.loop("walk") def change_dc(self, i): global d #if i ==0: # print "Hello" # self.car.loop("walk") #if i==2: # self.car.stop("walk") d = d + 45 d = d % 360 def change_da(self, i): global d #if i ==0: # print "Hello" # self.car.loop("walk") #if i==2: # self.car.stop("walk") d = d - 45 d = d % 360 #for j in range(9): # d=d - 5 # # d=d % 360 # self.car.setHpr(d , 0 , 0) # time.sleep(0.1) #messenger.send('arrow_up-repeat') def spinCameraTask(self, task): global time, carx, cary, d, dis, camx, camy, count, cor_ans time = int(task.time) #r = d * (pi / 180.0) #print carx,cary if self.car.getH() == 45: camx = carx - dis camy = cary + dis if self.car.getH() == 90: camx = carx - 1.41 * dis camy = cary if self.car.getH() == 135: camx = carx - dis camy = cary - dis if self.car.getH() == 180: camy = cary - 1.41 * dis camx = carx if self.car.getH() == 225: camx = carx + dis camy = cary - dis if self.car.getH() == 270: camx = carx + 1.41 * dis camy = cary if self.car.getH() == 315: camx = carx + dis camy = cary + dis if self.car.getH() == 0: camy = cary + 1.41 * dis camx = carx if h == 0: self.inst1.destroy() self.inst2.destroy() self.inst3.destroy() self.inst1 = addInstructions(0.89, "Correct Answer: " + str(cor_ans)) self.inst2 = addInstructions(0.95, "Time: " + str(time)) self.inst3 = addInstructions(0.84, "Waste Reamaining " + str(count / 2)) self.car.setPos(carx, cary, 0) self.car.setHpr(d, 0, 0) base.camera.setPos(camx, camy, 5) base.camera.setHpr(d + 180, 0, 0) #base.camera.setPos(0,0,1700) #base.camera.setHpr(0, -90 , 0) return Task.cont # base.camera.setPos(0,-40,3) # return Task.cont def setTruck(self): pandaPosInterval01 = self.Truck[0].posInterval(11, Point3(18, 138, 0), startPos=Point3( 21, 390, 0)) pandaPosInterval02 = self.Truck[0].posInterval(5, Point3(140, 132, 0), startPos=Point3( 18, 138, 0)) pandaPosInterval03 = self.Truck[0].posInterval(10, Point3(140, -123, 0), startPos=Point3( 140, 132, 0)) pandaPosInterval04 = self.Truck[0].posInterval(5, Point3(-7, -126, 0), startPos=Point3( 140, -123, 0)) pandaPosInterval05 = self.Truck[0].posInterval(11, Point3(-10, -399, 0), startPos=Point3( -7, -126, 0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval00 = self.Truck[0].hprInterval(1, Point3(180, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval01 = self.Truck[0].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 180, 0, 0)) pandaHprInterval02 = self.Truck[0].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( -90, 0, 0)) pandaHprInterval03 = self.Truck[0].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 180, 0, 0)) pandaHprInterval04 = self.Truck[0].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 90, 0, 0)) #pandaHprInterval5= self.Truck[0].hprInterif collEntry.getIntoNodePath().getParent() == self.crate[l]:val(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace0 = Sequence(pandaHprInterval00, pandaPosInterval01, pandaHprInterval01, pandaPosInterval02, pandaHprInterval02, pandaPosInterval03, pandaHprInterval03, pandaPosInterval04, pandaHprInterval04, pandaPosInterval05, name="pandaPace0") pandaPace0.loop() pandaPosInterval11 = self.Truck[1].posInterval(11, Point3(-126, 14, 0), startPos=Point3( -411, 14, 0)) pandaPosInterval12 = self.Truck[1].posInterval(5, Point3(-117, 145, 0), startPos=Point3( -126, 14, 0)) pandaPosInterval13 = self.Truck[1].posInterval(10, Point3(148, 130, 0), startPos=Point3( -117, 145, 0)) pandaPosInterval14 = self.Truck[1].posInterval(5, Point3(145, -5, 0), startPos=Point3( 148, 130, 0)) pandaPosInterval15 = self.Truck[1].posInterval(11, Point3(394, -8, 0), startPos=Point3( 145, -5, 0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval10 = self.Truck[1].hprInterval(1, Point3(-90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval11 = self.Truck[1].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( -90, 0, 0)) pandaHprInterval12 = self.Truck[1].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval13 = self.Truck[1].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( -90, 0, 0)) pandaHprInterval14 = self.Truck[1].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 180, 0, 0)) #pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace1 = Sequence(pandaHprInterval10, pandaPosInterval11, pandaHprInterval11, pandaPosInterval12, pandaHprInterval12, pandaPosInterval13, pandaHprInterval13, pandaPosInterval14, pandaHprInterval14, pandaPosInterval15, name="pandaPace1") pandaPace1.loop() pandaPosInterval21 = self.Truck[2].posInterval(11, Point3(-9, -144, 0), startPos=Point3( -6, -358, 0)) pandaPosInterval22 = self.Truck[2].posInterval(5, Point3(-129, -137, 0), startPos=Point3( -9, -144, 0)) pandaPosInterval23 = self.Truck[2].posInterval(10, Point3(-129, 142, 0), startPos=Point3( -129, -137, 0)) pandaPosInterval24 = self.Truck[2].posInterval(5, Point3(5, 145, 0), startPos=Point3( -129, 142, 0)) pandaPosInterval25 = self.Truck[2].posInterval(11, Point3(20, 395, 0), startPos=Point3( 5, 145, 0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval20 = self.Truck[2].hprInterval(1, Point3(0, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval21 = self.Truck[2].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval22 = self.Truck[2].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( 90, 0, 0)) pandaHprInterval23 = self.Truck[2].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval24 = self.Truck[2].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( -90, 0, 0)) #pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace2 = Sequence(pandaHprInterval20, pandaPosInterval21, pandaHprInterval21, pandaPosInterval22, pandaHprInterval22, pandaPosInterval23, pandaHprInterval23, pandaPosInterval24, pandaHprInterval24, pandaPosInterval25, name="pandaPace2") pandaPace2.loop() pandaPosInterval31 = self.Truck[3].posInterval(11, Point3(150, -18, 0), startPos=Point3( 408, -18, 0)) pandaPosInterval32 = self.Truck[3].posInterval(5, Point3(147, -135, 0), startPos=Point3( 150, -18, 0)) pandaPosInterval33 = self.Truck[3].posInterval(10, Point3(-120, -138, 0), startPos=Point3( 147, -135, 0)) pandaPosInterval34 = self.Truck[3].posInterval(5, Point3(-123, -6, 0), startPos=Point3( -120, -138, 0)) pandaPosInterval35 = self.Truck[3].posInterval(11, Point3(-396, 10, 0), startPos=Point3( -123, -6, 0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) pandaHprInterval30 = self.Truck[3].hprInterval(1, Point3(90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval31 = self.Truck[3].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 90, 0, 0)) pandaHprInterval32 = self.Truck[3].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 180, 0, 0)) pandaHprInterval33 = self.Truck[3].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( 90, 0, 0)) pandaHprInterval34 = self.Truck[3].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 0, 0, 0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace4 = Sequence(pandaHprInterval30, pandaPosInterval31, pandaHprInterval31, pandaPosInterval32, pandaHprInterval32, pandaPosInterval33, pandaHprInterval33, pandaPosInterval34, pandaHprInterval34, pandaPosInterval35, name="pandaPace4") pandaPace4.loop() pandaPosInterval41 = self.Truck[4].posInterval(12, Point3(298, -282, 0), startPos=Point3( -276, -282, 0)) pandaPosInterval42 = self.Truck[4].posInterval(12, Point3(286, 280, 0), startPos=Point3( 298, -282, 0)) pandaPosInterval43 = self.Truck[4].posInterval(12, Point3(-268, 280, 0), startPos=Point3( 286, 280, 0)) pandaPosInterval44 = self.Truck[4].posInterval(12, Point3(-276, -282, 0), startPos=Point3( -268, 280, 0)) #pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval41 = self.Truck[4].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval42 = self.Truck[4].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( -90, 0, 0)) pandaHprInterval43 = self.Truck[4].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval44 = self.Truck[4].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 90, 0, 0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace5 = Sequence(pandaHprInterval41, pandaPosInterval41, pandaHprInterval42, pandaPosInterval42, pandaHprInterval43, pandaPosInterval43, pandaHprInterval44, pandaPosInterval44, name="pandaPace5") pandaPace5.loop() pandaPosInterval51 = self.Truck[5].posInterval(12, Point3(-268, 280, 0), startPos=Point3( 286, 280, 0)) pandaPosInterval52 = self.Truck[5].posInterval(12, Point3(-276, -282, 0), startPos=Point3( -268, 280, 0)) pandaPosInterval53 = self.Truck[5].posInterval(12, Point3(298, -282, 0), startPos=Point3( -276, -282, 0)) pandaPosInterval54 = self.Truck[5].posInterval(12, Point3(286, 280, 0), startPos=Point3( 298, -282, 0)) #pandaPosInterval55= self.Truck[5].posInterval(13,Point3(-396,10,0), startPos=Point3(-123,-6,0)) #pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0) #pandaHprInterval50= self.Truck[5].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0)) pandaHprInterval51 = self.Truck[5].hprInterval(3, Point3(90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval52 = self.Truck[5].hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 90, 0, 0)) pandaHprInterval53 = self.Truck[5].hprInterval(3, Point3(-90, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval54 = self.Truck[5].hprInterval(3, Point3(0, 0, 0), startHpr=Point3( -90, 0, 0)) #pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0)) #Create and play the sequence that coordinates the intervals pandaPace6 = Sequence(pandaHprInterval51, pandaPosInterval51, pandaHprInterval52, pandaPosInterval52, pandaHprInterval53, pandaPosInterval53, pandaHprInterval54, pandaPosInterval54, name="pandaPace6") pandaPace6.loop() def Game_Point(self): self.ignore("arrow_down") self.ignore("arrow_up") self.ignore("arrow_down-repeat") self.ignore("arrow_up-repeat") #self.text1 = addInstructions(0.5,"Is this Recyclable") self.text1 = TextNode('t1') self.text1.setText("is This Recyclable") self.text1.setTextColor(0, 0, 0, 1) self.textNodePath1 = aspect2d.attachNewNode(self.text1) self.textNodePath1.setScale(0.07) self.textNodePath1.setPos(-0.1, -0.1, 0.1) #text1.setTextColor(1,1,1) self.text1.setFrameColor(1, 0, 0, 1) self.text1.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.text2 = TextNode('t2') self.text2.setText("Y/N") self.text2.setTextColor(0, 0, 0, 1) self.textNodePath2 = aspect2d.attachNewNode(self.text2) self.textNodePath2.setScale(0.07) self.textNodePath2.setPos(0, 0, 0) #textNodePath2.setTextColor(1,1,1) self.text2.setFrameColor(1, 0, 0, 1) self.text2.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.accept('y', self.answer, [0]) self.accept('n', self.answer, [1]) def answer(self, n): global Num, cor_ans #print self.ans[Num] self.accept('arrow_down', self.moved, [0]) self.accept('arrow_up', self.move, [0]) self.accept('arrow_down-repeat', self.moved, [1]) self.accept('arrow_up-repeat', self.move, [1]) aspect2d.getChildren().detach() if n == 0: if self.ans[Num] == 'Y': cor_ans = cor_ans + 1 if n == 1: if self.ans[Num] == 'N': #print "Correct" cor_ans = cor_ans + 1 self.ignore('y') self.ignore('n') #print "Hello" def GameOver(self): global cor_ans, time, h h = 1 #print time for x in self.render.getChildren(): x.detachNode() self.inst1.destroy() self.inst2.destroy() self.inst3.destroy() self.text3 = TextNode('t1') self.text3.setText("Game Over ") self.text3.setTextColor(1, 0, 0, 1) self.textNodePath3 = aspect2d.attachNewNode(self.text3) self.textNodePath3.setScale(0.1) self.textNodePath3.setPos(-0.1, -0.1, 0.2) #text1.setTextColor(1,1,1) #self.text3.setFrameColor(1, 0, 0, 1) #self.text3.setFrameAsMargin(0.2, 0.2, 0.1, 0.1) self.text5 = TextNode('t1') self.text5.setText("Time Taken: " + str(time)) self.text5.setTextColor(1, 0, 0, 1) self.textNodePath5 = aspect2d.attachNewNode(self.text5) self.textNodePath5.setScale(0.1) self.textNodePath5.setPos(-0.1, -0.1, 0) self.text6 = TextNode('t1') self.text6.setText("correct answer: " + str(cor_ans)) self.text6.setTextColor(1, 0, 0, 1) self.textNodePath6 = aspect2d.attachNewNode(self.text6) self.textNodePath6.setScale(0.1) self.textNodePath6.setPos(-0.1, -0.1, -0.2) self.text4 = TextNode('t2') self.text4.setText("Score: " + str(5000 / time + (cor_ans * 10))) self.text4.setTextColor(1, 0, 0, 1) self.textNodePath4 = aspect2d.attachNewNode(self.text4) self.textNodePath4.setScale(0.1) self.textNodePath4.setPos(-0.1, -0.1, -0.4)