class RepairMousePicker: def __init__(self): self.pickerNode = CollisionNode('RepairMousePicker.pickerNode') self.pickerNP = base.cam2d.attachNewNode(self.pickerNode) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.collisionTraverser = CollisionTraverser() self.collisionHandler = CollisionHandlerQueue() self.collisionTraverser.addCollider(self.pickerNP, self.collisionHandler) self.clearCollisionMask() self.orthographic = True def destroy(self): del self.pickerNode self.pickerNP.removeNode() del self.pickerNP del self.pickerRay del self.collisionTraverser del self.collisionHandler def setOrthographic(self, ortho): self.orthographic = ortho def setCollisionMask(self, mask): self.pickerNode.setFromCollideMask(mask) def clearCollisionMask(self): self.pickerNode.setFromCollideMask(BitMask32.allOff()) def getCollisions(self, traverseRoot, useIntoNodePaths = False): if not base.mouseWatcherNode.hasMouse(): return [] mpos = base.mouseWatcherNode.getMouse() if self.orthographic: self.pickerRay.setFromLens(base.cam2d.node(), 0, 0) self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY()) else: self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(), mpos.getY()) self.pickerNP.setPos(0.0, 0.0, 0.0) self.collisionTraverser.traverse(traverseRoot) pickedObjects = [] if useIntoNodePaths: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i).getIntoNodePath()) else: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i)) return pickedObjects
class RepairMousePicker: def __init__(self): self.pickerNode = CollisionNode('RepairMousePicker.pickerNode') self.pickerNP = base.cam2d.attachNewNode(self.pickerNode) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.collisionTraverser = CollisionTraverser() self.collisionHandler = CollisionHandlerQueue() self.collisionTraverser.addCollider(self.pickerNP, self.collisionHandler) self.clearCollisionMask() self.orthographic = True def destroy(self): del self.pickerNode self.pickerNP.removeNode() del self.pickerNP del self.pickerRay del self.collisionTraverser del self.collisionHandler def setOrthographic(self, ortho): self.orthographic = ortho def setCollisionMask(self, mask): self.pickerNode.setFromCollideMask(mask) def clearCollisionMask(self): self.pickerNode.setFromCollideMask(BitMask32.allOff()) def getCollisions(self, traverseRoot, useIntoNodePaths=False): if not base.mouseWatcherNode.hasMouse(): return [] mpos = base.mouseWatcherNode.getMouse() if self.orthographic: self.pickerRay.setFromLens(base.cam2d.node(), 0, 0) self.pickerNP.setPos(mpos.getX(), 0.0, mpos.getY()) else: self.pickerRay.setFromLens(base.cam2d.node(), mpos.getX(), mpos.getY()) self.pickerNP.setPos(0.0, 0.0, 0.0) self.collisionTraverser.traverse(traverseRoot) pickedObjects = [] if useIntoNodePaths: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append( self.collisionHandler.getEntry(i).getIntoNodePath()) else: for i in range(self.collisionHandler.getNumEntries()): pickedObjects.append(self.collisionHandler.getEntry(i)) return pickedObjects
def leftClick(self): self.mouse1Down = True #Collision traversal pickerNode = CollisionNode('mouseRay') pickerNP = base.camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) myTraverser = CollisionTraverser() myHandler = CollisionHandlerQueue() myTraverser.addCollider(pickerNP, myHandler) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if myHandler.getNumEntries() > 0: # This is so we get the closest object myHandler.sortEntries() pickedObj = myHandler.getEntry(0).getIntoNodePath() objTag = pickedObj.findNetTag('mouseCollisionTag').getTag('mouseCollisionTag') if objTag and len(objTag)>0: messenger.send('object_click',[objTag]) pickerNP.remove()
def leftClick(self): self.mouse1Down = True #Collision traversal pickerNode = CollisionNode('mouseRay') pickerNP = base.camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) myTraverser = CollisionTraverser() myHandler = CollisionHandlerQueue() myTraverser.addCollider(pickerNP, myHandler) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if myHandler.getNumEntries() > 0: # This is so we get the closest object myHandler.sortEntries() pickedObj = myHandler.getEntry(0).getIntoNodePath() objTag = pickedObj.findNetTag('mouseCollisionTag').getTag( 'mouseCollisionTag') if objTag and len(objTag) > 0: messenger.send('object_click', [objTag]) pickerNP.remove()
class Selector(object): '''A Selector listens for mouse clicks and then runs select. Select then broadcasts the selected tag (if there is one)''' def __init__(self): ''' Should the traverser be shared? ''' LOG.debug("[Selector] Initializing") # The collision traverser does the checking of solids for collisions self.cTrav = CollisionTraverser() # The collision handler queue is a simple handler that records all # detected collisions during traversal self.cHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerNP, self.cHandler) # Start listening to clicks self.resume() def select(self, event): LOG.debug("[Selector] Selecting ") if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.cTrav.traverse(render) # TODO - change this to a lower node if self.cHandler.getNumEntries() > 0: #LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries()) self.cHandler.sortEntries() selectionNP = self.cHandler.getEntry(0).getIntoNodePath() selection = selectionNP.findNetTag('SelectorTag').getTag( 'SelectorTag') if selection is not '': LOG.debug("[Selector] Collision with %s" % selection) Event.Dispatcher().broadcast( Event.Event('E_EntitySelect', src=self, data=selection)) else: LOG.debug("[Selector] No collision") #Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection)) def pause(self): Event.Dispatcher().unregister(self, 'E_Mouse_1') def resume(self): print("unpausing selector") Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
class Selector(object): '''A Selector listens for mouse clicks and then runs select. Select then broadcasts the selected tag (if there is one)''' def __init__(self): ''' Should the traverser be shared? ''' LOG.debug("[Selector] Initializing") # The collision traverser does the checking of solids for collisions self.cTrav = CollisionTraverser() # The collision handler queue is a simple handler that records all # detected collisions during traversal self.cHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerNP, self.cHandler) # Start listening to clicks self.resume() def select(self, event): LOG.debug("[Selector] Selecting ") if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.cTrav.traverse(render) # TODO - change this to a lower node if self.cHandler.getNumEntries() > 0: #LOG.debug("[Selector] Entries=%d"%self.cHandler.getNumEntries()) self.cHandler.sortEntries() selectionNP = self.cHandler.getEntry(0).getIntoNodePath() selection = selectionNP.findNetTag('SelectorTag').getTag('SelectorTag') if selection is not '': LOG.debug("[Selector] Collision with %s" % selection) Event.Dispatcher().broadcast(Event.Event('E_EntitySelect', src=self, data=selection)) else: LOG.debug("[Selector] No collision") #Event.Dispatcher().broadcast(Event.Event('E_EntityUnSelect', src=self, data=selection)) def pause(self): Event.Dispatcher().unregister(self, 'E_Mouse_1') def resume(self): print("unpausing selector") Event.Dispatcher().register(self, 'E_Mouse_1', self.select)
def _DistributedBanquetTable__endFireWater(self): if self.aimStart == None: return None if not self.state == "Controlled": return None if not self.avId == localAvatar.doId: return None taskMgr.remove(self.waterPowerTaskName) messenger.send("wakeup") self.aimStart = None origin = self.nozzle.getPos(render) target = self.boss.getPos(render) angle = deg2Rad(self.waterPitcherNode.getH() + 90) x = math.cos(angle) y = math.sin(angle) fireVector = Point3(x, y, 0) if self.power < 0.001: self.power = 0.001 self.lastPowerFired = self.power fireVector *= self.fireLength * self.power target = origin + fireVector segment = CollisionSegment(origin[0], origin[1], origin[2], target[0], target[1], target[2]) fromObject = render.attachNewNode(CollisionNode("pitcherColNode")) fromObject.node().addSolid(segment) fromObject.node().setFromCollideMask( ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask ) fromObject.node().setIntoCollideMask(BitMask32.allOff()) queue = CollisionHandlerQueue() base.cTrav.addCollider(fromObject, queue) base.cTrav.traverse(render) queue.sortEntries() self.hitObject = None if queue.getNumEntries(): entry = queue.getEntry(0) target = entry.getSurfacePoint(render) self.hitObject = entry.getIntoNodePath() base.cTrav.removeCollider(fromObject) fromObject.removeNode() self.d_firingWater(origin, target) self.fireWater(origin, target) self.resetPowerBar()
class Picker(object): ''' classdocs ''' def __init__(self, camera, mouseWatcherNode, camNode, things): ''' Constructor ''' self.mouseWatcherNode = mouseWatcherNode self.camNode = camNode self.things = things self.pickerRay = CollisionRay() self.pickerNode = CollisionNode('mouseRay') self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerNode.addSolid(self.pickerRay) self.pickerNP = camera.attachNewNode(self.pickerNode) self.pq = CollisionHandlerQueue() self.picker = CollisionTraverser() self.picker.addCollider(self.pickerNP, self.pq) def getMouseOn(self, mouse_x, mouse_y): #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(self.camNode, mouse_x, mouse_y) self.picker.traverse(self.things.node) if self.pq.getNumEntries() > 0: #if we have hit something, sort the hits so that the closest #is first, and highlight that node self.pq.sortEntries() selectedNode = self.pq.getEntry(0).getIntoNode() selectedNodeId = selectedNode.getTag('nodeId') thingId = selectedNode.getTag('ID') mouseOnInfo = MouseOnInfo(self.things.getById(thingId), thingId, selectedNode, selectedNodeId, mouse_x, mouse_y) return mouseOnInfo
def __endFireWater(self): if self.aimStart == None: return if not self.state == 'Controlled': return if not self.avId == localAvatar.doId: return taskMgr.remove(self.waterPowerTaskName) messenger.send('wakeup') self.aimStart = None origin = self.nozzle.getPos(render) target = self.boss.getPos(render) angle = deg2Rad(self.waterPitcherNode.getH() + 90) x = math.cos(angle) y = math.sin(angle) fireVector = Point3(x, y, 0) if self.power < 0.001: self.power = 0.001 self.lastPowerFired = self.power fireVector *= self.fireLength * self.power target = origin + fireVector segment = CollisionSegment(origin[0], origin[1], origin[2], target[0], target[1], target[2]) fromObject = render.attachNewNode(CollisionNode('pitcherColNode')) fromObject.node().addSolid(segment) fromObject.node().setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask) fromObject.node().setIntoCollideMask(BitMask32.allOff()) queue = CollisionHandlerQueue() base.cTrav.addCollider(fromObject, queue) base.cTrav.traverse(render) queue.sortEntries() self.hitObject = None if queue.getNumEntries(): entry = queue.getEntry(0) target = entry.getSurfacePoint(render) self.hitObject = entry.getIntoNodePath() base.cTrav.removeCollider(fromObject) fromObject.removeNode() self.d_firingWater(origin, target) self.fireWater(origin, target) self.resetPowerBar() return
class heightChecker(): def __init__(self): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('heightChecker') self.pickerNode = render.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay(0,0,300,0,0,-1) pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNode, self.pickerQ) def getHeight(self,obj,pos): res=0 self.pickerNode.setPos(pos) self.picker.traverse(obj) if self.pickerQ.getNumEntries() > 0: self.pickerQ.sortEntries() res=self.pickerQ.getEntry(0).getSurfacePoint(render).getZ() return res
class mouseControl(DirectObject): def __init__(self): self.picker = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() pickerCollN = CollisionNode('mouseRay') pickerCamN = base.camera.attachNewNode(pickerCollN) pickerCollN.setFromCollideMask(BitMask32.bit(1)) pickerCollN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() pickerCollN.addSolid(self.pickerRay) self.picker.addCollider(pickerCamN, self.pickerQ) self.accept('mouse1',self.pick) def pick(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.picker.traverse(render) for i in xrange(self.pickerQ.getNumEntries()): entry=self.pickerQ.getEntry(i) player.control('replace_wp', ('goto', Vec3(entry.getSurfacePoint(render))))
class Gui3D: def __init__(self, game_data, gfx_manager): self.game_data = game_data self.gui_traverser = CollisionTraverser() self.handler = CollisionHandlerQueue() self.selectable_objects = {} for cid, model in gfx_manager.character_models.items(): new_collision_node = CollisionNode('person_' + str(cid)) new_collision_node.addSolid( CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5)) new_collision_nodepath = model.attachNewNode(new_collision_node) new_collision_nodepath.setTag("type", "character") new_collision_nodepath.setTag("id", str(cid)) picker_node = CollisionNode('mouseRay') picker_np = camera.attachNewNode(picker_node) self.picker_ray = CollisionRay() picker_node.addSolid(self.picker_ray) self.gui_traverser.addCollider(picker_np, self.handler) self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) self.floor_np = render.attachNewNode(CollisionNode('floor')) self.floor_np.setTag("type", "ground") self.floor_np.node().addSolid(self.floor) def mouse_click(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.gui_traverser.traverse(render) num_entries = self.handler.getNumEntries() if num_entries > 0: self.handler.sortEntries() entry = self.handler.getEntry(0) selected = entry.getIntoNodePath() selected_type = selected.getTag("type") if selected_type == "character": self.game_data.select_character(int(selected.getTag("id"))) elif selected_type == "ground": self.game_data.click_point(entry.getSurfacePoint(render))
class Gui3D: def __init__(self, game_data, gfx_manager): self.game_data = game_data self.gui_traverser = CollisionTraverser() self.handler = CollisionHandlerQueue() self.selectable_objects = {} for cid, model in gfx_manager.character_models.items(): new_collision_node = CollisionNode('person_' + str(cid)) new_collision_node.addSolid(CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5)) new_collision_nodepath = model.attachNewNode(new_collision_node) new_collision_nodepath.setTag("type","character") new_collision_nodepath.setTag("id",str(cid)) picker_node = CollisionNode('mouseRay') picker_np = camera.attachNewNode(picker_node) self.picker_ray = CollisionRay() picker_node.addSolid(self.picker_ray) self.gui_traverser.addCollider(picker_np, self.handler) self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) self.floor_np = render.attachNewNode(CollisionNode('floor')) self.floor_np.setTag("type", "ground") self.floor_np.node().addSolid(self.floor) def mouse_click(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.picker_ray.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.gui_traverser.traverse(render) num_entries = self.handler.getNumEntries() if num_entries > 0: self.handler.sortEntries() entry = self.handler.getEntry(0) selected = entry.getIntoNodePath() selected_type = selected.getTag("type") if selected_type == "character": self.game_data.select_character(int(selected.getTag("id"))) elif selected_type == "ground": self.game_data.click_point(entry.getSurfacePoint(render))
class Mouse(DirectObject): def __init__(self, app): # local variables for mouse class self.app = app self.init_collide() self.has_mouse = None self.prev_pos = None self.pos = None self.drag_start = None self.hovered_object = None self.button2 = False self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask') self.task = None # set up event and response to this event self.accept('mouse1', self.mouse1) self.accept('mouse1-up', self.mouse1_up) # change the mouse to accept 'right-click' to rotate camera self.accept('mouse3', self.rotateCamera) self.accept('mouse3-up', self.stopCamera) self.accept('wheel_up', self.zoomIn) self.accept('wheel_down', self.zoomOut) # set up the collision for object def init_collide(self): # why the heck he import within method from pandac.PandaModules import CollisionTraverser, CollisionNode from pandac.PandaModules import CollisionHandlerQueue, CollisionRay # init and import collision for object self.cTrav = CollisionTraverser('MousePointer') self.cQueue = CollisionHandlerQueue() self.cNode = CollisionNode('MousePointer') self.cNodePath = base.camera.attachNewNode(self.cNode) self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.cRay = CollisionRay() self.cNode.addSolid(self.cRay) self.cTrav.addCollider(self.cNodePath, self.cQueue) # by the collision methods mouse is able to find out which tile mouse is at def find_object(self): if self.app.world.nodePath: self.cRay.setFromLens(base.camNode, self.pos.getX(), self.pos.getY()) self.cTrav.traverse(self.app.world.terrain.nodePath) if self.cQueue.getNumEntries() > 0: self.cQueue.sortEntries() return self.cQueue.getEntry(0).getIntoNodePath() return None # setting task for mouse def mouse_task(self, task): action = task.cont # if the current tile has a mouse point to this self.has_mouse = base.mouseWatcherNode.hasMouse() if self.has_mouse: self.pos = base.mouseWatcherNode.getMouse() if self.prev_pos: self.delta = self.pos - self.prev_pos else: self.delta = None if self.task: action = self.task(task) else: self.pos = None if self.pos: self.prev_pos = Point2(self.pos.getX(), self.pos.getY()) return action # when mouse hover over this hexagon def hover(self, task): if self.hovered_object: self.hovered_object.unhover() self.hovered_object = None if self.button2: self.camera_drag() hovered_nodePath = self.find_object() if hovered_nodePath: tile = hovered_nodePath.findNetTag('tile') if not tile.isEmpty(): tag = tile.getTag('tile') coords = tag.split(',') (x, y) = [int(n) for n in coords] # set the hovered target to be the corresponding hexagon on terrain self.hovered_object = self.app.world.terrain.rows[x][y] self.hovered_object.hover() character = hovered_nodePath.findNetTag('char') if not character.isEmpty(): tag = character.getTag('char') (team_index, char_id) = [int(n) for n in tag.split(',')] self.hovered_object = self.app.world.teams[ team_index].characters_dict[char_id] self.hovered_object.hover() ghost = hovered_nodePath.findNetTag('ghost') if not ghost.isEmpty(): tag = ghost.getTag('ghost') (team_index, char_id) = [int(n) for n in tag.split(',')] for ghostInstance in self.app.ghosts: if (ghostInstance.team.index == team_index) and (ghostInstance.id == char_id): self.hovered_object = ghostInstance self.hovered_object.hover() return task.cont def mouse1(self): self.app.state.request('mouse1') def mouse1_up(self): self.app.state.request('mouse1-up') def camera_drag(self): if self.delta: old_heading = base.camera.getH() new_heading = old_heading - self.delta.getX() * 180 base.camera.setH(new_heading % 360) old_pitch = base.camera.getP() new_pitch = old_pitch + self.delta.getY() * 90 new_pitch = max(-90, min(-10, new_pitch)) base.camera.setP(new_pitch) def rotateCamera(self): self.button2 = True def stopCamera(self): self.button2 = False def zoomIn(self): lens = base.cam.node().getLens() size = lens.getFilmSize() if size.length() >= 75: lens.setFilmSize(size / 1.2) def zoomOut(self): lens = base.cam.node().getLens() size = lens.getFilmSize() if size.length() <= 250: lens.setFilmSize(size * 1.2)
class Swifter: def __init__(self, model, run, walk, idle, jump, crouch, crouchWalk, startPos, scale): #(self, model, run, walk, startPos, scale): """Initialise the character. Arguments: model -- The path to the character's model file (string) run : The path to the model's run animation (string) walk : The path to the model's walk animation (string) startPos : Where in the world the character will begin (pos) scale : The amount by which the size of the model will be scaled (float) """ #Define movement map and speeds self.speedSprint = 20 self.speedWalk = 7 self.speedCrouch = 5 self.speed = self.speedWalk #Capture control status self.isMoving = False self.isJumping = False self.isIdle = False self.isCrouching = False self.movementMap = {"forward":Vec3(0,-self.speed,0), "back":Vec3(0,self.speed,0), \ "left":Vec3(self.speed,0,0), "right":Vec3(-self.speed,0,0), \ "crouch":0, "sprint":0, "jump":1, "punch":0, "kick":0, "stop":Vec3(0), "changeView":0} #Set up key state variables self.strafe_left = self.movementMap["stop"] self.strafe_right = self.movementMap["stop"] self.forward = self.movementMap["stop"] self.back = self.movementMap["stop"] self.jump = False self.sprint = False self.crouch = False #Stop player by default self.walk = self.movementMap["stop"] self.strafe = self.movementMap["stop"] #Define the actor and his animations self.actor = Actor(model, {"run":run, "walk":walk, "idle":idle, "jump":jump, "crouch":crouch, "crouchWalk":crouchWalk}) #self.actor.enableBlend() self.actor.setBlend(frameBlend = True)#Enable interpolation self.actor.reparentTo(render) self.actor.setScale(scale) self.actor.setPos(startPos) #Set up FSM controller self.FSM = ActorFSM(self.actor) taskMgr.add(self.move,"moveTask") # Note: deriving classes DO NOT need # to add their own move tasks to the # task manager. If they override # self.move, then their own self.move # function will get called by the # task manager (they must then # explicitly call Character.move in # that function if they want it). self.prevtime = 0 # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('actorRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = self.actor.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # Uncomment this line to see the collision rays self.groundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring self.cTrav.showCollisions(render) """ def jumpUpdate(self,task): # this task simulates gravity and makes the player jump # get the highest Z from the down casting ray highestZ = -100 for i in range(self.nodeGroundHandler.getNumEntries()): entry = self.nodeGroundHandler.getEntry(i) z = entry.getSurfacePoint(self.render).getZ() if z > highestZ and entry.getIntoNode().getName() == "Cube": highestZ = z # gravity effects and jumps self.node.setZ(self.node.getZ()+self.jump*globalClock.getDt()) self.jump -= 1*self.globalClock.getDt() if highestZ > self.node.getZ()-.3: self.jump = 0 self.node.setZ(highestZ+.3) if self.readyToJump: self.jump = 1 return task.cont """ def move(self, task): """Move and animate the character for one frame. This is a task function that is called every frame by Panda3D. The character is moved according to which of it's movement controls are set, and the function keeps the character's feet on the ground and stops the character from moving if a collision is detected. This function also handles playing the characters movement animations. Arguments: task -- A direct.task.Task object passed to this function by Panda3D. Return: Task.cont -- To tell Panda3D to call this task function again next frame. """ elapsed = task.time - self.prevtime # save the character's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.actor.getPos() #Calculate stateful movement self.walk = self.forward + self.back self.strafe = self.strafe_left + self.strafe_right # move the character if any of the move controls are activated. self.actor.setPos(self.actor,self.walk*globalClock.getDt()*self.speed) self.actor.setPos(self.actor,self.strafe*globalClock.getDt()*self.speed) #If strafing rotate the model -90 / 90 degrees to go in the direction specified #if going backwards rotate model 180 degrees # If the character is moving, loop the run animation. # If he is standing still, stop the animation. ##CALLL CONTROLLER CLASS AND CALL FSM's INSTEAD OF DOING IT HERE #Decide what type of movement anim to use if(self.sprint is True): #If we are sprinting.. self.walkAnim = 'Run' self.speed = self.speedSprint elif(self.crouch is True): # Can't sprint while crouching ;) #If we are crouching.. print ("Crouching!") self.walkAnim = "CrouchWalk" self.idleAnim = "Crouch" self.speed = self.speedCrouch else: #Otherwise were walking.. self.walkAnim = 'Walk' self.idleAnim = 'Idle' self.speed = self.speedWalk #Idling if(self.isJumping is False and self.isMoving is False and self.isIdle is True and self.FSM.state != self.idleAnim): #If were not moving and not jumping and were supposed to be idle, play the idle anim if we aren't already self.FSM.request(self.idleAnim,1) #We are idle, feel free to do something else, setting isIdle = False. print ("We are Idle but ready to do something: isIdle = False") elif(self.isJumping is False and self.isMoving is False and self.isIdle is False): #If were not moving or jumping, were not doing anything, we should probably be idle if we aren't already self.isIdle = True #locomotion #TODO: Separate out into animations for forward, back and side stepping if( (self.walk != self.movementMap["stop"] or self.strafe != self.movementMap["stop"]) and self.isJumping is False): #Check if actor is walking forward/back if(self.walk != self.movementMap["stop"]): if(self.isMoving is False or self.FSM.state != self.walkAnim): self.isMoving = True # were now moving self.isIdle = False # were not idle right now self.FSM.request(self.walkAnim,1) print ("Started running or walking") #Check if actor is strafing if(self.strafe != self.movementMap["stop"]): if(self.isMoving is False or self.FSM.state != self.walkAnim): #MAKE THE NODE ROTATE SO THE LEGS POINT THE DIRECTION MOVING #myLegRotate = actor.controlJoint(None,"modelRoot",) #http://www.panda3d.org/manual/index.php/Controlling_a_Joint_Procedurally self.isMoving = True # were now moving self.isIdle = False # were not idle right now self.FSM.request(self.walkAnim,1) print ("Started running or walking") elif(self.isMoving is True and self.isIdle is False): #Only switch of isMoving if we were moving and not idle self.isMoving = False print ("Finished walking") #if were moving, set isMoving = 1 and call walking FSM ''' Jumping Check if the user is jumping, if they currently aren't jumping: make them not idle and mark them as jumping and request the Jump FSM. If the jump anim isn't playing but we were jumping, mark actor as not jumping. ''' if(self.jump is True): #if user pressed jump and were not already jumping, jump if(self.isJumping is False and self.FSM.state != 'Jump'): self.isJumping = True # were jumping self.isIdle = False # were not idle right now self.FSM.request('Jump',1) print ("Started jumping") #if we are jumping, check the anim has finished and stop jumping self.JumpQuery = self.actor.getAnimControl('jump') if(self.isJumping is True and self.JumpQuery.isPlaying() is False): self.isJumping = False # finished jumping print ("Finished Jumping") # Now check for collisions. self.cTrav.traverse(render) # Adjust the character's Z coordinate. If the character's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.groundHandler.getNumEntries()): entry = self.groundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): self.actor.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.actor.setPos(startpos) # Store the task time and continue. self.prevtime = task.time return Task.cont def setMove(self, key, moveType): """ Used by keyboard setup This gets the input from keyBoardSetup and will capture inputs """ if (moveType == "strafe_left"): self.strafe_left = self.movementMap[key] if (moveType == "strafe_right"): self.strafe_right = self.movementMap[key] if (moveType == "forward"): self.forward = self.movementMap[key] if (moveType == "back"): self.back = self.movementMap[key] if (moveType == "sprint"): self.sprint = key if (moveType == "jump"): self.jump = key if (moveType == "crouch"): self.crouch = key
class World(DirectObject): #class World, extends DirectObject, builds the world to play the game ###################### INITIALIZATIONS ######################################### def __init__(self): mySplashScreen = SplashScreen() mySplashScreen.loading() mySplashScreen.introduction() self.promptMode() self.turnWallNotification() ##### Creating Scene ##### self.createBackground() self.loadWallModel() self.loadBallModel() self.setCamera() self.createLighting() ##### Create Controls ##### self.createKeyControls() self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "drop":0} ##### Task Manager ##### timer = 0.2 taskMgr.doMethodLater(timer, self.traverseTask, "tsk_traverse") #scans for collisions every 0.2 seconds taskMgr.add(self.move,"moveTask") #constant smooth movement ##### Collisions ##### self.createBallColliderModel() self.disableForwardMovement = False self.disableBackwardMovement = False self.disableLeftMovement = False self.disableRightMovement = False ##### Game state variables ##### self.isMoving = False self.isDropping = False self.camAngle = math.pi/2 self.direction = "W" #constant; does not change with relativity self.drop = False self.levelHeight = 2.1 self.level = 0 self.maxLevel = 6 self.currentHeight = 13.302 self.cameraHeight = 0.2 self.mode = None self.timer = "" ##### Views ##### self.xray_mode = False self.collision_mode = False self.wireframe = False ##### On-Screen Text ##### self.title = addTitle("aMAZEing") self.instructions = OnscreenText(text="[ i ]: Toggle Instructions", style=1, fg=(0, 0, 0, 1), pos=(1.3, 0.95), align=TextNode.ARight, scale=0.05) self.instr = [] self.messages = [] self.levelText = OnscreenText(text= "Level = " + str(self.level), style=1, fg=(0, 0, 0, 1), pos=(-1.3, -0.95), align=TextNode.ALeft, scale=0.07) self.directionText = OnscreenText(text="Direction = " + self.direction, style=1, fg=(0, 0, 0, 1), pos=(-1.3, -0.85), align=TextNode.ALeft, scale=0.07) self.timerText = OnscreenText(text= self.timer, style=1, fg=(1, 1, 1, 1), pos=(1.3, 0.85), align=TextNode.ARight, scale=0.07) def setKey(self, key, value): #records the state of the arrow keys self.keyMap[key] = value ###################### Onscreen Text ####################################### def postInstructions(self): #posts the instructions onto the screen inst1 = addInstructions(0.95, "[ESC]: Quit") self.instr.append(inst1) inst2 = addInstructions(0.90, "[Left Arrow]: Turn Left") self.instr.append(inst2) inst3 = addInstructions(0.85, "[Right Arrow]: Turn Right") self.instr.append(inst3) inst4 = addInstructions(0.80, "[Up Arrow]: Move Ball Forward") self.instr.append(inst4) inst5 = addInstructions(0.75, "[Down Arrow]: Move Ball Backwards") self.instr.append(inst5) inst6 = addInstructions(0.70, "[Space]: Drop Levels (if level drop is availale)") self.instr.append(inst6) inst7 = addInstructions(0.60, "[x]: Toggle XRay Mode") self.instr.append(inst7) inst8 = addInstructions(0.55, "[c]: Toggle Collision Mode") self.instr.append(inst8) inst9 = addInstructions(0.50, "[z]: Toggle Wireframe") self.instr.append(inst9) inst10 = OnscreenText(text='''Hello! Welcome to aMAZEing! You are this sphere, and your goal is to find the exit of the maze! Each level of the maze has a hole you can drop through, to move on to the next level. This maze has six levels and each maze is a 12x12. If you chose timer mode, you have 5 minutes to finish the maze, or else you lose. Good luck! You're aMAZEing :)''', style = 1, fg=(0, 0, 0, 1), pos=(0, -.1), align=TextNode.ACenter, scale=0.07) self.instr.append(inst10) def deleteInstructions(self): #deletes onscreen instructions for instr in self.instr: instr.destroy() def addNotification(self, txt): #adds a notification to the screen y = 0.9 tex = OnscreenText(text=txt, style=1, fg= (0, 0, 0, 1), pos=(0, y)) self.messages.append(tex) def deleteNotifications(self): #deletes all on-screen notifications for msg in self.messages: msg.destroy() def updateLevelText(self): #updates the level text self.levelText.destroy() levelTextPos = (-1.3, -0.95) levelScale = 0.07 self.levelText = OnscreenText(text= "Level = " + str(self.level), style=1, fg=(0, 0, 0, 1), pos=levelTextPos, align=TextNode.ALeft, scale=levelScale) def updateDirectionText(self): #updates the direction text on the screen self.directionText.destroy() directionTextPos = (-1.3, -0.85) directionScale = 0.07 self.directionText = OnscreenText(text="Direction = " + self.direction, style=1, fg=(0, 0, 0, 1), pos=directionTextPos, align=TextNode.ALeft, scale=directionScale) def updateTimerText(self): #updates timer on screen self.timerText.destroy() timerTextPos = (1.3, 0.85) timerScale = 0.07 if self.mode == "timer": self.timerText = OnscreenText(text= self.timer, style=1, fg=(1, 1, 1, 1), pos=timerTextPos, align=TextNode.ARight, scale=timerScale) def turnWallNotification(self): #give a notification sequence at the beginning notificationSeq = Sequence() notificationSeq.append(Func(addNotification,""" If you just see a blank color, it means you are facing a wall :)""")) notificationSeq.append(Wait(8)) notificationSeq.append(Func(deleteNotifications)) notificationSeq.start() def promptMode(self): #prompts for the mode modeScreen = SplashScreen() modeScreen.mode() def setMode(self, mode): #sets the mode of the game self.mode = mode if self.mode == "timer": self.setTimer() ###################### Initialization Helper Functions ##################### def createBackground(self): #black feautureless space base.win.setClearColor(Vec4(0,0,0,1)) def loadWallModel(self): #loads the wall model (the maze) wallScale = 0.3 wallModelName = self.randomWallModel() #randomly select a maze self.wallModel = loader.loadModel(wallModelName) self.wallModel.setScale(wallScale) self.wallModel.setPos(0, 0, 0) self.wallModel.setCollideMask(BitMask32.allOff()) self.wallModel.reparentTo(render) ### Setting Texture ### texScale = 0.08 self.wallModel.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldNormal) self.wallModel.setTexProjector(TextureStage.getDefault(), render, self.wallModel) self.wallModel.setTexScale(TextureStage.getDefault(), texScale) tex = loader.load3DTexture('/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/wallTex/wallTex_#.png') self.wallModel.setTexture(tex) #creating visual geometry collision self.wallModel.setCollideMask(BitMask32.bit(0)) def randomWallModel(self): #generates a random wall in the library of mazes that were #randomly generated by the Blender script "mazeGenerator" #and exported to this computer numMazes = 10 name = str(random.randint(0, numMazes)) #randomly selects a number saved in the computer path = "/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/mazeModels/maze" path += name return path def loadBallModel(self): #loads the character, a ball model #ballModelStartPos = (-8, -8, 0.701) #THIS IS THE END ballModelStartPos = (8, 8, 13.301) #level 0 ballScale = 0.01 self.ballModel = loader.loadModel("/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/ball") self.ballModel.reparentTo(render) self.ballModel.setScale(ballScale) self.ballModel.setPos(ballModelStartPos) ### Setting ball texture ### texScale = 0.08 self.ballModel.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition) self.ballModel.setTexProjector(TextureStage.getDefault(), render, self.ballModel) self.ballModel.setTexScale(TextureStage.getDefault(), texScale) tex = loader.load3DTexture('/Users/jianwei/Documents/School/Freshman/Semester1/15-112/TERMPROJECT/Project/ballTex/ballTex_#.png') self.ballModel.setTexture(tex) def setCamera(self): #sets up the initial camera location #camera will follow the sphere followLength = 2 camHeight = 0.2 base.disableMouse() base.camera.setPos(self.ballModel.getX(), self.ballModel.getY() - followLength, self.ballModel.getZ() + camHeight) base.camLens.setNear(0.4) #creates a floater object - will look at the floater object #above the sphere, so you can get a better view self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) def createKeyControls(self): #creates the controllers for the keys #event handler #describes what each key does when pressed and unpressed self.accept("escape", sys.exit) self.accept("arrow_left", self.turnLeft) self.accept("arrow_right", self.turnRight) self.accept("arrow_up", self.setKey, ["forward",1]) self.accept("arrow_down", self.setKey, ["backward",1]) self.accept("space", self.nowDropping) #unpressed event handlers self.accept("arrow_left-up", self.setKey, ["left",0]) self.accept("arrow_right-up", self.setKey, ["right",0]) self.accept("arrow_up-up", self.setKey, ["forward",0]) self.accept("arrow_down-up", self.setKey, ["backward",0]) self.accept("space_up", self.setKey, ["drop", 0]) #views self.accept('x', self.toggle_xray_mode) self.accept('c', self.toggle_collision_mode) self.accept('z', self.toggle_wireframe) #information self.accept('i', self.postInstructions) self.accept('i-up', self.deleteInstructions) #restart self.accept('r', self.restart) #modes self.accept("t", self.setMode, ["timer"]) self.accept("m", self.setMode, ["marathon"]) def createBallColliderModel(self): #creates the collider sphere around the ball cSphereRad = 9.9 self.cTrav = CollisionTraverser() #moves over all possible collisions self.ballModelSphere = CollisionSphere(0, 0, 0, cSphereRad) #collision mesh around ball is a simple sphere self.ballModelCol = CollisionNode('ballModelSphere') self.ballModelCol.addSolid(self.ballModelSphere) self.ballModelCol.setFromCollideMask(BitMask32.bit(0)) self.ballModelCol.setIntoCollideMask(BitMask32.allOff()) self.ballModelColNp = self.ballModel.attachNewNode(self.ballModelCol) self.ballModelGroundHandler = CollisionHandlerQueue() #collision handler queue stores all collision points self.cTrav.addCollider(self.ballModelColNp, self.ballModelGroundHandler) def createLighting(self): #creates lighting for the scene aLightVal = 0.3 dLightVal1 = -5 dLightVal2 = 5 #set up the ambient light ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) ambientLight1 = AmbientLight("ambientLight1") ambientLight1.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) ambientLight2 = AmbientLight("ambientLight2") ambientLight2.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1)) #sets a directional light directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(dLightVal1, dLightVal1, dLightVal1)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(0, 0, 0, 1)) #sets a directional light directionalLight1 = DirectionalLight("directionalLight2") directionalLight1.setDirection(Vec3(dLightVal2, dLightVal1, dLightVal1)) directionalLight1.setColor(Vec4(1, 1, 1, 1)) directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1)) #attaches lights to scene render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(ambientLight1)) render.setLight(render.attachNewNode(ambientLight1)) render.setLight(render.attachNewNode(directionalLight)) render.setLight(render.attachNewNode(directionalLight1)) ###################### COLLISION DETECTION ##################################### def traverseTask(self, task=None): # handles collisions with collision handers and a # collision queue # essentially checks region of potential collision for collisions # and stops the ball if a collision is triggered # called by task manager self.ballModelGroundHandler.sortEntries() for i in range(self.ballModelGroundHandler.getNumEntries()): entry = self.ballModelGroundHandler.getEntry(i) if self.drop == True: #we cant drop in this situation self.ballModel.setZ(self.currentHeight) dropFailWait = 4 dropFailSeq = Sequence() dropFailSeq.append(Func(addNotification,"Whoops! You can't drop here!")) dropFailSeq.append(Wait(dropFailWait)) dropFailSeq.append(Func(deleteNotifications)) dropFailSeq.start() self.drop = False elif self.direction == "N": self.northDisableMovements() elif self.direction == "S": self.southDisableMovements() elif self.direction == "E": self.eastDisableMovements() elif self.direction == "W": self.westDisableMovements() if task: return task.cont #exit task # If there are no collisions if task: return task.cont def northDisableMovements(self): #disables movements when direction is north if self.keyMap["forward"] != 0: #if the ball was moving foward self.disableForwardMovement = True #disable forward movement if self.keyMap["backward"] != 0: self.disableBackwardMovement = True def southDisableMovements(self): #disables movements when direction is south if self.keyMap["forward"] != 0: self.disableBackwardMovement = True if self.keyMap["backward"] != 0: self.disableForwardMovement = True def eastDisableMovements(self): #disables movements when direction is east if self.keyMap["forward"] != 0: self.disableRightMovement = True if self.keyMap["backward"] != 0: self.disableLeftMovement = True def westDisableMovements(self): #disables movements when direction is west if self.keyMap["forward"] != 0: self.disableLeftMovement = True if self.keyMap["backward"] != 0: self.disableRightMovement = True def checkCollisions(self): #checks for collisions self.cTrav.traverse(render) def enableAllWalls(self): #enables all walls by disabling all the disable wall functions self.disableLeftMovement = False self.disableRightMovement = False self.disableForwardMovement = False self.disableBackwardMovement = False def inCollision(self): #return true if we are in a collision right now, false otherwise if (self.disableForwardMovement == True or self.disableBackwardMovement == True or self.disableRightMovement == True or self.disableLeftMovement): return True return False def checkForWin(self): #checks for a win, toggles win splash sceen if we win yLoc = self.ballModel.getY() exitBound = -9.1 if yLoc < exitBound: winScreen = SplashScreen() winScreen.win() if self.mode == "timer": self.checkForTimerLoss() def checkForTimerLoss(self): #checks to see the time, will lose if past 5 minutes if self.timer == "0:05:00": loseScreen = SplashScreen() loseScreen.lose() ###################### MOVEMENTS ############################################### def move(self, task): # Accepts arrow keys to move the player front and back # Also deals with grid checking and collision detection step = 0.03 #movement animation self.movementAnimation(step) #rotation animation self.rotationAnimation() base.camera.setX(self.ballModel.getX() + math.sin(self.camAngle)) base.camera.setY(self.ballModel.getY() + math.cos(self.camAngle)) self.resetCamDist() self.checkCollisions() self.lookAtFloater() self.checkForWin() return task.cont def resetCamDist(self): #resets the camera distance to a specific distance #keeps distance relatively constant camFarDist = 0.75 camCloseDist = 0.7 camvec = self.ballModel.getPos() - base.camera.getPos() #vector between ball and camera camvec.setZ(0) camdist = camvec.length() camvec.normalize() if (camdist > camFarDist): base.camera.setPos(base.camera.getPos() + camvec*(camdist-camFarDist)) camdist = camFarDist if (camdist < camCloseDist): base.camera.setPos(base.camera.getPos() - camvec*(camCloseDist-camdist)) camdist = camCloseDist base.camera.lookAt(self.ballModel) def lookAtFloater(self): #looks at the floater above the sphere floaterHeight = 0.23 self.floater.setPos(self.ballModel.getPos()) self.floater.setZ(self.ballModel.getZ() + floaterHeight) base.camera.lookAt(self.floater) ####################### Movement Animation ################################# def ballIsMoving(self): #notes if the ball is moving or not with self.isMoving variable if (self.keyMap["forward"]!=0) or (self.keyMap["backward"]!=0): if self.isMoving == False: self.isMoving = True elif self.keyMap["forward"] == 0 and self.keyMap["backward"] == 0: self.isMoving = False def movementAnimation(self, step): #describes the movement animation if self.drop == True: self.dropMovementAnimation(step) elif self.direction == "N": self.northMovementAnimation(step) elif self.direction == "S": self.southMovementAnimation(step) elif self.direction == "E": self.eastMovementAnimation(step) elif self.direction == "W": self.westMovementAnimation(step) def northMovementAnimation(self, step): #describes animation when direction is north if (self.keyMap["forward"]!=0): #if you are pressing forward if self.disableForwardMovement == False: #if you are just moving through space... self.ballModel.setY(self.ballModel.getY() + step) if self.disableBackwardMovement == True: #if you had moved backwards into a wall #and you want to move forward again self.ballModel.setY(self.ballModel.getY() + step) self.disableBackwardMovement = False if (self.keyMap["backward"]!=0): #if you are pressing backwards if self.disableBackwardMovement == False: #if you are just moving backwards through space... self.ballModel.setY(self.ballModel.getY() - step) if self.disableForwardMovement == True: #if you had moved forward into a wall #and want to back away from the wall self.ballModel.setY(self.ballModel.getY() - step) self.disableForwardMovement = False def southMovementAnimation(self, step): #describes animation when direction is north #same relative set of animations to northMovementAnimation #but opposite if (self.keyMap["forward"]!=0): if self.disableBackwardMovement == False: self.ballModel.setY(self.ballModel.getY() - step) if self.disableForwardMovement == True: self.ballModel.setY(self.ballModel.getY() - step) self.disableForwardMovement = False if (self.keyMap["backward"]!=0): if self.disableForwardMovement == False: self.ballModel.setY(self.ballModel.getY() + step) if self.disableBackwardMovement == True: self.ballModel.setY(self.ballModel.getY() + step) self.disableBackwardMovement = False def eastMovementAnimation(self, step): #describes animation when direction is east #same relative as north and south movement animations #but relative to the x axis #and disabling/enabling right and left movement at collisions if (self.keyMap["forward"]!=0): if self.disableRightMovement == False: self.ballModel.setX(self.ballModel.getX() + step) if self.disableLeftMovement == True: self.ballModel.setX(self.ballModel.getX() + step) self.disableLeftMovement = False if (self.keyMap["backward"]!=0): if self.disableLeftMovement == False: self.ballModel.setX(self.ballModel.getX() - step) if self.disableRightMovement == True: self.ballModel.setX(self.ballModel.getX() - step) self.disableRightMovement = False def westMovementAnimation(self, step): #describes animation when direction is west #relatively same animations as the east movement animations #exact opposite if (self.keyMap["forward"]!=0): if self.disableLeftMovement == False: self.ballModel.setX(self.ballModel.getX() - step) if self.disableRightMovement == True: self.ballModel.setX(self.ballModel.getX() - step) self.disableRightMovement = False if (self.keyMap["backward"]!=0): if self.disableRightMovement == False: self.ballModel.setX(self.ballModel.getX() + step) if self.disableLeftMovement == True: self.ballModel.setX(self.ballModel.getX() + step) self.disableLeftMovement = False def turnRight(self): #turns right in the animation #uses an interval to slowly rotate camera around initial = self.camAngle final = self.camAngle + math.pi/2 #turn animation turnTime = 0.2 turnRightSeq = Sequence() turnRightSeq.append(LerpFunc(self.changeCamAngle, turnTime, initial, final, 'easeInOut')) turnRightSeq.start() self.setKey("right", 1) #notes that the right key is pressed #changes the direction right, based on current direction if self.direction == "N": self.direction = "E" elif self.direction == "E": self.direction = "S" elif self.direction == "S": self.direction = "W" else: self.direction = "N" #when you turn, all the collision disablements should be True #just checking #self.enableAllWalls() #update the label self.updateDirectionText() def turnLeft(self): #turns left initial = self.camAngle final = self.camAngle - math.pi/2 #turn animation turnTime = 0.2 turnRightSeq = Sequence() turnRightSeq.append(LerpFunc(self.changeCamAngle, turnTime, initial, final, 'easeInOut')) turnRightSeq.start() self.setKey("left", 1) #notes that left key is pressed #changes the direction left, based on current direction if self.direction == "N": self.direction = "W" elif self.direction == "W": self.direction = "S" elif self.direction == "S": self.direction = "E" else: self.direction = "N" #when you turn, all the collision disablements should be True #just checking #self.enableAllWalls() #update the label self.updateDirectionText() def changeCamAngle(self, angle): #changes the camAngle to angle self.camAngle = angle def dropMovementAnimation(self, step): #describes movement when drop is hit a = 0.1 if self.keyMap["drop"] != 0: if self.ballModel.getZ() > self.currentHeight - self.levelHeight+ a: self.ballModel.setZ(self.ballModel.getZ() - step) else: self.currentHeight -= self.levelHeight self.level += 1 self.updateLevelText() self.drop = False base.camera.setZ(self.ballModel.getZ() + self.cameraHeight) def nowDropping(self): #toggles isDropping boolean self.drop = True self.setKey("drop", 1) ################## Ball Rotation Animation ################################# def rotationAnimation(self): #describes the rotation movement of sphere self.ballIsMoving() speed=300 inCollision = self.inCollision() if self.isMoving and not inCollision: if self.direction == "N": self.northRotationAnimation(speed) if self.direction == "S": self.southRotationAnimation(speed) if self.direction == "E": self.eastRotationAnimation(speed) if self.direction == "W": self.westRotationAnimation(speed) def northRotationAnimation(self, speed): #describes the rotation animation if direction is north if self.keyMap["forward"] != 0: self.ballModel.setP(self.ballModel.getP()-speed*globalClock.getDt()) elif self.keyMap["backward"] != 0: self.ballModel.setP(self.ballModel.getP()+speed*globalClock.getDt()) def southRotationAnimation(self, speed): #describes the rotaiton animation if the direction is south if self.keyMap["backward"] != 0: self.ballModel.setP(self.ballModel.getP()-speed*globalClock.getDt()) elif self.keyMap["forward"] != 0: self.ballModel.setP(self.ballModel.getP()+speed*globalClock.getDt()) def eastRotationAnimation(self, speed): #describes the rotation animation if the direction is east if self.keyMap["backward"] != 0: self.ballModel.setR(self.ballModel.getR()-speed*globalClock.getDt()) elif self.keyMap["forward"] != 0: self.ballModel.setR(self.ballModel.getR()+speed*globalClock.getDt()) def westRotationAnimation(self, speed): #describes the rotation animation if the direction is west if self.keyMap["forward"] != 0: self.ballModel.setR(self.ballModel.getR()-speed*globalClock.getDt()) elif self.keyMap["backward"] != 0: self.ballModel.setR(self.ballModel.getR()+speed*globalClock.getDt()) ###################### VIEWS ################################################### def toggle_xray_mode(self): #Toggle X-ray mode on and off. #Note: slows down program considerably xRayA = 0.5 self.xray_mode = not self.xray_mode if self.xray_mode: self.wallModel.setColorScale((1, 1, 1, xRayA)) self.wallModel.setTransparency(TransparencyAttrib.MDual) else: self.wallModel.setColorScaleOff() self.wallModel.setTransparency(TransparencyAttrib.MNone) def toggle_collision_mode(self): #Toggle collision mode on and off #Shows visual representation of the collisions occuring self.collision_mode = not self.collision_mode if self.collision_mode == True: # Note: Slows the program down considerably self.cTrav.showCollisions(render) else: self.cTrav.hideCollisions() def toggle_wireframe(self): #toggles wireframe view self.wireframe = not self.wireframe if self.wireframe: self.wallModel.setRenderModeWireframe() else: self.wallModel.setRenderModeFilled() ##################### RESTART ################################################## def restart(self): #restarts the game loading = SplashScreen() loading.loading() self.reset() def reset(self): #resets the maze, resets the location of the character #removes all notes self.wallModel.removeNode() self.ballModel.removeNode() #resets notes self.loadWallModel() self.loadBallModel() self.createBallColliderModel() self.resetCamDist() #resets timers taskMgr.remove("timerTask") self.timer = "" self.timerText.destroy() self.promptMode() #################### TIMER ##################################################### def setTimer(self): #code from panda.egg user on Panda3D, #"How to use Timer, a small example maybe?" forum #creates a timer self.timer = DirectLabel(pos=Vec3(1, 0.85),scale=0.08) taskMgr.add(self.timerTask, "timerTask") def dCharstr(self, theString): #code from panda.egg user on Panda3D, #"How to use Timer, a small example maybe?" forum #turns time string into a readable clock string if len(theString) != 2: theString = '0' + theString return theString def timerTask(self, task): #code from panda.egg user on Panda3D, #"How to use Timer, a small example maybe?" forum #task for resetting timer in timer mode secondsTime = int(task.time) minutesTime = int(secondsTime/60) hoursTime = int(minutesTime/60) self.timer = (str(hoursTime) + ':' + self.dCharstr(str(minutesTime%60)) + ':' + self.dCharstr(str(secondsTime%60))) self.updateTimerText() return Task.cont
class Mode(object): """This is the base Mode class""" def __init__(self, game): self.name = "MODE" self.guiMediaPath = '../Packages/anw/gui/media/' self.alive = 1 self.enableMouseCamControl = 1 self.enableScrollWheelZoom = 1 self.canSelectFlags = {} self.messagePositions = [] self.selectTypes = [] self.gui = [] self.sims = [] self.game = game self.depth = 20.0 self.zoomCameraDepth = 10.0 self.zoomCameraOutDepth = -10.0 self.zoomSpeed = 5 self.panSpeed = 1.0 self.runningTasks = [] if globals.serverMode == 0: self.setMyBackground() camera.setHpr(0,0,0) self.mainmenu = None self.scrollSpeed = 0.1 if globals.serverMode == 0: self.setMousePicker() self.setCameraPosition() self.selector = None self.selector2 = None self.log = logging.getLogger('mode') self.entryFocusList = ('anw.gui.mainmenubuttons','anw.gui.industryvalue', 'anw.gui.cityindustry','anw.gui.weapondirection', 'anw.gui.scrollvalue','anw.gui.shipdesignvalue', 'anw.gui.systemmenu','anw.gui.tradevalue', 'anw.gui.designmenu','anw.gui.shipyardmenu', 'anw.gui.mimenu', 'anw.gui.textentry', 'anw.gui.marketsystemsellvalue', 'anw.gui.sendcreditsvalue') def __getstate__(self): odict = self.__dict__.copy() # copy the dict since we change it del odict['log'] # remove stuff not to be pickled return odict def __setstate__(self,dict): log=logging.getLogger('mode') self.__dict__.update(dict) self.log=log def setMousePicker(self): self.picker = CollisionTraverser() self.pq = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNP, self.pq) self.selectable = render.attachNewNode("selectable") def setCameraPosition(self): self.cameraPos = (camera.getX(), camera.getY(), camera.getZ()) self.cameraMoving = 0 def setCanSelectFlag(self, key): """Set the Flag""" self.clearAllCanSelectFlags() self.canSelectFlags[key] = 1 def clearAllCanSelectFlags(self): """Clear any selection flags""" for key in self.canSelectFlags.keys(): self.canSelectFlags[key] = 0 def isAnyFlagSelected(self): """Return 1 if any flags are selected""" for key in self.canSelectFlags.keys(): if self.canSelectFlags[key] == 1: return 1 return 0 def validateSelection(self): """Can something be selected right now""" if self.cameraMoving == 0: return 1 else: return 0 def removeMyGui(self, myGuiName): """Remove gui""" myGui = getattr(self, myGuiName) if myGui in self.gui: self.gui.remove(myGui) if myGui != None: myGui.destroy() setattr(self, myGuiName, None) def createMainMenu(self, key): self.mainmenu = mainmenubuttons.MainMenuButtons(self.guiMediaPath) self.mainmenu.setMyGame(self.game) self.mainmenu.setMyMode(self) self.mainmenu.enableLastButton(key) self.mainmenu.checkDisableButton(key) self.mainmenu.writeGameInfo() self.mainmenu.acceptSpaceBarKey() self.gui.append(self.mainmenu) def removeMainMenu(self): if self.mainmenu != None: self.mainmenu.destroyMe() self.mainmenu = None def centerCameraOnSim(self, sim): """Center the camera on the sim position""" self.game.app.disableMouseCamControl() camera.setPos(sim.getX(), camera.getY(), sim.getZ()) camera.setHpr(0,0,0) if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() def drawBox(self, x, y, width, height, color='guiblue1', lineWidth=0.15, glow=1): """Draw a box""" #LEFT myLine = line.Line(self.guiMediaPath,(x,y),(x,y+height), 'square_grey', lineWidth, glow) myLine.sim.setColor(globals.colors[color]) self.gui.append(myLine) #TOP myLine = line.Line(self.guiMediaPath,(x,y+height),(x+width,y+height), 'square_grey', lineWidth, glow) myLine.sim.setColor(globals.colors[color]) self.gui.append(myLine) #RIGHT myLine = line.Line(self.guiMediaPath,(x+width,y+height),(x+width,y), 'square_grey', lineWidth, glow) myLine.sim.setColor(globals.colors[color]) self.gui.append(myLine) #BOTTOM myLine = line.Line(self.guiMediaPath,(x+width,y),(x,y), 'square_grey', lineWidth, glow) myLine.sim.setColor(globals.colors[color]) self.gui.append(myLine) def stopCameraTasks(self): taskMgr.remove('zoomInCameraTask') taskMgr.remove('zoomOutCameraTask') self.cameraMoving = 0 self.game.app.enableMouseCamControl() self.enableMouseCamControl=1 def resetCamera(self): self.game.app.disableMouseCamControl() camera.setPos(self.cameraPos[0], self.zoomCameraOutDepth, self.cameraPos[2]) # I don't really understand why this doesn't reset the view when having a planet selected and hitting spacebar? camera.setHpr(0,0,0) if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() def zoomInCamera(self): if camera.getY() <= self.zoomCameraDepth: self.game.app.disableMouseCamControl() taskMgr.add(self.zoomInCameraTask, 'zoomInCameraTask', extraArgs=[self.zoomCameraDepth]) self.runningTasks.append('zoomInCameraTask') def zoomInCameraAmount(self, amount): """Zoom in Camera a certain amount specified""" depth = camera.getY()+amount self.game.app.disableMouseCamControl() taskMgr.add(self.zoomInCameraTask, 'zoomInCameraTask', extraArgs=[depth]) self.runningTasks.append('zoomInCameraTask') def zoomInCameraTask(self, depth): """Zoom in the camera until its at depth""" y = camera.getY() if y + 0.1 >= depth: # or y >= 8.0: # TODO: tacking this on will mess with the design screen but prevents you from zooming in too close everywhere else. self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() camera.setY(y) return Task.done else: camera.setY(y+self.getZoomSpeed(y, depth)) self.cameraMoving = 1 return Task.cont def getZoomSpeed(self, y, depth): """Make Camera zoom in faster if camera is further away""" diff = depth-y return diff/5.0 def zoomOutCamera(self): if camera.getY() >= self.zoomCameraOutDepth: self.game.app.disableMouseCamControl() taskMgr.add(self.zoomOutCameraTask, 'zoomOutCameraTask', extraArgs=[self.zoomCameraOutDepth]) self.runningTasks.append('zoomOutCameraTask') def zoomOutCameraAmount(self, amount): """Zoom out Camera a certain amount sepecified""" depth = camera.getY()-amount self.game.app.disableMouseCamControl() taskMgr.add(self.zoomOutCameraTask, 'zoomOutCameraTask', extraArgs=[depth]) self.runningTasks.append('zoomOutCameraTask') def zoomOutCameraTask(self, depth): """Zoom out the camera until its at 0 Depth""" y = camera.getY() if y - 0.1 <= depth: self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() camera.setY(y) return Task.done else: camera.setY(y+self.getZoomSpeed(y, depth)) self.cameraMoving = 1 return Task.cont def panCameraLeft(self, amount): """Pan Camera""" pos = camera.getX()-amount self.game.app.disableMouseCamControl() taskMgr.add(self.panCameraLeftTask, 'panCameraLeftTask', extraArgs=[pos]) self.runningTasks.append('panCameraLeftTask') def panCameraLeftTask(self, pos): """pan the camera to new position""" x = camera.getX() if x <= pos: self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() return Task.done else: camera.setX(x-self.panSpeed) self.cameraMoving = 1 return Task.cont def panCameraRight(self, amount): """Pan Camera""" pos = camera.getX()+amount self.game.app.disableMouseCamControl() taskMgr.add(self.panCameraRightTask, 'panCameraRightTask', extraArgs=[pos]) self.runningTasks.append('panCameraRightTask') def panCameraRightTask(self, pos): """pan the camera to new position""" x = camera.getX() if x >= pos: self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() return Task.done else: camera.setX(x+self.panSpeed) self.cameraMoving = 1 return Task.cont def panCameraUp(self, amount): """Pan Camera""" pos = camera.getZ()+amount self.game.app.disableMouseCamControl() taskMgr.add(self.panCameraUpTask, 'panCameraUpTask', extraArgs=[pos]) self.runningTasks.append('panCameraUpTask') def panCameraUpTask(self, pos): """pan the camera to new position""" z = camera.getZ() if z >= pos: self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() return Task.done else: camera.setZ(z+self.panSpeed) self.cameraMoving = 1 return Task.cont def panCameraDown(self, amount): """Pan Camera""" pos = camera.getZ()-amount self.game.app.disableMouseCamControl() taskMgr.add(self.panCameraDownTask, 'panCameraDownTask', extraArgs=[pos]) self.runningTasks.append('panCameraDownTask') def panCameraDownTask(self, pos): """pan the camera to new position""" z = camera.getZ() if z <= pos: self.cameraMoving = 0 if self.enableMouseCamControl == 1: self.game.app.enableMouseCamControl() return Task.done else: camera.setZ(z-self.panSpeed) self.cameraMoving = 1 return Task.cont def createSelector(self,type='select',speed=2.0): """Create selector for indication of selected objects""" self.selector = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1) self.selector.hide() ival = self.selector.hprInterval((speed), Vec3(0, 0, 360)) ival.loop() def createSelector2(self,type='select',speed=2.0): """Create selector2 for indication of secondary selected objects""" self.selector2 = self.loadObject(type, scale=2, parent=render, transparency=True, pos=Point2(0,0), glow=1) self.selector2.hide() ival = self.selector2.hprInterval((speed), Vec3(0, 0, 360)) ival.loop() def playSound(self, soundName): """Play a Sound based on soundName given, call app""" if globals.serverMode == 0: self.game.app.playSound(soundName) def askForHelp(self): """Ask the Server to analyse Player and provide help""" try: serverResult = self.game.server.askForHelp(self.game.authKey) if type(serverResult) == types.ListType: (message, self.game.myEmpire['help']) = serverResult self.modeMsgBox(message) else: self.modeMsgBox(serverResult) except: self.modeMsgBox('askForHelp->Connection to Server Lost') def assignSelector(self, myObj, scale): """create the Selector and assign to myObj at scale""" if self.selector == None: self.createSelector() self.selector.show() self.selector.setPos(myObj.getX(), myObj.getY(), myObj.getZ()) self.selector.setScale(scale) def assignSelector2(self, myObj, scale): """create the Selector2 and assign to myObj at scale""" if self.selector2 == None: self.createSelector2() self.selector2.show() self.selector2.setPos(myObj.getX(), myObj.getY(), myObj.getZ()) self.selector2.setScale(scale) ##def checkEndTurn(self): ##"""Do a Server Assesment of turn before ending the turn""" ##try: ##if 'EndTurn' in self.game.myEmpire['help']: ### turn not ended yet ##(serverResult, self.game.myEmpire['help']) = self.game.server.askForHelp(self.game.authKey) ##if serverResult == 'Server Assessment: WARNINGS:0, CRITICAL:0 (Check Mail for Assesment)': ### server assessment is good, end the turn without asking ##self.endMyTurn() ##else: ### server assessment has not come back without warnings ask for confirmation ##self.modeYesNoBox('%s - Do you still want to end your turn?' % serverResult, 'endturnYes', 'yesNoBoxNo') ##else: ### turn already ended, unend turn ##self.modeYesNoBox('Do you want to cancel your end turn?' , 'endturnYes', 'yesNoBoxNo') ##except: ##self.modeMsgBox('checkEndTurn->Connection to Server Lost, Login Again') def exitGame(self, doLogout=True): """Exit the game""" self.setEmpireDefaults(self.game.authKey) if doLogout: self.setLogout(self.game.authKey) self.alive = 0 self.game.app.quit() def getCreditInfoFromServer(self): self.getEmpireUpdate(['CR']) def refreshCredit(self): """Ask the Server for an updated Credit Info""" self.mainmenu.updateCR() def getEmpireUpdate(self, listAttr): """Ask the Server for updated Empire info""" try: serverResult = self.game.server.getEmpireUpdate(self.game.authKey, listAttr) if type(serverResult) == types.StringType: self.modeMsgBox(serverResult) else: for key, value in serverResult.iteritems(): self.game.myEmpire[key] = value except: self.modeMsgBox('getEmpireUpdate->Connection to Server Lost') def getMailUpdate(self): """Ask the Server for any updated mail""" try: myMailDict = self.game.myEmpire['mailBox'] serverResult = self.game.server.getMailUpdate(self.game.authKey, myMailDict.keys()) if type(serverResult) == types.StringType: self.modeMsgBox(serverResult) else: for key, value in serverResult.iteritems(): myMailDict[key] = value except: self.modeMsgBox('getMailUpdate->Connection to Server Lost') def getGalaxyUpdate(self, listAttr): """Ask the Server for updated Galaxy info""" try: serverResult = self.game.server.getGalaxyUpdate(listAttr, self.game.authKey) if type(serverResult) == types.StringType: self.modeMsgBox(serverResult) else: for key, value in serverResult.iteritems(): self.game.myGalaxy[key] = value except: self.modeMsgBox('getGalaxyUpdate->Connection to Server Lost') def getSystemUpdate(self, listAttr, systemID): """Ask the Server for updated System info""" try: serverResult = self.game.server.getSystemUpdate(listAttr, systemID, self.game.authKey) if type(serverResult) == types.StringType: self.modeMsgBox(serverResult) else: mySystemDict = self.game.allSystems[systemID] for key, value in serverResult.iteritems(): mySystemDict[key] = value except: self.modeMsgBox('getSystemUpdate->Connection to Server Lost') def enterMode(self): """Enter the mode.""" self.alive = 1 self.setShortcuts() def setShortcuts(self): """Set the default mode shortcuts""" self.game.app.accept('mouse1', self.onMouse1Down) self.game.app.accept('mouse3', self.onMouse2Down) self.game.app.accept('space', self.onSpaceBarClear) if self.enableMouseCamControl == 1: self.game.app.accept('wheel_up', self.onMouseWheelUp) self.game.app.accept('wheel_down', self.onMouseWheelDown) def exitMode(self): """Exit the mode""" self.removeMySims() self.removeAllGui() self.game.app.ignoreAll() self.removeAllTasks() self.alive = 0 def removeAllTasks(self): """Remove and Stop any tasks running""" for taskName in self.runningTasks: taskMgr.remove(taskName) def removeMySims(self): """Remove all sims in mode""" for sim in self.sims: try: sim.destroy() except: sim.removeNode() def removeAllGui(self): """Remove all DirectGUI""" for gui in self.gui: gui.destroy() def setPlanePickable(self, obj, dictName): """Set the plane model itself to be collideable with the mouse ray""" obj.sim.reparentTo(self.selectable) obj.sim.find('**/pPlane1').node().setIntoCollideMask(BitMask32.bit(1)) obj.sim.find('**/pPlane1').node().setTag(dictName, obj.id) def setSpherePickable(self, obj, dictName): """Set the sphere model itself to be collideable with the mouse ray""" obj.sim.reparentTo(self.selectable) obj.sim.find('**/pSphere1').node().setIntoCollideMask(BitMask32.bit(1)) obj.sim.find('**/pSphere1').node().setTag(dictName, obj.id) def setMySelector(self, x, y, z, scale): """Show selector if it is not in current position else return false""" selectorPos = (self.selector.getX(), self.selector.getY(), self.selector.getZ()) if selectorPos != (x,y,z): self.selector.setPos(x,y,z) self.selector.show() self.selector.setScale(scale) return 1 else: self.selector.setPos(-1,-1,-1) return 0 #self.enableScrollWheelZoom = 0 def getListButton(self, id, myScrolledList): """Return Button selected from buttonList gui based on id""" for button in myScrolledList.buttonsList: if button['extraArgs'][1] == id: return button def setMySelector2(self, x, y, z, scale): """Show selector2 if it is not in current position else return false""" selectorPos = (self.selector2.getX(), self.selector2.getY(), self.selector2.getZ()) if selectorPos != (x,y,z): self.selector2.setPos(x,y,z) self.selector2.show() self.selector2.setScale(scale) return 1 else: self.selector2.setPos(-1,-1,-1) return 0 #self.enableScrollWheelZoom = 0 def hideMySelector(self): """Hide the selector, move its position""" self.selector.setPos(-1,-1,-1) self.selector.hide() if self.selector2 != None: self.selector2.hide() def onMouse1Down(self): """Allow dynamic picking of an object within mode""" #Check to see if we can access the mouse. We need it to do anything else if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #Do the actual collision pass (Do it only on the selectable for #efficiency purposes) self.picker.traverse(self.selectable) if self.pq.getNumEntries() > 0: #if we have hit something, sort the hits so that the closest #is first, and highlight that node self.pq.sortEntries() for selectable in self.selectTypes: name = self.pq.getEntry(0).getIntoNode().getTag(selectable) if name != '': self.clearAnyGui() mySelectedDict = getattr(self, selectable) mySelected = mySelectedDict[name] myMethod = getattr(self, '%sSelected' % selectable) if self.validateSelection(): myMethod(mySelected) break def onMouseWheelUp(self): """ zoom out """ if self.enableScrollWheelZoom: self.stopCameraTasks() self.zoomInCameraAmount(20.0) def onMouseWheelDown(self): """ zoom in """ if self.enableScrollWheelZoom: self.stopCameraTasks() self.zoomOutCameraAmount(20.0) def onMouse2Down(self): """clear""" self.onSpaceBarClear() def onSpaceBarClear(self): """Space bar should reset the view in the mode""" if self.validateSelection(): self.resetCamera() self.clearMouseSelection() self.zoomOutCamera() self.setShortcuts() self.enableScrollWheelZoom = 1 def clearMouseSelection(self): """Clear mouse selection before selecting something new""" pass def clearAnyGui(self): pass def update(self, interval): """update the mode, return the status, 0 means stop game""" return self.alive def setMyBackground(self): """Set the Background of mode""" base.setBackgroundColor(globals.colors['guiblue3']) def setEmpireDefaults(self, clientKey): """Read the defaults currently set and change them in the database""" try: # setup attributes to send to server defaults = ['viewIndustry', 'viewMilitary', 'viewResources', 'viewTradeRoutes'] d = {} for item in defaults: d[item] = self.game.myEmpire[item] serverResult = self.game.server.setEmpire(clientKey, d) if serverResult == 1: print 'Setup Empire Defaults Success' else: self.modeMsgBox(serverResult) except: self.modeMsgBox('SetEmpireDefaults->Connection to Server Lost, Login Again') def setEmpireValues(self, dValues): """Update Empire with d = key: empire attribute name, value = new value""" try: serverResult = self.game.server.setEmpire(self.game.authKey, dValues) if serverResult == 1: for key, value in dValues.iteritems(): self.game.myEmpire[key] = value print 'Empire Update Success' else: self.modeMsgBox(serverResult) except: self.modeMsgBox('setEmpireValues->Connection to Server Lost, Login Again') def setLogout(self, clientKey): """Send a Logout Request to the Server""" try: serverResult = self.game.server.logout(clientKey) if serverResult == 1: print 'Logout Successful, Exit Program' else: self.modeMsgBox(serverResult) except: self.modeMsgBox('setLogout->Connection to Server Lost, Login Again') def submitDesign(self, name): """Take Ship Design and submit it to Server for verification and storage""" (oldName, hullID, compDict, weaponDict) = self.myShipDesign.getMyDesign() dOrder = {'name':name, 'hullID':hullID, 'compDict':compDict, 'weaponDict':weaponDict} try: serverResult = self.game.server.addShipDesign(self.game.authKey, dOrder) if type(serverResult) == types.StringType: self.modeMsgBox(serverResult) else: # design has been accepted by server, retrieve design ID and add to client (ID,name) = serverResult self.game.shipDesigns[ID] = (name, hullID, compDict, weaponDict) self.getEmpireUpdate(['designsLeft']) except: self.modeMsgBox('submitDesign->Connection to Server Lost, Login Again') def destroyTempFrames(self): """Destroy any Temp Frames""" for frame in self.tempFrames: frame.destroy() self.tempFrames = [] def modeMsgBox(self, messageText): """Create a message for the user""" self.createMessage(messageText) def createMessage(self, text): """Create a new message for user""" myMessage = fadingtext.FadingText(self.guiMediaPath, text, self.messagePositions) self.messagePositions.append(myMessage.getMyPosition()) self.playSound('beep03') def writeToScreen(self, myText, x, z, scale=0.2, color='default', font=3, wordwrap=10): if color == 'default': color = Vec4(.1,.1,.8,.8) text = textonscreen.TextOnScreen(self.guiMediaPath, myText, scale,font=3) text.writeTextToScreen(x, self.depth, z, wordwrap=wordwrap) text.setColor(color) self.gui.append(text) def loadObject(self, tex=None, pos='default', depth=55, scale=1, transparency=True, parent='cam', model='plane', glow=0): if pos == 'default': pos = Point2(0,0) if parent == 'cam': parent = camera scaleX = 187.5 scaleZ = 117.1875 obj = loader.loadModelCopy('%s%s' % (self.guiMediaPath, model)) #default object uses the plane model if parent: obj.reparentTo(parent) #Everything is parented to the camera so #that it faces the screen obj.setPos(Point3(pos.getX(), depth, pos.getY())) #Set initial position obj.setSx(scaleX) obj.setSz(scaleZ) obj.setBin("unsorted", 0) #This tells Panda not to worry about the #order this is drawn in. (it prevents an #effect known as z-fighting) if transparency: obj.setTransparency(1) #All of our objects are trasnparent if tex: tex = loader.loadTexture('%s%s.png' % (self.guiMediaPath, tex)) #Load the texture obj.setTexture(tex, 1) #Set the texture self.sims.append(obj) obj.setShaderInput('glow',Vec4(glow,0,0,0),glow) return obj def onEntryFocus(self): """When a text Entry is in focus disable all shortcut keys""" for gui in self.gui: if gui.__module__ in self.entryFocusList: gui.ignoreShortcuts() def onEntryOutFocus(self): """When an text Entry is out of focus enable all shortcut keys""" for gui in self.gui: if gui.__module__ in self.entryFocusList: gui.setShortcuts()
class Camera: def __init__(self,actor): self.actor = actor self.prevtime = 0 self.controlMap = {"left":0, "right":0} taskMgr.add(self.move,"cameraMoveTask") self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) base.disableMouse() #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) base.camera.setPos(self.actor.getX()-30,self.actor.getY()-10,self.actor.getZ()+7) camera.setHpr(-60,0,0) self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('camRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = base.camera.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) self.groundColNp.show() def move(self,task): elapsed = task.time - self.prevtime base.camera.lookAt(self.actor) camright = base.camera.getNetTransform().getMat().getRow3(0) camright.normalize() if (self.controlMap["left"]!=0): base.camera.setPos(base.camera.getPos() - camright*(elapsed*50)) if (self.controlMap["right"]!=0): base.camera.setPos(base.camera.getPos() + camright*(elapsed*50)) camvec = self.actor.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() #print(camdist) camvec.normalize() if (camdist > 30.0): base.camera.setPos(base.camera.getPos() + camvec*(camdist-30)) camdist = 30.0 if (camdist < 15.0): base.camera.setPos(base.camera.getPos() - camvec*(15-camdist)) camdist = 15.0 self.cTrav.traverse(render) entries = [] for i in range(self.groundHandler.getNumEntries()): entry = self.groundHandler.getEntry(i) entries.append(entry) #print(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+4.0) if (base.camera.getZ() < self.actor.getZ() + 8.0): base.camera.setZ(self.actor.getZ() + 8.0) self.floater.setPos(self.actor.getPos()) self.floater.setZ(self.actor.getZ() + 8.0) base.camera.lookAt(self.floater) #print("camer1" ,camera.getHpr()) self.prevtime = task.time return Task.cont def setControl(self, control, value): self.controlMap[control] = value
class mouseHandler(DirectObject.DirectObject): def __init__(self, mainClass): base.cTrav = CollisionTraverser('world') # collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode = CollisionNode('mouse ray CollisionNode') pickerNP = base.camera.attachNewNode(pickerNode) self.pickerRay = CollisionRay() pickerNode.addSolid(self.pickerRay) # base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays', 'ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.tileSelected = (0, 0) self.unitSelected = None self.buildingSelected = None self.tempJob = None self.accept("mouse1", self.mouseClick1, [mainClass]) self.accept("mouse3", self.mouseClick3, [mainClass]) taskMgr.add(self.rayUpdate, "Mouse checking") def rayUpdate(self, task): if base.mouseWatcherNode.hasMouse(): self.entries = [] for i in range(self.collisionHandler2.getNumEntries()): entry = self.collisionHandler2.getEntry(i) self.entries.append(entry) self.entries.sort(lambda x, y: cmp( y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) 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 self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) return task.cont def selectUnit(self, unitID, mainClass): self.clearSelection(mainClass) self.unitSelected = unitID self.tempJob = mainClass.unitHandler.gameUnits[self.unitSelected].job mainClass.unitHandler.gameUnits[self.unitSelected].job = "selected" mainClass.unitHandler.gameUnits[self.unitSelected].select.show() if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors. behaviorStatus('pathfollow') != 'done'): mainClass.unitHandler.gameUnits[ self.unitSelected].AIBehaviors.pauseAi("pathfollow") print 'UNIT' def selectWall(self, tilePos, tempNodeName, mainClass): self.clearSelection(mainClass) if (tempNodeName[0:17] != 'render/solid roof') or ( tempNodeName[0:20] != 'render/solid corner2'): x = tilePos[0] y = tilePos[1] mainClass.GUI.showWall(mainClass.mapLoaderClass.tileArray[y][x], mainClass) if (mainClass.mapLoaderClass.tileArray[y][x].selectable == True ): # If it is selectable, then select it mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][ self.tileSelected[0]].model.setColor(1, 1, 1, 1) mainClass.mapLoaderClass.tileArray[y][x].model.setColor( 0.5, 1, 0.5, 1) self.tileSelected = (x, y) def mouseClick1(self, mainClass): if (len(self.entries) > 0): print str(self.entries[0].getIntoNodePath()) tempNodeName = str(self.entries[0].getIntoNodePath( )) # Gets the node path of whatever is clicked on print tempNodeName, tempNodeName[len(tempNodeName) - 3:len(tempNodeName)] if (tempNodeName[0:12] == "render/solid") or ( tempNodeName[0:12] == "render/tile ") or ( tempNodeName[0:12] == "render/water") or ( tempNodeName[0:11] == "render/lava"): # If a tile or a solid x = int(self.entries[0].getIntoNode().getName() [len(self.entries[0].getIntoNode().getName()) - 6:len(self.entries[0].getIntoNode().getName()) - 4]) y = int(self.entries[0].getIntoNode().getName() [len(self.entries[0].getIntoNode().getName()) - 2:]) self.selectWall((x, y), tempNodeName, mainClass) elif (tempNodeName[0:11] == "render/unit"): # If a unit self.selectUnit(int(tempNodeName[12:15]), mainClass) # elif (tempNodeName[0:15] == 'render/building'): # self.selectBuilding(int(tempNodeName[16:19]), mainClass) def mouseClick3(self, mainClass): # Deselects a wall if (self.tileSelected != (0, 0)): self.clearSelection(mainClass) # mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) # # self.tileSelected = (0,0) elif (self.unitSelected != None): if (len(self.entries) > 0): # mainClass.unitHandler.gameUnits[self.unitSelected].select.hide() tempNodeName = str(self.entries[0].getIntoNodePath()) if (tempNodeName[0:12] == "render/tile ") or ( tempNodeName[0:12] == "render/water") or (tempNodeName[0:11] == "render/lava"): # If a tile mainClass.unitHandler.moveTo( mainClass, (self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY()), self.unitSelected, userJob=True) mainClass.unitHandler.gameUnits[ self.unitSelected].AIBehaviors.resumeAi("pathfollow") self.clearSelection(mainClass) #mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) # self.tileSelected = (0,0) else: mainClass.unitHandler.gameUnits[ self.unitSelected].AIBehaviors.removeAi("pathfollow") self.unitSelected = None def clearSelection(self, mainClass): # mainClass.GUI.hideAll() if (self.tileSelected != (0, 0)): mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][ self.tileSelected[0]].model.setColor(1, 1, 1, 1) self.tileSelected = (0, 0) if (self.unitSelected != None): mainClass.unitHandler.gameUnits[self.unitSelected].select.hide() if (self.tempJob != None): mainClass.unitHandler.gameUnits[ self.unitSelected].job = self.tempJob if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors. behaviorStatus('pathfollow') == 'paused'): mainClass.unitHandler.gameUnits[ self.unitSelected].AIBehaviors.resumeAi("pathfollow") self.unitSelected = None if (self.buildingSelected != None): mainClass.buildingHandler.buildings[ self.buildingSelected].modelNode.setColor(1, 1, 1, 1) self.buildingSelected = None def mineWall(self, mainClass): if (self.tileSelected != (0, 0)): pass # mainClass.mineWall(mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]]) # self.b1.hide() # self.tileSelected = (0,0) def getMousePos(self): #if (len(self.entries) >= 1): return Vec3(self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY(), self.entries[0].getSurfacePoint(render).getZ())
class cWorld: def __init__(self): # set background color base.setBackgroundColor(0, 0, 0) # create target self.createTarget() # create boids self.createBoids() # setup camera self.setupCamera() # setup lights self.setupLights() # setup collision detection self.setupCollision() # add task taskMgr.add(self.steer, 'steer') # steer task taskMgr.add(self.moveTarget, 'moveTarget') # mouse move target task def createBoids(self): self.redBoid = cBoid() # create red boid # setup blue boid with model path, starting location, max force, and max speed self.redBoid.setup('assets/models/boid_one.egg', Vec3(0.0, 0.0, 0.0), 4.0, 0.1) # create blue boid self.blueBoid = cBoid() # setup blue boid with model path, starting location, max force, and max speed self.blueBoid.setup('assets/models/boid_two.egg', Vec3(0.0, 0.0, 0.0), 4.0, 1.0) def createTarget(self): # load in model file self.target = loader.loadModel('assets/models/target.egg') # parent self.target.reparentTo(render) # set location self.target.setPos(Vec3(0.0, 0.0, 0.0)) def setupCamera(self): # disable auto controls base.disableMouse() # set position, heading, pitch, and roll camera.setPosHpr(Vec3(0.0, -45.0, 45.0), Vec3(0.0, -45.0, 0)) def setupLights(self): # create a point light plight = PointLight('plight') # set its color plight.setColor(VBase4(1.0, 1.0, 1.0, 1)) # attach the light to the render plnp = render.attachNewNode(plight) # set position plnp.setPos(0.0, 0.0, 2.0) # turn on light render.setLight(plnp) def setupCollision(self): # create collision traverser self.picker = CollisionTraverser() # create collision handler self.pq = CollisionHandlerQueue() # create collision node self.pickerNode = CollisionNode('mouseRay') # create collision node # attach new collision node to camera node self.pickerNP = camera.attachNewNode( self.pickerNode) # attach collision node to camera # set bit mask to one self.pickerNode.setFromCollideMask(BitMask32.bit(1)) # set bit mask # create a collision ray self.pickerRay = CollisionRay() # create collision ray # add picker ray to the picker node self.pickerNode.addSolid( self.pickerRay) # add the collision ray to the collision node # make the traverser know about the picker node and its even handler queue self.picker.addCollider( self.pickerNP, self.pq) # add the colision node path and collision handler queue #self.picker.showCollisions( render ) # render or draw the collisions #self.pickerNP.show( ) # render picker ray # create col node self.colPlane = CollisionNode('colPlane') # add solid to col node plane self.colPlane.addSolid( CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))) # attach new node to the render self.colPlanePath = render.attachNewNode(self.colPlane) #self.colPlanePath.show( ) # render node # make the col plane look at the camera # this makes it alway look at the camera no matter the orientation # we need this because the ray nees to intersect a plane parallel # to the camera self.colPlanePath.lookAt(camera) # prop up the col plane self.colPlanePath.setP(-45) # set bit mask to one # as I understand it, this makes all col nodes with bit mask one # create collisions while ignoring others of other masks self.colPlanePath.node().setIntoCollideMask(BitMask32.bit(1)) def steer(self, Task): # seek after target self.redBoid.seek(Vec3(self.target.getPos())) # run the algorithm self.redBoid.run() # arrive at the target self.blueBoid.arrive(Vec3(self.target.getPos())) # run the algorithm self.blueBoid.run() return Task.cont # continue task def moveTarget(self, Task): # traverse through the render tree self.picker.traverse(render) # go through the queue of collisions for i in range(self.pq.getNumEntries()): entry = self.pq.getEntry(i) # get entry surfacePoint = entry.getSurfacePoint( render) # get surface point of collision self.target.setPos( surfacePoint) # set surface point to target's position if base.mouseWatcherNode.hasMouse(): # if we have a mouse mpos = base.mouseWatcherNode.getMouse( ) # get the path to the mouse # shoot ray from camera # based on X & Y coordinate of mouse self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) return Task.cont # continue task
class Camera: """A floating 3rd person camera that follows an actor around, and can be turned left or right around the actor. Public fields: self.controlMap -- The camera's movement controls. actor -- The Actor object that the camera will follow. Public functions: init(actor) -- Initialise the camera. move(task) -- Move the camera each frame, following the assigned actor. This task is called every frame to update the camera. setControl -- Set the camera's turn left or turn right control on or off. """ def __init__(self,actor): """Initialise the camera, setting it to follow 'actor'. Arguments: actor -- The Actor that the camera will initially follow. """ self.actor = actor self.prevtime = 0 # The camera's controls: # "left" = move the camera left, 0 = off, 1 = on # "right" = move the camera right, 0 = off, 1 = on self.controlMap = {"left":0, "right":0} taskMgr.add(self.move,"cameraMoveTask") # Create a "floater" object. It is used to orient the camera above the # target actor's head. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Set up the camera. base.disableMouse() base.camera.setPos(self.actor.getX(),self.actor.getY()+2, 2) # uncomment for topdown #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) #base.camera.setHpr(180, -50, 0) # A CollisionRay beginning above the camera and going down toward the # ground is used to detect camera collisions and the height of the # camera above the ground. A ray may hit the terrain, or it may hit a # rock or a tree. If it hits the terrain, we detect the camera's # height. If it hits anything else, the camera is in an illegal # position. self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('camRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = base.camera.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # Uncomment this line to see the collision rays #self.groundColNp.show() def move(self,task): """Update the camera's position before rendering the next frame. This is a task function and is called each frame by Panda3D. The camera follows self.actor, and tries to remain above the actor and above the ground (whichever is highest) while looking at a point slightly above the actor's head. Arguments: task -- A direct.task.Task object passed to this function by Panda3D. Return: Task.cont -- To tell Panda3D to call this task function again next frame. """ # FIXME: There is a bug with the camera -- if the actor runs up a # hill and then down again, the camera's Z position follows the actor # up the hill but does not come down again when the actor goes down # the hill. elapsed = task.time - self.prevtime # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. # comment out for topdown base.camera.lookAt(self.actor) camright = base.camera.getNetTransform().getMat().getRow3(0) camright.normalize() if (self.controlMap["left"]!=0): base.camera.setPos(base.camera.getPos() - camright*(elapsed*20)) if (self.controlMap["right"]!=0): base.camera.setPos(base.camera.getPos() + camright*(elapsed*20)) # If the camera is too far from the actor, move it closer. # If the camera is too close to the actor, move it farther. camvec = self.actor.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if (camdist > 10.0): base.camera.setPos(base.camera.getPos() + camvec*(camdist-10)) camdist = 10.0 if (camdist < 5.0): base.camera.setPos(base.camera.getPos() - camvec*(5-camdist)) camdist = 5.0 # Now check for collisions. self.cTrav.traverse(render) # Keep the camera at one foot above the terrain, # or two feet above the actor, whichever is greater. # comment out for topdown entries = [] for i in range(self.groundHandler.getNumEntries()): entry = self.groundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+1.0) if (base.camera.getZ() < self.actor.getZ() + 2.0): base.camera.setZ(self.actor.getZ() + 2.0) # The camera should look in the player's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above the player's head. self.floater.setPos(self.actor.getPos()) self.floater.setZ(self.actor.getZ() + 2.0) #self.floater.setZ(self.actor.getZ() + 10.0) #self.floater.setY(self.actor.getY() + 7.0) # comment out for topdown base.camera.lookAt(self.floater) base.camera.setPos(self.floater.getPos()) # Store the task time and continue. self.prevtime = task.time return Task.cont def setControl(self, control, value): """Set the state of one of the camera's movement controls. Arguments: See self.controlMap in __init__. control -- The control to be set, must be a string matching one of the strings in self.controlMap. value -- The value to set the control to. """ # FIXME: this function is duplicated in Camera and Character, and # keyboard control settings are spread throughout the code. Maybe # add a Controllable class? self.controlMap[control] = value
class Character: """A character with an animated avatar that moves left, right or forward according to the controls turned on or off in self.controlMap. Public fields: self.controlMap -- The character's movement controls self.actor -- The character's Actor (3D animated model) Public functions: __init__ -- Initialise the character move -- Move and animate the character for one frame. This is a task function that is called every frame by Panda3D. setControl -- Set one of the character's controls on or off. """ def __init__(self, model, run, walk, startPos, scale): """Initialise the character. Arguments: model -- The path to the character's model file (string) run : The path to the model's run animation (string) walk : The path to the model's walk animation (string) startPos : Where in the world the character will begin (pos) scale : The amount by which the size of the model will be scaled (float) """ self.controlMap = {"left":0, "right":0, "up":0, "down":0} self.actor = Actor(Config.MYDIR+model, {"run":Config.MYDIR+run, "walk":Config.MYDIR+walk}) self.actor.reparentTo(render) self.actor.setScale(scale) self.actor.setPos(startPos) self.controller = Controller.LocalController(self) taskMgr.add(self.move,"moveTask") # Note: deriving classes DO NOT need # to add their own move tasks to the # task manager. If they override # self.move, then their own self.move # function will get called by the # task manager (they must then # explicitly call Character.move in # that function if they want it). self.prevtime = 0 self.isMoving = False # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('ralphRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = self.actor.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # Uncomment this line to see the collision rays # self.groundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring # self.cTrav.showCollisions(render) def move(self, task): """Move and animate the character for one frame. This is a task function that is called every frame by Panda3D. The character is moved according to which of it's movement controls are set, and the function keeps the character's feet on the ground and stops the character from moving if a collision is detected. This function also handles playing the characters movement animations. Arguments: task -- A direct.task.Task object passed to this function by Panda3D. Return: Task.cont -- To tell Panda3D to call this task function again next frame. """ elapsed = task.time - self.prevtime # save the character's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.actor.getPos() # pass on input self.controller.move(task, elapsed) # If the character is moving, loop the run animation. # If he is standing still, stop the animation. if (self.controlMap["up"]!=0) or (self.controlMap["left"]!=0) or (self.controlMap["right"]!=0) or (self.controlMap["down"]!=0): if self.isMoving is False: self.actor.loop("run") self.isMoving = True else: if self.isMoving: self.actor.stop() self.actor.pose("walk",5) self.isMoving = False # Now check for collisions. self.cTrav.traverse(render) # Adjust the character's Z coordinate. If the character's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.groundHandler.getNumEntries()): entry = self.groundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): self.actor.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.actor.setPos(startpos) # Store the task time and continue. self.prevtime = task.time return Task.cont def setControl(self, control, value): """Set the state of one of the character's movement controls. Arguments: See self.controlMap in __init__. control -- The control to be set, must be a string matching one of the strings in self.controlMap. value -- The value to set the control to. """ # FIXME: this function is duplicated in Camera and Character, and # keyboard control settings are spread throughout the code. Maybe # add a Controllable class? self.controlMap[control] = value
class thirdPerson(DirectObject): def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False #self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", { "run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk" }) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) #self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[ mainClass, parserClass, mapLoaderClass, modelLoaderClass ]) #Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def move(self, mainClass, parserClass, mapLoaderClass, modelLoaderClass): # Get the time elapsed since last frame. We need this # for framerate-independent movement. elapsed = globalClock.getDt() # save ralph's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.ralph.getPos() # If a move-key is pressed, move ralph in the specified direction. if (self.keyMap["left"] != 0): self.ralph.setH(self.ralph.getH() + elapsed * 300) if (self.keyMap["right"] != 0): self.ralph.setH(self.ralph.getH() - elapsed * 300) if (self.keyMap["forward"] != 0): self.ralph.setY(self.ralph, -(elapsed * 50)) #25)) if (self.keyMap["backward"] != 0): self.ralph.setY(self.ralph, +(elapsed * 20)) if (self.keyMap["forward"] != 0) or (self.keyMap["left"] != 0) or (self.keyMap["right"] != 0): if self.isMoving is False: self.ralph.loop("run") self.isMoving = True elif (self.keyMap["backward"] != 0): if self.isMoving is False: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # Now check for collisions. self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.ralphGroundHandler.getNumEntries()): entry = self.ralphGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp( y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:4] == "tile"): self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) elif (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:5] == "solid"): self.ralph.setPos(startpos) x = int(entries[0].getIntoNode().getName() [len(entries[0].getIntoNode().getName()) - 6:len(entries[0].getIntoNode().getName()) - 4]) y = int(entries[0].getIntoNode().getName() [len(entries[0].getIntoNode().getName()) - 2:]) if (mapLoaderClass.tileArray[y][x].drillTime != None): mainClass.changeTile(mapLoaderClass.tileArray[y][x], 0, parserClass, modelLoaderClass, mapLoaderClass) else: self.ralph.setPos(startpos) self.ralph.setP(0) return Task.cont
class MousePicker( p3d.SingleTask ): """ Class to represent a ray fired from the input camera lens using the mouse. """ def __init__( self, *args, **kwargs ): p3d.SingleTask.__init__( self, *args, **kwargs ) self.fromCollideMask = kwargs.pop( 'fromCollideMask', None ) self.node = None self.collEntry = None # Create collision nodes self.collTrav = CollisionTraverser() #self.collTrav.showCollisions( render ) self.collHandler = CollisionHandlerQueue() self.pickerRay = CollisionRay() # Create collision ray pickerNode = CollisionNode( self.name ) pickerNode.addSolid( self.pickerRay ) pickerNode.setIntoCollideMask( BitMask32.allOff() ) pickerNp = self.camera.attachNewNode( pickerNode ) self.collTrav.addCollider( pickerNp, self.collHandler ) # Create collision mask for the ray if one is specified if self.fromCollideMask is not None: pickerNode.setFromCollideMask( self.fromCollideMask ) # Bind mouse button events eventNames = ['mouse1', 'control-mouse1', 'mouse1-up'] for eventName in eventNames: self.accept( eventName, self.FireEvent, [eventName] ) def OnUpdate( self, task ): # Update the ray's position if self.mouseWatcherNode.hasMouse(): mp = self.mouseWatcherNode.getMouse() self.pickerRay.setFromLens( self.camera.node(), mp.getX(), mp.getY() ) # Traverse the hierarchy and find collisions self.collTrav.traverse( self.rootNp ) if self.collHandler.getNumEntries(): # If we have hit something, sort the hits so that the closest is first self.collHandler.sortEntries() collEntry = self.collHandler.getEntry( 0 ) node = collEntry.getIntoNode() # If this node is different to the last node, send a mouse leave # event to the last node, and a mouse enter to the new node if node != self.node: if self.node is not None: messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] ) messenger.send( '%s-mouse-enter' % node.getName(), [collEntry] ) # Send a message containing the node name and the event over name, # including the collision entry as arguments messenger.send( '%s-mouse-over' % node.getName(), [collEntry] ) # Keep these values self.collEntry = collEntry self.node = node elif self.node is not None: # No collisions, clear the node and send a mouse leave to the last # node that stored messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] ) self.node = None def FireEvent( self, event ): """ Send a message containing the node name and the event name, including the collision entry as arguments. """ if self.node is not None: messenger.send( '%s-%s' % ( self.node.getName(), event ), [self.collEntry] ) def GetFirstNodePath( self ): """ Return the first node in the collision queue if there is one, None otherwise. """ if self.collHandler.getNumEntries(): collEntry = self.collHandler.getEntry( 0 ) return collEntry.getIntoNodePath() return None
class objectIdPicklingClass: def __init__( self, bit=[PICKABLE] ): global OBJECTIDMAPPING #Since we are using collision detection to do picking, we set it up like #any other collision detection system with a traverser and a handler self.picker = CollisionTraverser() #Make a traverser self.pq = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pickerNode = CollisionNode('mouseRay') #Attach that node to the camera since the ray will need to be positioned #relative to it self.pickerNP = base.camera.attachNewNode(self.pickerNode) #Everything to be picked will use bit 1. This way if we were doing other #collision we could seperate it self.pickerNode.setFromCollideMask(bitMaskOr(bit)) self.pickerRay = CollisionRay() #Make our ray self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node #Register the ray as something that can cause collisions self.picker.addCollider(self.pickerNP, self.pq) #self.picker.showCollisions(render) def mousePick( self ): #Check to see if we can access the mouse. We need it to do anything else if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #Do the actual collision pass (Do it only on the squares for #efficiency purposes) self.picker.traverse( render ) if self.pq.getNumEntries() > 0: #if we have hit something, sort the hits so that the closest #is first, and highlight that node self.pq.sortEntries() pickedObj = self.pq.getEntry(0).getIntoNodePath() #print pickedObj pickedObjObjectId = pickedObj.findNetTag( 'objectId' ) if pickedObj.hasNetTag( 'objectId' ): return pickedObj.getNetTag( 'objectId' ) else: print "pickedObj.hasNetTag( 'objectId' ) failed" return None else: print "self.pq.getNumEntries() = %i" % self.pq.getNumEntries() return None else: print "base.mouseWatcherNode.hasMouse() failed" return None def getPickerRayDirection( self, mousePos=None ): #posX, posY ): ''' return the direction of the ray sent trought the mouse ''' # the pickerRay cannot be changed anyway once it has been set in a frame (BUG?) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() #mousePos = (mpos.getX(), mpos.getY()) self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) # make a copy of the ray direction = self.pickerRay.getDirection() mouseRayDirection = Point3(direction.getX(), direction.getY(), direction.getZ()) # and normalize it mouseRayDirection.normalize() return mouseRayDirection def getObjectMousePick( self ): objectId = self.mousePick() if OBJECTIDMAPPING.has_key( objectId ): return OBJECTIDMAPPING[objectId] else: return None
class mouseHandler(DirectObject.DirectObject): def __init__(self, mainClass): base.cTrav = CollisionTraverser('world') # collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode=CollisionNode('mouse ray CollisionNode') pickerNP = base.camera.attachNewNode(pickerNode) self.pickerRay=CollisionRay() pickerNode.addSolid(self.pickerRay) # base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays','ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.tileSelected = (0,0) self.unitSelected = None self.buildingSelected = None self.tempJob = None self.accept("mouse1", self.mouseClick1, [mainClass]) self.accept("mouse3", self.mouseClick3, [mainClass]) taskMgr.add(self.rayUpdate, "Mouse checking") def rayUpdate(self, task): if base.mouseWatcherNode.hasMouse(): self.entries = [] for i in range(self.collisionHandler2.getNumEntries()): entry = self.collisionHandler2.getEntry(i) self.entries.append(entry) self.entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) 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 self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont def selectUnit(self, unitID, mainClass): self.clearSelection(mainClass) self.unitSelected = unitID self.tempJob = mainClass.unitHandler.gameUnits[self.unitSelected].job mainClass.unitHandler.gameUnits[self.unitSelected].job = "selected" mainClass.unitHandler.gameUnits[self.unitSelected].select.show() if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.behaviorStatus('pathfollow') != 'done'): mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.pauseAi("pathfollow") print 'UNIT' def selectWall(self, tilePos, tempNodeName, mainClass): self.clearSelection(mainClass) if (tempNodeName[0:17] != 'render/solid roof') or (tempNodeName[0:20] != 'render/solid corner2'): x = tilePos[0] y = tilePos[1] mainClass.GUI.showWall(mainClass.mapLoaderClass.tileArray[y][x], mainClass) if (mainClass.mapLoaderClass.tileArray[y][x].selectable == True): # If it is selectable, then select it mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) mainClass.mapLoaderClass.tileArray[y][x].model.setColor(0.5,1,0.5,1) self.tileSelected = (x, y) def mouseClick1(self, mainClass): if (len(self.entries)>0): print str(self.entries[0].getIntoNodePath()) tempNodeName = str(self.entries[0].getIntoNodePath()) # Gets the node path of whatever is clicked on print tempNodeName, tempNodeName[len(tempNodeName)-3:len(tempNodeName)] if (tempNodeName[0:12] == "render/solid") or (tempNodeName[0:12] == "render/tile ") or (tempNodeName[0:12] == "render/water") or (tempNodeName[0:11] == "render/lava"): # If a tile or a solid x = int(self.entries[0].getIntoNode().getName()[len(self.entries[0].getIntoNode().getName())-6:len(self.entries[0].getIntoNode().getName())-4]) y = int(self.entries[0].getIntoNode().getName()[len(self.entries[0].getIntoNode().getName())-2:]) self.selectWall((x,y), tempNodeName, mainClass) elif (tempNodeName[0:11] == "render/unit"): # If a unit self.selectUnit(int(tempNodeName[12:15]), mainClass) # elif (tempNodeName[0:15] == 'render/building'): # self.selectBuilding(int(tempNodeName[16:19]), mainClass) def mouseClick3(self, mainClass): # Deselects a wall if (self.tileSelected != (0,0)): self.clearSelection(mainClass) # mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) # # self.tileSelected = (0,0) elif (self.unitSelected != None): if (len(self.entries) > 0): # mainClass.unitHandler.gameUnits[self.unitSelected].select.hide() tempNodeName = str(self.entries[0].getIntoNodePath()) if (tempNodeName[0:12] == "render/tile ") or (tempNodeName[0:12] == "render/water") or (tempNodeName[0:11] == "render/lava"): # If a tile mainClass.unitHandler.moveTo(mainClass, (self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY()), self.unitSelected, userJob = True) mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.resumeAi("pathfollow") self.clearSelection(mainClass) #mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) # self.tileSelected = (0,0) else: mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.removeAi("pathfollow") self.unitSelected = None def clearSelection(self, mainClass): # mainClass.GUI.hideAll() if (self.tileSelected != (0,0)): mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) self.tileSelected = (0,0) if (self.unitSelected != None): mainClass.unitHandler.gameUnits[self.unitSelected].select.hide() if (self.tempJob != None): mainClass.unitHandler.gameUnits[self.unitSelected].job = self.tempJob if (mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.behaviorStatus('pathfollow') == 'paused'): mainClass.unitHandler.gameUnits[self.unitSelected].AIBehaviors.resumeAi("pathfollow") self.unitSelected = None if (self.buildingSelected != None): mainClass.buildingHandler.buildings[self.buildingSelected].modelNode.setColor(1,1,1,1) self.buildingSelected = None def mineWall(self, mainClass): if (self.tileSelected != (0,0)): pass # mainClass.mineWall(mainClass.mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]]) # self.b1.hide() # self.tileSelected = (0,0) def getMousePos(self): #if (len(self.entries) >= 1): return Vec3(self.entries[0].getSurfacePoint(render).getX(), self.entries[0].getSurfacePoint(render).getY(), self.entries[0].getSurfacePoint(render).getZ())
class MouseEvents(DirectObject.DirectObject): def __init__(self): # from gameEngine import moveUnitsNext, moveUnitsPrev # self.accept('arrow_down', moveUnitsNext ) # self.accept('arrow_up', moveUnitsPrev ) self.accept('arrow_up-repeat', self.moveCameraUp) self.accept('arrow_up', self.moveCameraUp) self.accept('arrow_down-repeat', self.moveCameraDown) self.accept('arrow_down', self.moveCameraDown) self.accept('arrow_left-repeat', self.moveCameraLeft) self.accept('arrow_left', self.moveCameraLeft) self.accept('arrow_right-repeat', self.moveCameraRight) self.accept('arrow_right', self.moveCameraRight) # Initialize the traverser. self.myTraverser = CollisionTraverser() # Initialize the handler. self.myHandler = CollisionHandlerQueue() self.accept("escape", sys.exit) #Exit the program when escape is pressed base.disableMouse() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.myTraverser.addCollider(self.pickerNP, self.myHandler) ''' the player has to double click a star or planet in order to activate them ''' self.accept("mouse1", self.handleLeftMouseClick) self.accept("mouse3", self.handleRightMouseClick) self.accept("mouse1-up", self.handleMouseDrag) self.mouseFirstPos = None cm = CardMaker('quad') # cm.setFrameFullscreenQuad() self.drag_rect_path = base.render2d.attachNewNode(cm.generate()) self.drag_rect_path.setTransparency(TransparencyAttrib.MAlpha) self.drag_rect_path.setColor(Vec4(1,1,1,0.3)) self.drag_rect_path.hide() # self.drag_rect_path = LineNodePath(base.render2d, thickness = 8.0) def selectionRectangle(self, task): if base.mouseWatcherNode.hasMouse():# and self.mouseFirstPos != None: mpos = base.mouseWatcherNode.getMouse() self.drag_rect_path.show() self.drag_rect_path.setSx(mpos.getX()-self.mouseFirstPos.getX()+0.0001) self.drag_rect_path.setSz(mpos.getY()-self.mouseFirstPos.getY()+0.0001) self.drag_rect_path.setPos(self.mouseFirstPos.getX(), 0, self.mouseFirstPos.getY()) # self.drag_rect_path.drawLines([((self.mouseFirstPos.getX(),self.mouseFirstPos.getY()),(mpos.getX(), mpos.getY()))]) # self.drag_rect_path.create() # base.win.makeDisplayRegion(self.mouseFirstPos.getX(), self.mouseFirstPos.getY(), mpos.getX(), mpos.getY()) return task.cont def handleMouseDrag(self): if base.mouseWatcherNode.hasMouse(): if self.mouseFirstPos != None: mpos = base.mouseWatcherNode.getMouse() lvec = Vec2(self.mouseFirstPos) - Vec2(mpos) if lvec.length() > 0.01: scaled_pos = Point2(self.mouseFirstPos) scaled_pos.setX(scaled_pos.getX()*base.getAspectRatio()) scaled_mpos = Point2(mpos) scaled_mpos.setX(scaled_mpos.getX()*base.getAspectRatio()) for unit in self.player.selected_units: unit.deselect() del self.player.selected_units[:] for unit in self.player.units: if unit.is3dpointIn2dRegion(scaled_pos, scaled_mpos): unit.select() self.mouseFirstPos = None self.drag_rect_path.hide() taskMgr.remove(self.rect_task) def setPlayer(self, player): self.player = player def setCamera(self, camera): self.camera = camera def moveCameraUp(self): self.camera.camera_direction = "moveUp" def moveCameraDown(self): self.camera.camera_direction = "moveDown" def moveCameraLeft(self): self.camera.camera_direction = "moveLeft" def moveCameraRight(self): self.camera.camera_direction = "moveRight" def handleLeftMouseClick(self): if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() self.savemousePos() # This makes the ray's origin the camera and makes the ray point # to the screen coordinates of the mouse. self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if self.myHandler.getNumEntries() > 0: # This is so we get the closest object. self.myHandler.sortEntries() pickedObj = self.myHandler.getEntry(0).getIntoNodePath() if pickedObj.hasTag('star'): self.selected(pickedObj, 'star', 'pyStar', 'leftClick') elif pickedObj.hasTag('planet'): self.selected(pickedObj, 'planet', 'pyPlanet', 'leftClick') elif pickedObj.hasTag('unit'): self.selected(pickedObj, 'unit', 'pyUnit', 'leftClick') elif pickedObj.hasTag('testUnit'): self.selected(pickedObj, 'testUnit', 'pyTestUnit', 'leftClick') self.rect_task = taskMgr.add(self.selectionRectangle, 'drag') def savemousePos(self): self.mouseFirstPos = Point2(base.mouseWatcherNode.getMouse()) # self.mouseFirstPos.setX(self.mouseFirstPos.getX()*1.33) def handleRightMouseClick(self): if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() # This makes the ray's origin the camera and makes the ray point # to the screen coordinates of the mouse. self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) self.myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if self.myHandler.getNumEntries() > 0: # This is so we get the closest object. self.myHandler.sortEntries() pickedObj = self.myHandler.getEntry(0).getIntoNodePath() #if pickedObj.hasTag('star'): # self.selected(pickedObj, 'star', 'pyStar') if pickedObj.hasTag('planet'): self.selected(pickedObj, 'planet', 'pyPlanet', 'rightClick') #elif pickedObj.hasTag('unit'): # self.selected(pickedObj, 'unit', 'pyUnit') def selected(self, pickedObj, tag, python_tag, click): # print 'Player has selected '+ tag + ' ' + pickedObj.getTag(tag) model_path = pickedObj.getParent() #model_path.notify("starSelected") model = model_path.getPythonTag(python_tag) if(click == 'rightClick'): model.selectRight(self.player) elif(click == 'leftClick' and tag == 'unit'): if(self.player == model.player): for unit in self.player.selected_units: unit.deselect() del self.player.selected_units[:] model.select() else: model.select(self.player)
class Hero(DirectObject): def __init__(self,no): self.HeroStats(no) self.display() # self.displaynot() self.SetupEvents() self.Collision() self.Loader() self.SkillStatus() self.sec=0 self.min=0 self.heroPace=None self.timesec = OnscreenText(text = '', pos = (1.2,-0.725),fg=(1,1,1,1),mayChange=1,scale=0.05) self.timemin = OnscreenText(text = '', pos = (1,-0.725),fg=(1,1,1,1),mayChange=1,scale=0.05) self.deathtxt=OnscreenText(text="",pos=(0.5,0.9),scale=0.5) taskMgr.add(self.update,"update") taskMgr.doMethodLater(1,self.Second,"second") taskMgr.add(self.MousePos,"mouse") def HeroStats(self,no): self.char={} self.char=hero[no] self.name=self.char['name'] self.model=Actor(MYDIRMODEL+self.char['model']+'.egg') self.type=None self.heroicon=self.char['icon'][0] self.skillicons=(self.char['icon'][1],self.char['icon'][2],self.char['icon'][3],self.char['icon'][4]) self.StartPos=Point3(25,25,0) self.gold=4000 self.goldrate = 1 self.items=[-1,-1,-1,-1,-1,-1] #each stores the no of the item self.itemindex=0 self.itemname="self.itemb" self.range=self.char['range'] self.strdt=self.char['strdt'] self.agidt=self.char['agidt'] self.intdt=self.char['intdt'] self.type=self.char['type'] self.Delta1=0 self.Delta2=0 self.Delta3=0 self.Delta4=0 self.Delta5=0 self.lvl=0 self.xp=0 self.Input=None self.str=self.char['str']+(self.strdt*self.lvl) self.agi=self.char['agi'] + (self.agidt*self.lvl) self.int=self.char['int'] +(self.intdt*self.lvl) self.basehp=590+self.str*19 self.basemp=220+(self.int*13) self.maxhp=590 +(self.str*19) self.curhp=self.maxhp self.maxmp=220 +(self.int*13) self.curmp=self.maxmp self.armor=self.char['armor'] +(self.agi/7) self.atkspeed=1.5/self.agi if self.type=='str': self.TYPESTR() if self.type=='agi': self.TYPEAGI() if self.type=='int': self.TYPEINT() self.healrate=0.003 *self.str self.mprate=0.02 *self.int self.res=0.25 self.speed=self.char['speed'] self.skill=0 self.isDead=False self.lon=pi*(self.getX()+10)*(self.getY()+10) def Loader(self): self.model=Actor("models/ralph", {"run": "models/ralph-run"}) # self.model=Actor(MYDIRMODEL+self.model+'.egg') self.model.setScale(3) # self.model.setHpr(90,270,0) self.model.setTransparency(0.5) # self.model.setScale(0.1) self.model.setPos(self.StartPos) self.model.reparentTo(render) # self.model.setColor(0, 0, 0, 0) self.model.loop("run") # self.Input=Input(self.model) Flame(self,self.model) #-------------------------------------------------------------Display Function---------------------------------------------------# def TYPESTR(self): self.mindamage=self.char['min']+self.str+self.Delta1 self.maxdamage=self.char['max']+self.str+self.Delta1 self.damage=range(int(self.mindamage),int(self.maxdamage)) def TYPEAGI(self): self.mindamage=self.char['min']+self.agi+self.Delta1 self.maxdamage=self.char['max']+self.agi+self.Delta1 self.damage=range(int(self.mindamage),int(self.maxdamage)) def TYPEINT(self): self.mindamage=self.char['min']+self.int+self.Delta1 self.maxdamage=self.char['max']+self.int+self.Delta1 self.damage=range(int(self.mindamage),int(self.maxdamage)) def TYPE(self): pass def display(self): x,y,z=self.model.getX(),self.model.getY(),self.model.getZ() base.camera.setPos(x,y,z+180) base.camera.setP(-30) base.camera.lookAt(self.model) self.panel=aspect2d.attachNewNode("panel") self.panel.setTransparency(1) self.SKNode=aspect2d.attachNewNode("skl") self.SKNode.setTransparency(0) self.HP=DirectLabel(text='',parent = self.panel,text_fg=(0,0.9,0,1),frameColor=(0,0,0,0),pos=(-0.41,0,-0.850),scale=0.04) self.MP=DirectLabel(text='',parent = self.panel,text_fg=(0,0,0.8,1),frameColor=(0,0,0,0),pos=(-0.41,0,-0.912),scale=0.04) self.LVL=DirectLabel(text ="Level %d"%(self.lvl+1),parent = self.panel,text_fg=(0,0,0,1),frameColor=(0,0,0,0),pos =(-0.5,0,-0.79),scale=Sc) Text1(self,"Damage",-0.26,-0.02,-1) Text1(self,"Armor",-0.27,0.03,-1) Text1(self,"Str",-0.25,0.085,-1) Text1(self,"Agi",-0.25,0.13,-1) Text1(self,"Int",-0.25,0.17,-1) self.DAM=Text2(self,"%d-%d",(self.mindamage-self.Delta1,self.maxdamage-self.Delta1),-0.40,-0.02,-1) self.ARM=Text2(self,"%d",(self.armor-self.Delta2),-0.40,0.03,-1) self.STR=Text2(self,"%d",(self.str-self.Delta3),-0.40,0.085,-1) self.AGI=Text2(self,"%d",(self.agi-self.Delta4),-0.40,0.13,-1) self.INT=Text2(self,"%d",(self.int-self.Delta5),-0.40,0.17,-1) if self.Delta1!=0: self.damdelta=Text3(self,"%d",self.Delta1,-0.4,-0.02,-1) if self.Delta2!=0: self.armdelta=Text3(self,"%d",self.Delta2,-0.4,0.03,-1) if self.Delta3!=0: self.strdelta=Text3(self,"%d",self.Delta3,-0.36,0.085,-1) if self.Delta4!=0: self.agidelta=Text3(self,"%d",self.Delta4,-0.44,0.13,-1) if self.Delta5!=0: self.intdelta=Text3(self,"%d",self.Delta5,-0.44,0.17,-1) self.hpbar = DirectWaitBar(barColor=(0,0.176470,0,1),parent = self.panel,scale=(0.3,0,0.23), frameColor=(0,0,0,1),pos = (0,0,-0.84)) self.mpbar=DirectWaitBar(barColor=(0,0,0.6,1),parent = self.panel,scale=(0.3,0,0.23), frameColor=(0,0,0,1),pos = (0,0,-0.90)) self.lvlbar=DirectWaitBar(barColor=(0,0,0.2,1),parent = self.panel,image='glue/lvlbar.png',image_scale=(1.1,0,0.2),scale=0.35, pos = (0,0,-0.8)) self.lvlbar.setTransparency(1) self.lvlbar.detachNode() self.skbtn1=DirectButton(image=self.skillicons[0]+'.png',parent=self.SKNode,pos=(posx-1.3,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[0]) self.skbtn2=DirectButton(image=self.skillicons[1]+'.png',parent=self.SKNode,pos=(posx-1.3+0.14,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[1]) self.skbtn3=DirectButton(image=self.skillicons[2]+'.png',parent=self.SKNode,pos=(posx-1.3+0.28,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[2]) self.skbtn4=DirectButton(image=self.skillicons[3]+'.png',parent=self.SKNode,pos=(posx-1.3+0.42,0,posy-1.2),pad=(-0.1,-0.1),scale=biconscale,command=self.SkillNo,extraArgs=[3]) self.b2 = DirectButton(text ="dam",parent = self.panel,pos=(-0.5,0,0),enableEdit=1,scale=(0.25,0,0.1),command=self.hurt,extraArgs=[200]) self.b3 = DirectButton(text ="",image='tome.tga',pos=(0.5,0,0),frameColor=(0,0,0,0),pad=(-0.1,-0.1),enableEdit=1,scale=(0.07,0,0.07),command=self.itemBuy,extraArgs=[0,300]) self.GOLD=OnscreenText(text='',fg=(1,1,1,1),pos=(1.225,-0.84),scale=0.05) # self.escapeEvent = OnscreenText(text=HELPTEXT, font = font,style=1, fg=(1,1,1,1), pos=(-0.82, -0.725),align=TextNode.ALeft, scale = .045) def displaynot(self): self.panel.detachNode() self.SKNode.detachNode() #------------------------------------------------------------Set Functions--------------------------------------------------------# def setDamage(self,amt): if delta >1: self.damage+=delta else: self.damage=self.damage+self.damage*delta def Delta(self,amt1,amt2,amt3,amt4,amt5): if amt1!=0: #After changes occur for that period the taks sets the values to zero self.Delta1+=amt1 if amt2!=0: self.Delta2+=amt2 if amt3!=0: self.Delta3+=amt3 if amt4!=0: self.Delta4+=amt3 if amt5!=0: self.Delta5+=amt3 def hurt(self,amt): if self.curhp>0: if self.curhp<=self.maxhp: self.curhp-=amt*1 def hurtMag(self,delta): if self.curhp>0: if self.curhp<=self.maxhp: self.curhp-=delta*self.res def heal(self,delta): if self.curhp!=self.maxhp: if self.curhp < self.maxhp: self.curhp+=delta def replenish(self,delta): if self.curmp!=self.maxmp: if self.curmp < self.maxmp: if self.curmp>0: self.curmp+=delta def manaspend(self,amt): if self.curmp>amt: self.curmp-=amt def setSpeed(self,delta): if delta > 1: self.speed+=delta else: self.speed=self.speed+self.speed*delta def setArmor(self,delta): self.armor+=delta def setPos(self,x,y,z): self.model.setPos(x,y,z) def setHPColor(self): if self.curhp<0.25*self.maxhp: self.hpbar['barColor']=(1,0,0,1) elif self.curhp<0.5*self.maxhp: self.hpbar['barColor']=(1,0.5,0,1) elif self.curhp<0.75*self.maxhp: self.hpbar['barColor']=(1,1,0,1) else: self.hpbar['barColor']=(0,0.176470,0,1) #-------------------------------------------------------------Setup Keys And EVENTS--------------------------------------------------# def SetupEvents(self): self.dt=0 self.keyMap = {"left":0, "right":0, "forward":0} self.isMoving = False self.Change=False self.Animate=False self.pos3d=None self.target=Point3() self.dist=0 self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) self.Text = OnscreenText(text="Set PanRate",pos=(-1.25,-0.15),scale=0.1) self.slider = DirectSlider(range=(20,100), value=50, pageSize=2, pos=(-1.25,0,-0.2),scale= (0.2,0.2,0.2), command=self.setScrollSpeed) self.dumm=loader.loadModel("models/panda.egg") self.dumm.reparentTo(render) self.dumm.setTag("Unit",'1') self.dumm.setPos(0,0,0) self.mini=0 self.x1,self.y1=self.model.getX(),self.model.getY() self.x2,self.y2=self.dumm.getX(),self.dumm.getY() self.fired=False self.atk=Attack(self.model,self.dumm,1.4) self.accept("arrow_left", self.setKey1, ["left",1,True]) self.accept("arrow_right", self.setKey1, ["right",1,True]) self.accept("arrow_up", self.setKey1, ["forward",1,True]) self.accept("arrow_left-up", self.setKey1, ["left",0,False]) self.accept("arrow_right-up", self.setKey1, ["right",0,False]) self.accept("arrow_up-up", self.setKey1, ["forward",0,False]) self.accept("mouse1",self.ObjectClick) self.accept("mouse3",self.MoveHero) def MoveHero(self): self.startR=self.model.getHpr() self.target=self.mpos3d x2,y2,z2=self.target.getX(),self.target.getY(),self.target.getZ() h1,p1,r1=self.model.getH(),self.model.getP(),self.model.getR() self.dist=sqrt(pow(self.x1-x2,2)+pow(self.y1-y2,2)) self.sptime=self.dist/(self.speed) self.hall=270-degrees(y2/x2) # self.model.setPos(self.model,self.spd,0,self.spd) self.Inter=LerpPosHprInterval(self.model,self.sptime,pos=self.target ,startPos=self.model.getPos(),startHpr=self.startR,hpr=self.startR)#(h1,p1,self.hall)) #Inter2=Func(self.model.lookAt(self.target),Wait(0.3)) self.heroPace = Sequence(self.Inter,name="heroPace") self.heroPace.start() def Collision(self): self.mpos3d=0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0)) base.cTrav = CollisionTraverser() self.collHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerNP, self.collHandler) def ObjectClick(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if self.collHandler.getNumEntries() > 0: # This is so we get the closest object. self.collHandler.sortEntries() self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath() self.pickedObj = self.pickedObj.findNetTag('Unit') if not self.pickedObj.isEmpty(): self.Attack(self.pickedObj.getPos()) #Handles the object def setKey1(self, key, value,value2): self.keyMap[key] = value self.Change=value2 def checkKeys(self): if (self.keyMap["left"]!=0): self.model.setH(self.model.getH() + self.dt*300) if (self.keyMap["right"]!=0): self.model.setH(self.model.getH() - self.dt*300) if (self.keyMap["forward"]!=0): self.model.setX(self.model, +(self.dt*25*SPEED)) def checkAnim(self): if self.Change: #(self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0): if self.isMoving is False: self.model.loop("run") self.isMoving = True else: if self.isMoving: self.model.stop() self.model.pose("walk",5) self.isMoving = False if self.Animate: pass def Attack(self,pos): self.atk.setWeil(self.model) self.atk.setTarg(self.dumm) self.atk.setDist(self.mini) if self.mini<=60: self.Animate=self.atk.ATT() else: messenger.send('mouse3') if self.mini<=60: self.atk.ATT() def setScrollSpeed(self): SCROLLSPEED=self.slider['value'] def UnSetupEvents(self): self.ignore("arrow_left") self.ignore("arrow_right") self.ignore("arrow_up") self.ignore("arrow_left-up") self.ignore("arrow_right-up") self.ignore("arrow_up-up") self.ignore("enter") self.ignore("mouse1") self.ignore("mouse3") taskMgr.remove("update") taskMgr.remove("second") taskMgr.remove("mouse") #--------------------------------------------------------------Return Functions------------------------------------------------------# def getDamage(self): return self.damage def getPos(self): return self.model.getPos() def getX(self): return self.model.getX() def getY(self): return self.model.getY() def getZ(self): return self.model.getZ() def getlvl(self): return self.lvl def getModel(self): return self.model def gainxp(self,unit): self.xp+=unit def gainGold(self,gain): self.gold+=gain def sendTime(self,min,sec): self.min=min self.sec=sec #----------------------------------------------------------------ITEM FUNCTIONS--------------------------------------------------------# def itemBuy(self,arg,cost): if self.gold>=0: if self.itemindex<=5: del self.items[self.itemindex] self.items.insert(self.itemindex,arg) self.gainGold(-cost) if self.items[self.itemindex]!=-1: if self.itemindex==0: self.itm0= aspect2d.attachNewNode("item0") DirectButton(text ="",parent=self.itm0,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) if self.itemindex==1: self.itm1= aspect2d.attachNewNode("item1") DirectButton(text ="",parent=self.itm1,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) if self.itemindex==2: self.itm2= aspect2d.attachNewNode("item2") DirectButton(text ="",parent=self.itm2,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) if self.itemindex==3: self.itm3= aspect2d.attachNewNode("item3") DirectButton(text ="",parent=self.itm3,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) if self.itemindex==4: self.itm4= aspect2d.attachNewNode("item4") DirectButton(text ="",parent=self.itm4,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) if self.itemindex==5: self.itm5= aspect2d.attachNewNode("item5") DirectButton(text ="",parent=self.itm5,image='tome.tga',pos=(0+0.12*self.itemindex,0,-0.90),pad=(-0.1,-0.1),scale=(0.05,0,0.05),extraArgs=[arg,cost],command=self.itemSold)#,commandButtons=DGG.RMB) self.itemindex+=1 else: Error("No Empty Slots") else: Error("No Gold") def itemSold(self,itemtosell,cost): self.ind=self.items.index(itemtosell) del self.items[self.ind] self.items.insert(self.ind,-1) self.gainGold(cost/2) if self.ind==0: self.itm0.detachNode() if self.ind==1: self.itm1.detachNode() if self.ind==2: self.itm2.detachNode() if self.ind==3: self.itm3.detachNode() if self.ind==4: self.itm4.detachNode() if self.ind==5: self.itm5.detachNode() self.itemindex-=1 def lvlup(self): self.lvl+=1 self.str=self.char['str'] +(self.strdt*self.lvl) self.str=self.char['str'] +(self.agidt*self.lvl) self.int=self.char['int'] +(self.intdt*self.lvl) self.hpgain=(self.strdt+self.Delta1)*19 self.mpgain=(self.intdt+self.Delta3)*13 self.maxhp=590+self.str*19 self.maxmp=290+self.int*13 #some error here self.heal(self.hpgain) self.replenish(self.mpgain) self.xp =0 #---------------------------------------------------------SKILL FUNCTIONS-------------------------------------# def SkillStatus(self): self.sp1=0 self.sp2=0 self.sp3=0 self.sp4=0 self.sp1dam=0 self.sp2dam=0 self.sp3dam=0 self.sp4dam=0 if self.sp1==1: self.range=400 self.sp1dam=130 self.raduis=100 self.sp2dam=30 self.sp3dam=90 self.pulses=6 def SkillNo(self,arg): if arg==0: if self.curmp>=100: self.accept("mouse1",Blink,extraArgs=[self]) self.skbtn1['image']='cancel.png' # self.skbtn1['command']=self.setOpen() else: Error("NO MANA") elif arg==1: StatUp(self) elif arg==2: StatDn(self) else: Ulti(self) def setOpen(self): self.open=False self.ignore("mouse1") self.skbtn1['image']=self.skillicons[0]+'.png' self.accept("mouse1",self.ObjectClick) #----------------------------------------TASK FUNCTIONS------------------------------------------------------# def Delay(self,task): self.Delta(-2,-2,-2) return task.done def Second(self,task): self.gainGold(self.goldrate) self.heal(self.healrate) self.replenish(self.mprate) return task.again def update(self,task): self.timemin.setText(str(self.min)) self.timesec.setText(str(self.sec)) self.str=self.char['str'] +(self.strdt*self.lvl)+self.Delta3 self.agi=self.char['agi'] + (self.agidt*self.lvl)+self.Delta4 self.int=self.char['int']+(self.intdt*self.lvl)+self.Delta5 self.hpgain=(self.strdt+self.Delta1)*19 self.mpgain=(self.intdt+self.Delta3)*13 self.maxhp=590+self.str*19 self.maxmp=290+self.int*13 #some error here # self.heal(self.hpgain) # self.replenish(self.mpgain) self.armor=self.char['armor'] +(self.agi/7)+self.Delta2 self.atkspeed=1.5/self.agi if self.type=='str': self.TYPESTR() if self.type=='agi': self.TYPEAGI() if self.type=='int': self.TYPEINT() self.healrate=0.03 *self.str self.mprate=0.02 *self.int self.GOLD.setText(str(self.gold)) self.hpbar['range']=int(self.maxhp) self.hpbar['value']=int(self.curhp) self.mpbar['range']=int(self.maxmp) self.mpbar['value']=int(self.curmp) self.lvlbar['range']=int(10*self.lvl) self.lvlbar['value']=int(self.xp) self.HP['text']="HP"+str(int(self.curhp))+"/"+str(int(self.maxhp)) self.MP['text']="MP"+str(int(self.curmp))+"/"+str(int(self.maxmp)) self.DAM['text']=str(int(self.mindamage))+'-'+str(int(self.maxdamage)) self.ARM['text']=str(int(self.armor)) self.STR['text']=str(int(self.str)) self.AGI['text']=str(int(self.agi)) self.INT['text']=str(int(self.int)) self.LVL['text']="LEVEL "+str(int(self.lvl)) if self.xp>=20*20: self.lvlup() if self.curhp<=0: taskMgr.add(self.Death,"death") self.x1,self.y1=self.model.getX(),self.model.getY() self.x2,self.y2=self.dumm.getX(),self.dumm.getY() self.mini=sqrt(pow(self.x1-self.x2,2)+pow(self.y1-self.y2,2)) Debug2(self,str(self.mini)) elapsed = globalClock.getDt() self.dt=elapsed self.setHPColor() self.checkAnim() self.checkKeys() # base.camera.lookAt(self.model) # self.floater.setPos(self.model.getPos()) # base.camera.lookAt(self.floater) return task.cont def Death(self,task): self.isDead=True Debug2(self,str(task.time)) if self.isDead==True: self.model.reparentTo(hidden) self.panel.detachNode() self.deathtime=(self.lvl+1)*3 self.isDead=False if int(task.time)==self.deathtime: self.model.setPos(self.StartPos) self.model.reparentTo(render) self.curhp=self.maxhp self.model.loop("walk") self.display() taskMgr.remove("death") # self.deathtxt.destroy() return task.cont def MousePos(self, task): #This Took me 1.5 Months to Learn if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.mpos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine(self.mpos3d, render.getRelativePoint(camera, nearPoint),render.getRelativePoint(camera, farPoint)): pass return task.again def destroy(self): self.panel.detachNode() self.t1.destroy() self.t2.destroy() self.model.remove() self.timesec.destroy() self.timemin.destroy() self.UnsetupEvents()
class thirdPerson(DirectObject): def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False # self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", {"run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk"}, ) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode("ralphRay") self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[mainClass, parserClass, mapLoaderClass, modelLoaderClass]) # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def move(self, mainClass, parserClass, mapLoaderClass, modelLoaderClass): # Get the time elapsed since last frame. We need this # for framerate-independent movement. elapsed = globalClock.getDt() # save ralph's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.ralph.getPos() # If a move-key is pressed, move ralph in the specified direction. if self.keyMap["left"] != 0: self.ralph.setH(self.ralph.getH() + elapsed * 300) if self.keyMap["right"] != 0: self.ralph.setH(self.ralph.getH() - elapsed * 300) if self.keyMap["forward"] != 0: self.ralph.setY(self.ralph, -(elapsed * 50)) # 25)) if self.keyMap["backward"] != 0: self.ralph.setY(self.ralph, +(elapsed * 20)) if (self.keyMap["forward"] != 0) or (self.keyMap["left"] != 0) or (self.keyMap["right"] != 0): if self.isMoving is False: self.ralph.loop("run") self.isMoving = True elif self.keyMap["backward"] != 0: if self.isMoving is False: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False else: if self.isMoving: self.ralph.stop() self.ralph.pose("walk", 5) self.isMoving = False # Now check for collisions. self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.ralphGroundHandler.getNumEntries()): entry = self.ralphGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:4] == "tile"): self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) elif (len(entries) > 0) and (entries[0].getIntoNode().getName()[0:5] == "solid"): self.ralph.setPos(startpos) x = int( entries[0] .getIntoNode() .getName()[len(entries[0].getIntoNode().getName()) - 6 : len(entries[0].getIntoNode().getName()) - 4] ) y = int(entries[0].getIntoNode().getName()[len(entries[0].getIntoNode().getName()) - 2 :]) if mapLoaderClass.tileArray[y][x].drillTime != None: mainClass.changeTile(mapLoaderClass.tileArray[y][x], 0, parserClass, modelLoaderClass, mapLoaderClass) else: self.ralph.setPos(startpos) self.ralph.setP(0) return Task.cont
class Input1(DirectObject): def __init__(self,model): # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0,0,1000) self.ralphGroundRay.setDirection(0,0,-1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0,0,1000) self.camGroundRay.setDirection(0,0,-1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays self.ralphGroundColNp.show() self.camGroundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring self.cTrav.showCollisions(render) #Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): # Get the time elapsed since last frame. We need this # for framerate-independent movement. elapsed = globalClock.getDt() #Has a Change in time from 0.04 to 0.09 constantly changes # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. base.camera.lookAt(self.model.getX(),self.model.getY(),0) # save ralph's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.model.getPos() # If a move-key is pressed, move ralph in the specified direction. # If the camera is too far from ralph, move it closer. # If the camera is too close to ralph, move it farther. camvec = self.model.getPos() - base.camera.getPos() camvec.setZ(5) camdist = camvec.length() camvec.normalize() if (camdist > 30.0): base.camera.setPos(base.camera.getPos() + camvec*(camdist-30)) camdist = 30.0 if (camdist < 15.0): base.camera.setPos(base.camera.getPos() - camvec*(15-camdist)) camdist = 15.0 # The camera should look in ralph's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above ralph's head. # Keep the camera at one foot above the terrain, # or two feet above ralph, whichever is greater. self.floater.setPos(self.model.getPos()) base.camera.lookAt(self.floater) # Now check for collisions. self.cTrav.traverse(render) # Adjust ralph's Z coordinate. If ralph's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. entries = [] for i in range(self.ralphGroundHandler.getNumEntries()): entry = self.ralphGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): self.ralph.setZ(entries[0].getSurfacePoint(render).getZ()) else: self.ralph.setPos(startpos) entries = [] for i in range(self.camGroundHandler.getNumEntries()): entry = self.camGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+1.0) if (base.camera.getZ() < self.ralph.getZ() + 2.0): base.camera.setZ(self.ralph.getZ() + 2.0) return Task.cont
class World(DirectObject.DirectObject): def __init__(self): self.creeps = None self.open = False self.sec = 0 self.min = 0 self.pindex = 1 # This is the Pause Index self.index = -1 # This is the hero Index self.rindex = False # This is the Repick Index self.hpicked = [] # This List Stores All The Heroes Picked and Removes Them for i in range(0, 110): self.hpicked.append(-1) # Gotta change and check this self.hindex = 0 # When a hero is picked this index saves it and stores it in the list self.RND = render.attachNewNode("rend") self.LightHandler = None self.Players() self.LoadTerrain() # Load the Map self.SetupCamera() self.SetupLight() self.SetupEvents() self.SetupTimer() self.chooseHero() self.SetupMap() self.SetupCreeps() self.SetupCollision() self.displayed = False self.keyMap = {"cam-left": 0, "cam-right": 0, "cam-up": 0, "cam-down": 0, "zoom-in": 0, "zoom-out": 0} self.chatindex = 0 self.chat = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] self.text = ["text1", "text2", "text3", "text4", "text5" "text6" "text7" "text8" "text9", "text10", "text11"] self.task = None def Players(self): self.hero1 = None self.hero2 = None self.hero3 = None self.hero4 = None self.hero5 = None self.hero6 = None self.hero7 = None self.hero8 = None self.hero9 = None self.hero10 = None self.player1 = None self.player2 = None self.player3 = None self.player4 = None self.player5 = None self.player6 = None self.player7 = None self.player8 = None self.player9 = None self.player10 = None def LoadTerrain(self): self.terrain = loader.loadModel("models/environment") self.terrain.setTag("Map", "1") self.terrain.reparentTo(self.RND) self.itmpan1 = OnscreenImage(image=MYDIRIMG + "/3.png", scale=(0.3, 0, 0.09), pos=(0.61, 0, -0.915)) self.itmpan2 = OnscreenImage(image=MYDIRIMG + "/3.png", scale=(0.3, 0, 0.09), pos=(0.61, 0, -0.740)) self.t2 = OnscreenImage(image=MYDIRIMG + "/t2.png", scale=(0.25, 0, 0.06), pos=(1.160, 0, -0.71)) self.t1 = OnscreenImage(image=MYDIRIMG + "/t1.png", scale=(0.25, 0, 0.06), pos=(1.160, 0, -0.83)) self.end = OnscreenImage(image=MYDIRIMG + "/end.png", scale=(0.1, 0, 0.2), pos=(1.510, 0, -0.80)) self.back = OnscreenImage(image=MYDIRIMG + "/back.png", scale=(0.57, 0, 0.2), pos=(-0.26, 0, -0.80)) def SetupCollision(self): base.cTrav = CollisionTraverser() self.collHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode("mouseRay") self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerNP, self.collHandler) def ObjectClick(self): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if self.collHandler.getNumEntries() > 0: # This is so we get the closest object. self.collHandler.sortEntries() self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath() self.pickedObj1 = self.pickedObj.findNetTag("Unit") self.pickedObj2 = self.pickedObj.findNetTag("MyHero") self.pickedObj3 = self.pickedObj.findNetTag("Map") self.pickedObj4 = self.pickedObj.findNetTag("MyHero") if self.pickedObj1 == self.creeps.getModel(): if self.displayed is False: self.displayed = True self.creeps.display() else: if self.displayed is True: self.displayed = False self.creeps.displaynot() if self.hero != None: if self.pickedObj2 == self.hero1.getModel(): if self.displayed is False: self.displayed = True self.hero1.display() else: if self.displayed is True: self.displayed = False self.hero1.displaynot() def SetupCamera(self): base.camera.setPos(0, 0, 180) base.camera.setP(-30) base.camera.lookAt(0, 0, 0) def SetupTimer(self): self.btn = aspect2d.attachNewNode("btn") self.btn.setTransparency(1) self.timesec = OnscreenText(text="", pos=(1.3, -0.71), fg=(1, 1, 1, 1), mayChange=1, scale=0.05) self.timemin = OnscreenText(text="", pos=(1.1, -0.71), fg=(1, 1, 1, 1), mayChange=1, scale=0.05) self.pausebtn = DirectButton( text="Pause (%d)" % (self.pindex), parent=self.btn, text_fg=(0, 0.2, 0, 1), text_pos=(0.05, -0.15), text_scale=(0.48, 0.53), image=(MYDIRIMG + "btnof.png", MYDIRIMG + "btnon.png", MYDIRIMG + "btnon.png", None), frameColor=(0, 0, 0, 0), pos=(-1.0, 0, -0.81), image_scale=(1.0, 0, 0.7), scale=(0.15, 0, 0.10), command=self.Pause, ) self.infobtn = DirectButton( text="Info", parent=self.btn, text_fg=(0, 0.2, 0, 1), text_pos=(0.05, -0.15), text_scale=0.6, image=(MYDIRIMG + "btnof.png", MYDIRIMG + "btnon.png", MYDIRIMG + "btnon.png", None), frameColor=(0, 0, 0, 0), pos=(-1.0, 0, -0.68), image_scale=(1.0, 0, 0.7), scale=(0.15, 0, 0.10), command=self.Pause, ) taskMgr.doMethodLater(1, self.Timer, "tickTask") def SetupMap(self): self.minimap = minimap(None) def SetupLight(self): self.LightHandler = Lights(None) def SetupEvents(self): self.DEntry = DirectEntry( text="", pos=(-0.6, 0.0, -0.7), image=MYDIRIMG + "/tooltips9.png", frameColor=(0, 0, 0, 1), width=27, image_pos=(13.5, 0, 0.2), image_scale=(15, 0, 0.6), scale=0.05, initialText="", numLines=1, focus=1, command=self.Parser, ) self.DEntry.setTransparency(1) self.DEntry.detachNode() taskMgr.add(self.MoveCamera, "CameraControl") self.accept("enter", self.MsgBox) self.accept("wheel_up", self.setKey, ["zoom-in", 1]) self.accept("wheel_down", self.setKey, ["zoom-out", 1]) # self.accept("wheel_up-up",self.setKey, ["zoom-in",0]) # self.accept("wheel_down-up",self.setKey, ["zoom-out",0]) self.accept("a", self.setKey, ["cam-left", 1]) self.accept("d", self.setKey, ["cam-right", 1]) self.accept("w", self.setKey, ["cam-up", 1]) self.accept("s", self.setKey, ["cam-down", 1]) self.accept("+", self.setKey, ["zoom-in", 1]) self.accept("-", self.setKey, ["zoom-out", 1]) self.accept("a-up", self.setKey, ["cam-left", 0]) self.accept("d-up", self.setKey, ["cam-right", 0]) self.accept("w-up", self.setKey, ["cam-up", 0]) self.accept("s-up", self.setKey, ["cam-down", 0]) self.accept("+-up", self.setKey, ["zoom-in", 0]) self.accept("--up", self.setKey, ["zoom-out", 0]) self.accept("mouse1", self.ObjectClick) def UnSetupEvents(self): self.ignore("a") self.ignore("s") self.ignore("w") self.ignore("s") self.ignore("+") self.ignore("-") self.ignore("enter") self.ignore("wheel_up") self.ignore("wheel_down") taskMgr.remove("CameraControl") def setKey(self, key, value): self.keyMap[key] = value def MoveCamera(self, task): mpos = base.mouseWatcherNode.getMouse() elapsed = globalClock.getDt() self.dt = elapsed self.mx = mpos.getX() self.my = mpos.getY() if self.keyMap["cam-left"] != 0: base.camera.setX(base.camera, -(self.dt * 20)) if self.keyMap["cam-right"] != 0: base.camera.setX(base.camera, +(self.dt * 20)) if self.keyMap["zoom-in"] != 0: base.camera.setY(base.camera, -(self.dt * 20)) if self.keyMap["zoom-out"] != 0: base.camera.setY(base.camera, +(self.dt * 20)) if self.keyMap["cam-down"] != 0: base.camera.setZ(base.camera, -(self.dt * 20)) if self.keyMap["cam-up"] != 0: base.camera.setZ(base.camera, +(self.dt * 20)) if self.mx > 0.95: if base.camera.getX() < MAPLIMIT: base.camera.setX(base.camera, +(self.dt * SCROLLSPEED)) if self.mx < -0.95: if base.camera.getX() > -MAPLIMIT: base.camera.setX(base.camera, -(self.dt * SCROLLSPEED)) if self.my > 0.95: if base.camera.getY() < MAPLIMIT: base.camera.setZ(base.camera, +(self.dt * SCROLLSPEED)) if self.my < -0.95: if base.camera.getY() > -MAPLIMIT: base.camera.setZ(base.camera, -(self.dt * SCROLLSPEED)) return task.cont def chooseHero(self): if self.hero1 == None: self.BTNnode = aspect2d.attachNewNode("buttons") for i in range(0, 3): for j in range(0, 4): self.index += 1 if icons[self.index] == None: continue if self.hpicked[self.index] == self.index: continue self.worldHeroButton(-1.8 + j * 0.1, -i * 0.1, self.index) def worldHeroButton(self, x, y, arg): DirectButton( text="", parent=self.BTNnode, text_font=font, image=MYDIRICONS + icons[arg] + ".tga", frameColor=(0, 0, 0, 0), pad=(-0.1, -0.1), image_scale=(IconSx + 0.2, 0, IconSy + 0.2), pos=(posx - 0.5 + x, 0, posy + y), scale=(0.20, 0, 0.20), command=self.SetupHero, extraArgs=[arg], ) def SetupCreeps(self): self.creeps = Unit1() def SetupHero(self, no): self.hpicked.insert(self.hindex, no) self.hindex += 1 self.BTNnode.detachNode() self.hero1 = Hero(no) self.hero1.getModel().setTag("Hero1", "1") def Timer(self, task): self.task = task self.sec += 1 if self.hero1 != None: self.hero1.sendTime(self.min, self.sec) if self.sec >= 60: self.sec = 0 self.min += 1 self.timemin.setText(str(self.min)) self.timesec.setText(str(self.sec)) return task.again def MsgBox(self): if self.open == False: self.DEntry.reparentTo(aspect2d) self.open = True else: self.DEntry.detachNode() self.open = False def Parser(self, text): Text = text # Within 120 seconds on the game if self.hero1 == None: self.BTNnode.detachNode() if Text == "-random": self.hero1 = Hero(random.randint(0, 96)) elif Text == "-random int": self.hero1 = Hero(random.randint(66, 96)) elif Text == "-random str": self.hero1 = Hero(random.randint(0, 36)) elif Text == "-random agi": self.hero1 == Hero(random.randint(36, 66)) if Text == "-repick": if self.rindex == False: if self.hero1 != None: self.hero1.destroy() self.hero1 = None self.index = -1 self.chooseHero() self.rindex = True else: Error("Cannot Repick") elif Text == "-": pass else: pass # self.Chat(Text,self.task) # taskMgr.add(self.Chat,"nn",extraArgs=[Text]) # this sends text to allies def ChatTimer(self, task, chat, i): chat.destroy() self.chat.insert(i, 0) self.chatindex -= 1 return task.done def Chat(self, text, task): for i in range(1, 15): if self.chat[i] == 0: self.text[i] = OnscreenText(text=text, pos=(-1.3, -0.4), fg=(0, 0, 0, 1), scale=0.07) self.chat.insert(self.chatindex, 1) taskMgr.doMethodLater(5, self.ChatTimer, "chat", [task, self.text[i], i]) self.chatindex += 1 break else: self.text[i].setY(-(0.1 * i) + 0.4) return task.done def Pause(self): if self.pindex != 0: self.pindex -= 1 time.sleep(2) self.pausebtn["text"] = "Pause (%d)" % (self.pindex) else: Error("Pause Limits Used") def destroy(self): if self.hero1 != None: self.hero1.destroy() self.minimap.destroy() self.btn.detachNode() self.BTNnode.detachNode() taskMgr.remove("timer") self.terrain.detachNode() del self.LightHandler del self.creeps self.UnSetupEvents() def MousePos(self, task): # This Took me 1.5 Months to Learn if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pos3d = Point3() self.nearPoint = Point3() self.farPoint = Point3() base.camLens.extrude(mpos, self.nearPoint, self.farPoint) if self.plane.intersectsLine( self.pos3d, render.getRelativePoint(camera, self.nearPoint), render.getRelativePoint(camera, self.farPoint) ): pass return task.again
class MouseControls(DirectObject.DirectObject): def __init__(self): self.keys = {} for char in string.ascii_lowercase: self.keys[char] = BUTTON_UP def makeKeyPair(ch): def keyUp(): self.keys[ch] = BUTTON_DOWN #print "%s UP" % (ch) def keyDown(): self.keys[ch] = BUTTON_UP #print "%s DOWN" % (ch) return [keyUp, keyDown] keyPair = makeKeyPair(char) self.accept(char,keyPair[0]) self.accept(char+'-up',keyPair[1]) self.accept('mouse1',self.leftClick) self.accept('mouse1-up',self.leftClickUp) self.accept('mouse2',self.mClick) self.accept('mouse2-up',self.mClickUp) self.accept('mouse3',self.rightClick) self.accept('mouse3-up',self.rightClickUp) self.mouse1Down = False self.mouse2Down = False self.mouse3Down = False self.trackMouseTimeOld = 0 self.trackMouseX = 0 self.trackMouseY = 0 self.trackMouse_Mouse1DownOld = False self.trackMouse_Mouse2DownOld = False self.trackMouse_Mouse3DownOld = False taskMgr.add(self.trackMouseTask, 'trackMouseTask') # base.cTrav = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() self.pickerCollN = CollisionNode('mouseRay') self.pickerCamN = base.camera.attachNewNode(self.pickerCollN) self.pickerCollN.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerCollN.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerCamN, self.pickerQ) self.objectUnderCursor = None #taskMgr.add(self.mousePickerTask, 'Mouse picker process') def leftClick(self): self.mouse1Down = True #Collision traversal pickerNode = CollisionNode('mouseRay') pickerNP = base.camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) myTraverser = CollisionTraverser() myHandler = CollisionHandlerQueue() myTraverser.addCollider(pickerNP, myHandler) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if myHandler.getNumEntries() > 0: # This is so we get the closest object myHandler.sortEntries() pickedObj = myHandler.getEntry(0).getIntoNodePath() objTag = pickedObj.findNetTag('mouseCollisionTag').getTag('mouseCollisionTag') if objTag and len(objTag)>0: messenger.send('object_click',[objTag]) pickerNP.remove() def leftClickUp(self): self.mouse1Down = False def mClick(self): self.mouse2Down = True def mClickUp(self): self.mouse2Down = False def rightClick(self): self.mouse3Down = True def rightClickUp(self): self.mouse3Down = False def trackMouseTask(self, task): timeElapsed = task.time - self.trackMouseTimeOld if timeElapsed < 0.05: return Task.cont self.trackMouseTimeOld = task.time if base.mouseWatcherNode.hasMouse(): mX = base.mouseWatcherNode.getMouseX() mY = base.mouseWatcherNode.getMouseY() diffX = mX-self.trackMouseX diffY = mY-self.trackMouseY if (abs(diffX) > DRAG_THRESH) or (abs(diffY) > DRAG_THRESH): messenger.send('mouseDelta',[diffX,diffY]) self.trackMouseX = mX self.trackMouseY = mY if self.trackMouse_Mouse1DownOld and self.mouse1Down: messenger.send('mouse1Delta',[diffX,diffY]) if self.trackMouse_Mouse2DownOld and self.mouse2Down: messenger.send('mouse2Delta',[diffX,diffY]) if self.trackMouse_Mouse3DownOld and self.mouse3Down: messenger.send('mouse3Delta',[diffX,diffY]) self.trackMouse_Mouse1DownOld = self.mouse1Down self.trackMouse_Mouse2DownOld = self.mouse2Down self.trackMouse_Mouse3DownOld = self.mouse3Down return Task.cont def mousePickerTask(self, task): print 'lalala: ',self.objectUnderCursor if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #self.picker.traverse(base.render) if self.pickerQ.getNumEntries() > 0: self.pickerQ.sortEntries() firstNode = self.pickerQ.getEntry(0).getIntoNode() if firstNode != self.objectUnderCursor: if self.objectUnderCursor: messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollout']) print 'Rollout', self.objectUnderCursor.getName() self.objectUnderCursor = firstNode messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollin']) print 'Rollin', self.objectUnderCursor.getName() else: if self.objectUnderCursor: messenger.send('interactive-scene-event',[self.objectUnderCursor.getName(),'rollout']) print 'Rollout', self.objectUnderCursor.getName() self.objectUnderCursor = None return task.cont
class MousePicker( gizmo_core.Object ): """ Class to represent a ray fired from the input camera lens using the mouse. """ def __init__( self, name, camera=None, rootNp=None, fromCollideMask=None, pickTag=None ): gizmo_core.Object.__init__( self, name, camera, rootNp ) self.fromCollideMask = fromCollideMask self.pickTag = pickTag self.selection = [] self.node = None self.collEntry = None # Create a marquee self.marquee = gizmo_core.Marquee( '%sMarquee' % self.name ) # Create collision nodes self.collTrav = CollisionTraverser() #self.collTrav.showCollisions( render ) self.collHandler = CollisionHandlerQueue() self.pickerRay = CollisionRay() # Create collision ray pickerNode = CollisionNode( self.name ) pickerNode.addSolid( self.pickerRay ) pickerNode.setIntoCollideMask( BitMask32.allOff() ) pickerNp = camera.attachNewNode( pickerNode ) self.collTrav.addCollider( pickerNp, self.collHandler ) # Create collision mask for the ray if one is specified if self.fromCollideMask is not None: pickerNode.setFromCollideMask( self.fromCollideMask ) # Bind mouse button events eventNames = ['mouse1', 'control-mouse1', 'mouse1-up'] for eventName in eventNames: self.accept( eventName, self.FireEvent, [eventName] ) def FireEvent( self, event ): # Send a message containing the node name and the event name, including # the collision entry as arguments if self.node is not None: messenger.send( '%s-%s' % ( self.node.getName(), event ), [self.collEntry] ) def UpdateTask( self, task ): # Traverse the hierarchy and find collisions self.collTrav.traverse( self.rootNp ) if self.collHandler.getNumEntries(): # If we have hit something, sort the hits so that the closest is first self.collHandler.sortEntries() collEntry = self.collHandler.getEntry( 0 ) node = collEntry.getIntoNode() # If this node is different to the last node, send a mouse leave # event to the last node, and a mouse enter to the new node if node != self.node: if self.node is not None: messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] ) messenger.send( '%s-mouse-enter' % node.getName(), [collEntry] ) # Send a message containing the node name and the event over name, # including the collision entry as arguments messenger.send( '%s-mouse-over' % node.getName(), [collEntry] ) # Keep these values self.collEntry = collEntry self.node = node elif self.node is not None: # No collisions, clear the node and send a mouse leave to the last # node that stored messenger.send( '%s-mouse-leave' % self.node.getName(), [self.collEntry] ) self.node = None # Update the ray's position if base.mouseWatcherNode.hasMouse(): mp = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens( self.camera.node(), mp.getX(), mp.getY() ) return task.cont def StartSelection( self, clearSelection=True ): # Start the marquee self.marquee.Start() # Clear selection list if required if clearSelection: self.selection = [] def StopSelection( self ): # Stop the marquee self.marquee.Stop() nodes = [] for node in self.rootNp.findAllMatches( '**' ): if self.marquee.IsPoint3Inside( self.camera, self.rootNp, node.getPos() ): if self.pickTag is not None: if node.getTag( self.pickTag ): nodes.append( node ) else: nodes.append( node ) # Add any node which was under the mouse to the selection if self.collHandler.getNumEntries(): collEntry = self.collHandler.getEntry( 0 ) node = collEntry.getIntoNodePath().getParent() nodes.append( node ) # If the node was already in the selection then remove it, otherwise # add the node to the selection for node in nodes: if node in self.selection: self.selection.remove( node ) else: self.selection.append( node ) # Remove duplicated self.selection = list( set( self.selection ) )
class Mouse(DirectObject): def __init__(self, app): self.app = app self.init_collide() self.has_mouse = None self.prev_pos = None self.pos = None self.drag_start = None self.hovered_object = None self.button2 = False self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask') self.task = None self.accept('mouse1', self.mouse1) self.accept('mouse1-up', self.mouse1_up) self.accept('mouse2', self.rotateCamera) self.accept('mouse2-up', self.stopCamera) self.accept('wheel_up', self.zoomIn) self.accept('wheel_down', self.zoomOut) def init_collide(self): from pandac.PandaModules import CollisionTraverser, CollisionNode from pandac.PandaModules import CollisionHandlerQueue, CollisionRay self.cTrav = CollisionTraverser('MousePointer') self.cQueue = CollisionHandlerQueue() self.cNode = CollisionNode('MousePointer') self.cNodePath = base.camera.attachNewNode(self.cNode) self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.cRay = CollisionRay() self.cNode.addSolid(self.cRay) self.cTrav.addCollider(self.cNodePath, self.cQueue) def find_object(self): if self.app.world.nodePath: self.cRay.setFromLens(base.camNode, self.pos.getX(), self.pos.getY()) self.cTrav.traverse(self.app.world.terrain.nodePath) if self.cQueue.getNumEntries() > 0: self.cQueue.sortEntries() return self.cQueue.getEntry(0).getIntoNodePath() return None def mouse_task(self, task): action = task.cont self.has_mouse = base.mouseWatcherNode.hasMouse() if self.has_mouse: self.pos = base.mouseWatcherNode.getMouse() if self.prev_pos: self.delta = self.pos - self.prev_pos else: self.delta = None if self.task: action = self.task(task) else: self.pos = None if self.pos: self.prev_pos = Point2(self.pos.getX(), self.pos.getY()) return action def hover(self, task): if self.hovered_object: self.hovered_object.unhover() self.hovered_object = None if self.button2: self.camera_drag() hovered_nodePath = self.find_object() if hovered_nodePath: tile = hovered_nodePath.findNetTag('tile') if not tile.isEmpty(): tag = tile.getTag('tile') coords = tag.split(',') (x, y) = [int(n) for n in coords] self.hovered_object = self.app.world.terrain.rows[x][y] self.hovered_object.hover() character = hovered_nodePath.findNetTag('char') if not character.isEmpty(): tag = character.getTag('char') (team_index, char_id) = [int(n) for n in tag.split(',')] self.hovered_object = self.app.world.teams[team_index].characters_dict[char_id] self.hovered_object.hover() return task.cont def mouse1(self): self.app.state.request('mouse1') def mouse1_up(self): self.app.state.request('mouse1-up') def camera_drag(self): if self.delta: old_heading = base.camera.getH() new_heading = old_heading - self.delta.getX() * 180 base.camera.setH(new_heading % 360) old_pitch = base.camera.getP() new_pitch = old_pitch + self.delta.getY() * 90 new_pitch = max(-90, min(0, new_pitch)) base.camera.setP(new_pitch) def rotateCamera(self): self.button2 = True def stopCamera(self): self.button2 = False def zoomIn(self): lens = base.cam.node().getLens() size = lens.getFilmSize() lens.setFilmSize(size / 1.2) def zoomOut(self): lens = base.cam.node().getLens() size = lens.getFilmSize() lens.setFilmSize(size * 1.2)
class Input(DirectObject): def __init__(self,model): self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) self.Text = OnscreenText(text="Set PanRate",pos=(-1.25,-0.15),scale=0.1) self.slider = DirectSlider(range=(20,100), value=50, pageSize=2, pos=(-1.25,0,-0.2),scale= (0.2,0.2,0.2), command=self.setScrollSpeed) def Attack(self,pos): self.atk.setWeil(self.model) self.atk.setTarg(self.dumm) self.atk.setDist(self.mini) if self.mini<=60: self.Animate=self.atk.ATT() else: messenger.send('mouse3') if self.mini<=60: self.atk.ATT() def setScrollSpeed(self): SCROLLSPEED=self.slider['value'] def MousePos(self, task): #This Took me 1.5 Months to Learn if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pos3d = Point3() self.nearPoint = Point3() self.farPoint = Point3() base.camLens.extrude(mpos, self.nearPoint, self.farPoint) if self.plane.intersectsLine(self.pos3d, render.getRelativePoint(camera, self.nearPoint), render.getRelativePoint(camera, self.farPoint)): pass return task.again def MoveHero(self): self.startR=self.model.getHpr() self.target=self.pos3d x2,y2,z2=self.target.getX(),self.target.getY(),self.target.getZ() h1,p1,r1=self.model.getH(),self.model.getP(),self.model.getR() self.dist=sqrt(pow(self.x1-x2,2)+pow(self.y1-y2,2)) self.sptime=self.dist/(30) self.hall=270-degrees(y2/x2) # self.model.setPos(self.model,self.spd,0,self.spd) Inter=LerpPosHprInterval(self.model,self.sptime,pos=self.target ,startPos=self.model.getPos(),startHpr=self.startR,hpr=self.startR)#(h1,p1,self.hall)) #Inter2=Func(self.model.lookAt(self.target),Wait(0.3)) self.heroPace = Sequence(Inter,name="heroPace") self.heroPace.start() def Move(self,task): self.x1,self.y1=self.model.getX(),self.model.getY() self.x2,self.y2=self.dumm.getX(),self.dumm.getY() self.mini=sqrt(pow(self.x1-self.x2,2)+pow(self.y1-self.y2,2)) Debug2(self,str(self.mini)) elapsed = globalClock.getDt() self.dt=elapsed self.setAnim() if (self.keyMap["left"]!=0): self.model.setH(self.model.getH() + self.dt*300) if (self.keyMap["right"]!=0): self.model.setH(self.model.getH() - self.dt*300) if (self.keyMap["forward"]!=0): self.model.setX(self.model, +(self.dt*25*SPEED)) # base.camera.lookAt(self.model) self.floater.setPos(self.model.getPos()) # base.camera.lookAt(self.floater) return task.cont def Setup(self): self.accept("arrow_left", self.setKey1, ["left",1,True]) self.accept("arrow_right", self.setKey1, ["right",1,True]) self.accept("arrow_up", self.setKey1, ["forward",1,True]) self.accept("arrow_left-up", self.setKey1, ["left",0,False]) self.accept("arrow_right-up", self.setKey1, ["right",0,False]) self.accept("arrow_up-up", self.setKey1, ["forward",0,False]) self.accept("mouse1",self.ObjectClick) self.accept("mouse3",self.MoveHero) def setKey1(self, key, value,value2): self.keyMap[key] = value self.Change=value2 def setAnim(self): if self.Change: #(self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0): if self.isMoving is False: self.model.loop("run") self.isMoving = True else: if self.isMoving: self.model.stop() self.model.pose("walk",5) self.isMoving = False if self.Animate: pass #set the attack anim here def Coll(self): base.cTrav = CollisionTraverser() self.collHandler = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerNP, self.collHandler) def ObjectClick(self): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) base.cTrav.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if self.collHandler.getNumEntries() > 0: # This is so we get the closest object. self.collHandler.sortEntries() self.pickedObj = self.collHandler.getEntry(0).getIntoNodePath() self.pickedObj = self.pickedObj.findNetTag('Unit') if not self.pickedObj.isEmpty(): self.Attack(self.pickedObj.getPos())
class cameraCollisionClass: def __init__( self ): self.collisionCheckSetup() def collisionCheckSetup( self ): print "setting up collision check" #No we create a ray to start above the ball and cast down. This is to #Determine the height the ball should be at and the angle the floor is #tilting. We could have used the sphere around the ball itself, but it #would not be as reliable self.cameraGroundRay = CollisionRay() #Create the ray self.cameraGroundRay.setOrigin(0,0,0.0) #Set its origin self.cameraGroundRay.setDirection(0,0,-1.0) #And its direction #Collision solids go in CollisionNode self.cameraGroundCol = CollisionNode('cameraGroundRay') #Create and name the node self.cameraGroundCol.addSolid(self.cameraGroundRay) #Add the ray self.cameraGroundCol.setFromCollideMask(bitMaskOr([GROUND])) #Set its bitmasks self.cameraGroundCol.setIntoCollideMask(bitMaskOr([])) #Attach the node to the ballRoot so that the ray is relative to the ball #(it will always be 10 feet over the ball and point down) # self.cameraGroundColNp = base.camera.attachNewNode(self.cameraGroundCol) ### the ground controller is allways looking down NOT ACTIVE self.horizontalCameraNode = base.camera.attachNewNode('horizontalCameraNode') self.horizontalCameraNode.reparentTo( base.camera ) self.cameraGroundColNp = self.horizontalCameraNode.attachNewNode(self.cameraGroundCol) #Uncomment this line to see the ray #self.cameraGroundColNp.show() ''' # the camera forward rays look in the direction of the camera self.cameraFrontRay = CollisionRay() #Create the ray self.cameraFrontRay.setOrigin (0,-1,0) #Set its origin self.cameraFrontRay.setDirection(0, 5,0) #And its direction self.cameraFrontCol = CollisionNode('cameraFrontRay') #Create and name the node self.cameraFrontCol.addSolid(self.cameraFrontRay) #Add the ray self.cameraFrontCol.setFromCollideMask(bitMaskOr([WALLS])) #Set its bitmasks self.cameraFrontCol.setIntoCollideMask(bitMaskOr([])) self.cameraFrontColNp = base.camera.attachNewNode(self.cameraFrontCol) #self.cameraFrontColNp.show() self.cameraBackRay = CollisionRay() #Create the ray self.cameraBackRay.setOrigin (0, 1,0) #Set its origin self.cameraBackRay.setDirection(0,-5,0) #And its direction self.cameraBackCol = CollisionNode('cameraBackRay') #Create and name the node self.cameraBackCol.addSolid(self.cameraBackRay) #Add the ray self.cameraBackCol.setFromCollideMask(bitMaskOr([WALLS])) #Set its bitmasks self.cameraBackCol.setIntoCollideMask(bitMaskOr([])) self.cameraBackColNp = base.camera.attachNewNode(self.cameraBackCol) #self.cameraBackColNp.show() # the camera left/right rays self.cameraLeftRay = CollisionRay() #Create the ray self.cameraLeftRay.setOrigin (-1,0,0) #Set its origin self.cameraLeftRay.setDirection( 5,0,0) #And its direction self.cameraLeftCol = CollisionNode('cameraLeftRay') #Create and name the node self.cameraLeftCol.addSolid(self.cameraLeftRay) #Add the ray self.cameraLeftCol.setFromCollideMask(bitMaskOr([WALLS])) #Set its bitmasks self.cameraLeftCol.setIntoCollideMask(bitMaskOr([])) self.cameraLeftColNp = base.camera.attachNewNode(self.cameraLeftCol) #self.cameraLeftColNp.show() self.cameraRightRay = CollisionRay() #Create the ray self.cameraRightRay.setOrigin ( 1,0,0) #Set its origin self.cameraRightRay.setDirection(-5,0,0) #And its direction self.cameraRightCol = CollisionNode('cameraRightRay') #Create and name the node self.cameraRightCol.addSolid(self.cameraRightRay) #Add the ray self.cameraRightCol.setFromCollideMask(bitMaskOr([WALLS])) #Set its bitmasks self.cameraRightCol.setIntoCollideMask(bitMaskOr([])) self.cameraRightColNp = base.camera.attachNewNode(self.cameraRightCol) #self.cameraRightColNp.show() ''' #Finally, we create a CollisionTraverser. CollisionTraversers are what #do the job of calculating collisions self.cTrav = CollisionTraverser() #Collision traverservs tell collision handlers about collisions, and then #the handler decides what to do with the information. We are using a #CollisionHandlerQueue, which simply creates a list of all of the #collisions in a given pass. There are more sophisticated handlers like #one that sends events and another that tries to keep collided objects #apart, but the results are often better with a simple queue self.cGroundHandler = CollisionHandlerQueue() self.cWallHandler = CollisionHandlerQueue() #Now we add the collision nodes that can create a collision to the #traverser. The traverser will compare these to all others nodes in the #scene. There is a limit of 32 CollisionNodes per traverser #We add the collider, and the handler to use as a pair #self.cTrav.addCollider(self.cameraBallSphere, self.cHandler) self.cTrav.addCollider(self.cameraGroundColNp, self.cGroundHandler) ''' self.cTrav.addCollider(self.cameraBackColNp, self.cWallHandler) self.cTrav.addCollider(self.cameraFrontColNp, self.cWallHandler) self.cTrav.addCollider(self.cameraLeftColNp, self.cWallHandler) self.cTrav.addCollider(self.cameraRightColNp, self.cWallHandler) ''' # we dont want this to be automatically executed #base.cTrav = self.cTrav #Collision traversers have a built in tool to help visualize collisions. #Uncomment the next line to see it. #self.cTrav.showCollisions(render) #self.cTrav.traverse( render ) # add a task to check for collisions taskMgr.add(self.collisionCheckTask, 'collisionCheckTask') def collisionCheckTask( self, task ): # make the parent of the groundCollideHandler be horizontal relative to render self.horizontalCameraNode.setHpr( render, Vec3(0,0,0)) self.cTrav.traverse( render ) #The collision handler collects the collisions. We dispatch which function #to handle the collision based on the name of what was collided into for i in range(self.cGroundHandler.getNumEntries()): self.cGroundHandler.sortEntries() entry = self.cGroundHandler.getEntry(i) object = entry.getIntoNode() self.groundCollideHandler(entry) # stop after first one break for i in range(self.cWallHandler.getNumEntries()): self.cWallHandler.sortEntries() entry = self.cWallHandler.getEntry(i) object = entry.getIntoNode() self.wallCollideHandler(entry) # stop after first one break return Task.cont def groundCollideHandler( self, colEntry ): # get Z position of collision newZ = colEntry.getSurfacePoint(render).getZ() # set position node of camera above collision point base.camera.setZ(newZ+GROUNDDISTANCE) def wallCollideHandler( self, colEntry ): # get position of collision collisionPos = colEntry.getSurfacePoint(render) # get position of camera cameraPos = base.camera.getPos(render) # distance from collisionpoint to camera distance = collisionPos - cameraPos # length of the distance distanceLength = distance.length() # if distance to collision point smaller then defined if distanceLength < MINDISTANCEWALL: # move camera backwand to be at correct distance base.camera.setPos( base.camera.getPos() - (distance * (MINDISTANCEWALL - distanceLength)))
class MouseControls(DirectObject.DirectObject): def __init__(self): self.keys = {} for char in string.ascii_lowercase: self.keys[char] = BUTTON_UP def makeKeyPair(ch): def keyUp(): self.keys[ch] = BUTTON_DOWN #print "%s UP" % (ch) def keyDown(): self.keys[ch] = BUTTON_UP #print "%s DOWN" % (ch) return [keyUp, keyDown] keyPair = makeKeyPair(char) self.accept(char, keyPair[0]) self.accept(char + '-up', keyPair[1]) self.accept('mouse1', self.leftClick) self.accept('mouse1-up', self.leftClickUp) self.accept('mouse2', self.mClick) self.accept('mouse2-up', self.mClickUp) self.accept('mouse3', self.rightClick) self.accept('mouse3-up', self.rightClickUp) self.mouse1Down = False self.mouse2Down = False self.mouse3Down = False self.trackMouseTimeOld = 0 self.trackMouseX = 0 self.trackMouseY = 0 self.trackMouse_Mouse1DownOld = False self.trackMouse_Mouse2DownOld = False self.trackMouse_Mouse3DownOld = False taskMgr.add(self.trackMouseTask, 'trackMouseTask') # base.cTrav = CollisionTraverser() self.pickerQ = CollisionHandlerQueue() self.pickerCollN = CollisionNode('mouseRay') self.pickerCamN = base.camera.attachNewNode(self.pickerCollN) self.pickerCollN.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerCollN.addSolid(self.pickerRay) base.cTrav.addCollider(self.pickerCamN, self.pickerQ) self.objectUnderCursor = None #taskMgr.add(self.mousePickerTask, 'Mouse picker process') def leftClick(self): self.mouse1Down = True #Collision traversal pickerNode = CollisionNode('mouseRay') pickerNP = base.camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) myTraverser = CollisionTraverser() myHandler = CollisionHandlerQueue() myTraverser.addCollider(pickerNP, myHandler) if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) myTraverser.traverse(render) # Assume for simplicity's sake that myHandler is a CollisionHandlerQueue. if myHandler.getNumEntries() > 0: # This is so we get the closest object myHandler.sortEntries() pickedObj = myHandler.getEntry(0).getIntoNodePath() objTag = pickedObj.findNetTag('mouseCollisionTag').getTag( 'mouseCollisionTag') if objTag and len(objTag) > 0: messenger.send('object_click', [objTag]) pickerNP.remove() def leftClickUp(self): self.mouse1Down = False def mClick(self): self.mouse2Down = True def mClickUp(self): self.mouse2Down = False def rightClick(self): self.mouse3Down = True def rightClickUp(self): self.mouse3Down = False def trackMouseTask(self, task): timeElapsed = task.time - self.trackMouseTimeOld if timeElapsed < 0.05: return Task.cont self.trackMouseTimeOld = task.time if base.mouseWatcherNode.hasMouse(): mX = base.mouseWatcherNode.getMouseX() mY = base.mouseWatcherNode.getMouseY() diffX = mX - self.trackMouseX diffY = mY - self.trackMouseY if (abs(diffX) > DRAG_THRESH) or (abs(diffY) > DRAG_THRESH): messenger.send('mouseDelta', [diffX, diffY]) self.trackMouseX = mX self.trackMouseY = mY if self.trackMouse_Mouse1DownOld and self.mouse1Down: messenger.send('mouse1Delta', [diffX, diffY]) if self.trackMouse_Mouse2DownOld and self.mouse2Down: messenger.send('mouse2Delta', [diffX, diffY]) if self.trackMouse_Mouse3DownOld and self.mouse3Down: messenger.send('mouse3Delta', [diffX, diffY]) self.trackMouse_Mouse1DownOld = self.mouse1Down self.trackMouse_Mouse2DownOld = self.mouse2Down self.trackMouse_Mouse3DownOld = self.mouse3Down return Task.cont def mousePickerTask(self, task): print 'lalala: ', self.objectUnderCursor if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #self.picker.traverse(base.render) if self.pickerQ.getNumEntries() > 0: self.pickerQ.sortEntries() firstNode = self.pickerQ.getEntry(0).getIntoNode() if firstNode != self.objectUnderCursor: if self.objectUnderCursor: messenger.send( 'interactive-scene-event', [self.objectUnderCursor.getName(), 'rollout']) print 'Rollout', self.objectUnderCursor.getName() self.objectUnderCursor = firstNode messenger.send( 'interactive-scene-event', [self.objectUnderCursor.getName(), 'rollin']) print 'Rollin', self.objectUnderCursor.getName() else: if self.objectUnderCursor: messenger.send( 'interactive-scene-event', [self.objectUnderCursor.getName(), 'rollout']) print 'Rollout', self.objectUnderCursor.getName() self.objectUnderCursor = None return task.cont
class Camera: """A floating 3rd person camera that follows an actor around, and can be turned left or right around the actor. Public fields: self.controlMap -- The camera's movement controls. actor -- The Actor object that the camera will follow. Public functions: init(actor) -- Initialise the camera. move(task) -- Move the camera each frame, following the assigned actor. This task is called every frame to update the camera. setControl -- Set the camera's turn left or turn right control on or off. """ def __init__(self, actor): """Initialise the camera, setting it to follow 'actor'. Arguments: actor -- The Actor that the camera will initially follow. """ self.actor = actor self.prevtime = 0 # The camera's controls: # "left" = move the camera left, 0 = off, 1 = on # "right" = move the camera right, 0 = off, 1 = on self.controlMap = {"left": 0, "right": 0} taskMgr.add(self.move, "cameraMoveTask") # Create a "floater" object. It is used to orient the camera above the # target actor's head. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Set up the camera. base.disableMouse() base.camera.setPos(self.actor.getX(), self.actor.getY() + 2, 2) # uncomment for topdown #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) #base.camera.setHpr(180, -50, 0) # A CollisionRay beginning above the camera and going down toward the # ground is used to detect camera collisions and the height of the # camera above the ground. A ray may hit the terrain, or it may hit a # rock or a tree. If it hits the terrain, we detect the camera's # height. If it hits anything else, the camera is in an illegal # position. self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0, 0, 1000) self.groundRay.setDirection(0, 0, -1) self.groundCol = CollisionNode('camRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = base.camera.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # Uncomment this line to see the collision rays #self.groundColNp.show() def move(self, task): """Update the camera's position before rendering the next frame. This is a task function and is called each frame by Panda3D. The camera follows self.actor, and tries to remain above the actor and above the ground (whichever is highest) while looking at a point slightly above the actor's head. Arguments: task -- A direct.task.Task object passed to this function by Panda3D. Return: Task.cont -- To tell Panda3D to call this task function again next frame. """ # FIXME: There is a bug with the camera -- if the actor runs up a # hill and then down again, the camera's Z position follows the actor # up the hill but does not come down again when the actor goes down # the hill. elapsed = task.time - self.prevtime # If the camera-left key is pressed, move camera left. # If the camera-right key is pressed, move camera right. # comment out for topdown base.camera.lookAt(self.actor) camright = base.camera.getNetTransform().getMat().getRow3(0) camright.normalize() if (self.controlMap["left"] != 0): base.camera.setPos(base.camera.getPos() - camright * (elapsed * 20)) if (self.controlMap["right"] != 0): base.camera.setPos(base.camera.getPos() + camright * (elapsed * 20)) # If the camera is too far from the actor, move it closer. # If the camera is too close to the actor, move it farther. camvec = self.actor.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if (camdist > 10.0): base.camera.setPos(base.camera.getPos() + camvec * (camdist - 10)) camdist = 10.0 if (camdist < 5.0): base.camera.setPos(base.camera.getPos() - camvec * (5 - camdist)) camdist = 5.0 # Now check for collisions. self.cTrav.traverse(render) # Keep the camera at one foot above the terrain, # or two feet above the actor, whichever is greater. # comment out for topdown entries = [] for i in range(self.groundHandler.getNumEntries()): entry = self.groundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x, y: cmp( y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ() + 1.0) if (base.camera.getZ() < self.actor.getZ() + 2.0): base.camera.setZ(self.actor.getZ() + 2.0) # The camera should look in the player's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above the player's head. self.floater.setPos(self.actor.getPos()) self.floater.setZ(self.actor.getZ() + 2.0) #self.floater.setZ(self.actor.getZ() + 10.0) #self.floater.setY(self.actor.getY() + 7.0) # comment out for topdown base.camera.lookAt(self.floater) base.camera.setPos(self.floater.getPos()) # Store the task time and continue. self.prevtime = task.time return Task.cont def setControl(self, control, value): """Set the state of one of the camera's movement controls. Arguments: See self.controlMap in __init__. control -- The control to be set, must be a string matching one of the strings in self.controlMap. value -- The value to set the control to. """ # FIXME: this function is duplicated in Camera and Character, and # keyboard control settings are spread throughout the code. Maybe # add a Controllable class? self.controlMap[control] = value
class CameraHandler(DirectObject.DirectObject): def __init__(self, parserClass, mapLoaderClass, modelLoaderClass, mainClass, mapWidth, mapHeight, scrollborder, zoomInSpeed, zoomOutSpeed, zoomMax, zoomMin): self.zoomMax = zoomMax self.zoomMin = zoomMin base.disableMouse() # This disables the default mouse based camera control used by panda. This default control is awkward, and won't be used. base.camera.setPos(10,20,10) base.camera.lookAt(0,0,0) # Gives the camera an initial position and rotation. self.mx,self.my = 0,0 # Sets up variables for storing the mouse coordinates self.orbiting = False # A boolean variable for specifying whether the camera is in orbiting mode. Orbiting mode refers to when the camera is being moved # because the user is holding down the right mouse button. self.target = Vec3() # sets up a vector variable for the camera's target. The target will be the coordinates that the camera is currently focusing on. self.camDist = 20 # A variable that will determine how far the camera is from it's target focus self.panRateDivisor = 100. # This variable is used as a divisor when calculating how far to move the camera when panning. Higher numbers will yield slower panning # and lower numbers will yield faster panning. This must not be set to 0. self.panZoneSize = scrollborder # This variable controls how close the mouse cursor needs to be to the edge of the screen to start panning the camera. It must be less than 1, # and I recommend keeping it less than .2 self.panLimitsX = Vec2(0, 4*mapWidth) self.panLimitsY = Vec2(0, 4*mapHeight) # These two vairables will serve as limits for how far the camera can pan, so you don't scroll away from the map. self.setTarget(0,0,0) # calls the setTarget function to set the current target position to the origin. self.turnCameraAroundPoint(0,0) # calls the turnCameraAroundPoint function with a turn amount of 0 to set the camera position based on the target and camera distance self.accept("mouse2",self.startOrbit) # sets up the camrea handler to accept a right mouse click and start the "drag" mode. self.accept("mouse2-up",self.stopOrbit) # sets up the camrea handler to understand when the right mouse button has been released, and ends the "drag" mode when # the release is detected. # The next pair of lines use lambda, which creates an on-the-spot one-shot function. self.accept("wheel_up",lambda : self.adjustCamDist(zoomInSpeed)) # sets up the camera handler to detet when the mouse wheel is rolled upwards and uses a lambda function to call the # adjustCamDist function with the argument 0.9 self.accept("wheel_down",lambda : self.adjustCamDist(zoomOutSpeed)) # sets up the camera handler to detet when the mouse wheel is rolled upwards and uses a lambda function to call the # adjustCamDist function with the argument 1.1 # ######### self.tileSelected = (0,0) #** Collision events ignition base.cTrav = CollisionTraverser() collisionHandler = CollisionHandlerEvent() self.collisionHandler2 = CollisionHandlerQueue() pickerNode=CollisionNode('mouseraycnode') pickerNP=base.camera.attachNewNode(pickerNode) self.pickerRay=CollisionRay() pickerNode.addSolid(self.pickerRay) base.cTrav.showCollisions(render) # The ray tag pickerNode.setTag('rays','ray1') base.cTrav.addCollider(pickerNP, self.collisionHandler2) self.accept("mouse1", self.mouseClick, [mapLoaderClass]) self.accept("q", self.mineWall, [parserClass, modelLoaderClass, mapLoaderClass, mainClass]) taskMgr.add(self.rayupdate, "blah") ########## taskMgr.add(self.camMoveTask,'camMoveTask') # sets the camMoveTask to be run every frame ########## def rayupdate(self, task): if base.mouseWatcherNode.hasMouse(): self.entry=0 self.collisionHandler2.sortEntries() if self.collisionHandler2.getNumEntries()>0: self.entry=self.collisionHandler2.getEntry(0) 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 self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont def mineWall(self, parserClass, modelLoaderClass, mapLoaderClass, mainClass): if (self.tileSelected != (0,0)): mainClass.mineWall(mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]], parserClass, modelLoaderClass, mapLoaderClass) def mouseClick(self, mapLoaderClass): if (self.entry!=0): x = int(self.entry.getIntoNode().getName()[len(self.entry.getIntoNode().getName())-6:len(self.entry.getIntoNode().getName())-4]) y = int(self.entry.getIntoNode().getName()[len(self.entry.getIntoNode().getName())-2:]) if (mapLoaderClass.tileArray[y][x].selectable == True): mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) mapLoaderClass.tileArray[y][x].model.setColor(0.5,1,0.5,1) self.tileSelected = (x, y) else: mapLoaderClass.tileArray[self.tileSelected[1]][self.tileSelected[0]].model.setColor(1,1,1,1) self.tileSelected = (0,0) # print self.tileSelected def turnCameraAroundPoint(self, deltaX, deltaY): # This function performs two important tasks. First, it is used for the camera orbital movement that occurs when the # right mouse button is held down. It is also called with 0s for the rotation inputs to reposition the camera during the # panning and zooming movements. # The delta inputs represent the change in rotation of the camera, which is also used to determine how far the camera # actually moves along the orbit. newCamHpr = Vec3() newCamPos = Vec3() # Creates temporary containers for the new rotation and position values of the camera. camHpr=base.camera.getHpr() # Creates a container for the current HPR of the camera and stores those values. newCamHpr.setX(camHpr.getX()+deltaX) newCamHpr.setY(self.clamp(camHpr.getY()-deltaY, -85, -10)) newCamHpr.setZ(camHpr.getZ()) # Adjusts the newCamHpr values according to the inputs given to the function. The Y value is clamped to prevent # the camera from orbiting beneath the ground plane and to prevent it from reaching the apex of the orbit, which # can cause a disturbing fast-rotation glitch. base.camera.setHpr(newCamHpr) # Sets the camera's rotation to the new values. angleradiansX = newCamHpr.getX() * (math.pi / 180.0) angleradiansY = newCamHpr.getY() * (math.pi / 180.0) # Generates values to be used in the math that will calculate the new position of the camera. newCamPos.setX(self.camDist*math.sin(angleradiansX)*math.cos(angleradiansY)+self.target.getX()) newCamPos.setY(-self.camDist*math.cos(angleradiansX)*math.cos(angleradiansY)+self.target.getY()) newCamPos.setZ(-self.camDist*math.sin(angleradiansY)+self.target.getZ()) base.camera.setPos(newCamPos.getX(),newCamPos.getY(),newCamPos.getZ()) # print (newCamPos.getX(),newCamPos.getY(),newCamPos.getZ()) # Performs the actual math to calculate the camera's new position and sets the camera to that position. #Unfortunately, this math is over my head, so I can't fully explain it. base.camera.lookAt(self.target.getX(),self.target.getY(),self.target.getZ() ) # Points the camera at the target location. def setTarget(self, x, y, z): #This function is used to give the camera a new target position. x = self.clamp(x, self.panLimitsX.getX(), self.panLimitsX.getY()) self.target.setX(x) y = self.clamp(y, self.panLimitsY.getX(), self.panLimitsY.getY()) self.target.setY(y) self.target.setZ(z) # Stores the new target position values in the target variable. The x and y values are clamped to the pan limits. def setPanLimits(self, xMin, xMax, yMin, yMax): # This function is used to set the limitations of the panning movement. self.panLimitsX = (xMin, xMax) self.panLimitsY = (yMin, yMax) # Sets the inputs into the limit variables. def clamp(self, val, minVal, maxVal): # This function constrains a value such that it is always within or equal to the minimum and maximum bounds. val = min( max(val, minVal), maxVal) # This line first finds the larger of the val or the minVal, and then compares that to the maxVal, taking the smaller. This ensures # that the result you get will be the maxVal if val is higher than it, the minVal if val is lower than it, or the val itself if it's # between the two. return val # returns the clamped value def startOrbit(self): # This function puts the camera into orbiting mode. self.orbiting=True # Sets the orbiting variable to true to designate orbiting mode as on. def stopOrbit(self): # This function takes the camera out of orbiting mode. self.orbiting=False # Sets the orbiting variable to false to designate orbiting mode as off. def adjustCamDist(self, distFactor): # This function increases or decreases the distance between the camera and the target position to simulate zooming in and out. # The distFactor input controls the amount of camera movement. # For example, inputing 0.9 will set the camera to 90% of it's previous distance. self.camDist=self.camDist*distFactor if (self.camDist >= self.zoomMax): self.camDist = self.zoomMax elif (self.camDist <= self.zoomMin): self.camDist = self.zoomMin # Sets the new distance into self.camDist. self.turnCameraAroundPoint(0,0) # Calls turnCameraAroundPoint with 0s for the rotation to reset the camera to the new position. def camMoveTask(self, task): # This task is the camera handler's work house. It's set to be called every frame and will control both orbiting and panning the camera. if base.mouseWatcherNode.hasMouse(): # We're going to use the mouse, so we have to make sure it's in the game window. If it's not and we try to use it, we'll get # a crash error. mpos = base.mouseWatcherNode.getMouse() # Gets the mouse position if self.orbiting: # Checks to see if the camera is in orbiting mode. Orbiting mode overrides panning, because it would be problematic if, while # orbiting the camera the mouse came close to the screen edge and started panning the camera at the same time. self.turnCameraAroundPoint((self.mx-mpos.getX())*100,(self.my-mpos.getY())*100) # calculates new values for camera rotation based on the change in mouse position. mx and my are used here as the old # mouse position. else: # If the camera isn't in orbiting mode, we check to see if the mouse is close enough to the edge of the screen to start panning moveY=False moveX=False # these two booleans are used to denote if the camera needs to pan. X and Y refer to the mouse position that causes the # panning. X is the left or right edge of the screen, Y is the top or bottom. if self.my > (1 - self.panZoneSize): angleradiansX1 = base.camera.getH() * (math.pi / 180.0) panRate1 = (1 - self.my - self.panZoneSize) * (self.camDist / self.panRateDivisor) * 2 moveY = True if self.my < (-1 + self.panZoneSize): angleradiansX1 = base.camera.getH() * (math.pi / 180.0)+math.pi panRate1 = (1 + self.my - self.panZoneSize)*(self.camDist / self.panRateDivisor) moveY = True if self.mx > (1 - self.panZoneSize): angleradiansX2 = base.camera.getH() * (math.pi / 180.0)+math.pi*0.5 panRate2 = (1 - self.mx - self.panZoneSize) * (self.camDist / self.panRateDivisor) * 2 moveX = True if self.mx < (-1 + self.panZoneSize): angleradiansX2 = base.camera.getH() * (math.pi / 180.0)-math.pi*0.5 panRate2 = (1 + self.mx - self.panZoneSize) * (self.camDist / self.panRateDivisor) moveX = True # These four blocks check to see if the mouse cursor is close enough to the edge of the screen to start panning and then # perform part of the math necessary to find the new camera position. Once again, the math is a bit above my head, so # I can't properly explain it. These blocks also set the move booleans to true so that the next lines will move the camera. if moveY: tempX = self.target.getX()+math.sin(angleradiansX1)*panRate1 tempX = self.clamp(tempX, self.panLimitsX.getX(), self.panLimitsX.getY()) self.target.setX(tempX) tempY = self.target.getY()-math.cos(angleradiansX1)*panRate1 tempY = self.clamp(tempY, self.panLimitsY.getX(), self.panLimitsY.getY()) self.target.setY(tempY) self.turnCameraAroundPoint(0,0) if moveX: tempX = self.target.getX()-math.sin(angleradiansX2)*panRate2 tempX = self.clamp(tempX, self.panLimitsX.getX(), self.panLimitsX.getY()) self.target.setX(tempX) tempY = self.target.getY()+math.cos(angleradiansX2)*panRate2 tempY = self.clamp(tempY, self.panLimitsY.getX(), self.panLimitsY.getY()) self.target.setY(tempY) self.turnCameraAroundPoint(0,0) # These two blocks finalize the math necessary to find the new camera position and apply the transformation to the # camera's TARGET. Then turnCameraAroundPoint is called with 0s for rotation, and it resets the camera position based # on the position of the target. The x and y values are clamped to the pan limits before they are applied. # print(self.target) self.mx=mpos.getX() self.my=mpos.getY() # The old mouse positions are updated to the current mouse position as the final step. return task.cont
class Mouse(DirectObject): def __init__(self, app): # local variables for mouse class self.app = app self.init_collide() self.has_mouse = None self.prev_pos = None self.pos = None self.drag_start = None self.hovered_object = None self.button2 = False self.mouseTask = taskMgr.add(self.mouse_task, 'mouseTask') self.task = None # set up event and response to this event self.accept('mouse1', self.mouse1) self.accept('mouse1-up', self.mouse1_up) # change the mouse to accept 'right-click' to rotate camera self.accept('mouse3', self.rotateCamera) self.accept('mouse3-up', self.stopCamera) self.accept('wheel_up', self.zoomIn) self.accept('wheel_down', self.zoomOut) # set up the collision for object def init_collide(self): # why the heck he import within method from pandac.PandaModules import CollisionTraverser, CollisionNode from pandac.PandaModules import CollisionHandlerQueue, CollisionRay # init and import collision for object self.cTrav = CollisionTraverser('MousePointer') self.cQueue = CollisionHandlerQueue() self.cNode = CollisionNode('MousePointer') self.cNodePath = base.camera.attachNewNode(self.cNode) self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) self.cRay = CollisionRay() self.cNode.addSolid(self.cRay) self.cTrav.addCollider(self.cNodePath, self.cQueue) # by the collision methods mouse is able to find out which tile mouse is at def find_object(self): if self.app.world.nodePath: self.cRay.setFromLens(base.camNode, self.pos.getX(), self.pos.getY()) self.cTrav.traverse(self.app.world.terrain.nodePath) if self.cQueue.getNumEntries() > 0: self.cQueue.sortEntries() return self.cQueue.getEntry(0).getIntoNodePath() return None # setting task for mouse def mouse_task(self, task): action = task.cont # if the current tile has a mouse point to this self.has_mouse = base.mouseWatcherNode.hasMouse() if self.has_mouse: self.pos = base.mouseWatcherNode.getMouse() if self.prev_pos: self.delta = self.pos - self.prev_pos else: self.delta = None if self.task: action = self.task(task) else: self.pos = None if self.pos: self.prev_pos = Point2(self.pos.getX(), self.pos.getY()) return action # when mouse hover over this hexagon def hover(self, task): if self.hovered_object: self.hovered_object.unhover() self.hovered_object = None if self.button2: self.camera_drag() hovered_nodePath = self.find_object() if hovered_nodePath: tile = hovered_nodePath.findNetTag('tile') if not tile.isEmpty(): tag = tile.getTag('tile') coords = tag.split(',') (x, y) = [int(n) for n in coords] # set the hovered target to be the corresponding hexagon on terrain self.hovered_object = self.app.world.terrain.rows[x][y] self.hovered_object.hover() character = hovered_nodePath.findNetTag('char') if not character.isEmpty(): tag = character.getTag('char') (team_index, char_id) = [int(n) for n in tag.split(',')] self.hovered_object = self.app.world.teams[team_index].characters_dict[char_id] self.hovered_object.hover() ghost = hovered_nodePath.findNetTag('ghost') if not ghost.isEmpty(): tag = ghost.getTag('ghost') (team_index, char_id) = [int(n) for n in tag.split(',')] for ghostInstance in self.app.ghosts: if (ghostInstance.team.index == team_index) and (ghostInstance.id == char_id): self.hovered_object = ghostInstance self.hovered_object.hover() return task.cont def mouse1(self): self.app.state.request('mouse1') def mouse1_up(self): self.app.state.request('mouse1-up') def camera_drag(self): if self.delta: old_heading = base.camera.getH() new_heading = old_heading - self.delta.getX() * 180 base.camera.setH(new_heading % 360) old_pitch = base.camera.getP() new_pitch = old_pitch + self.delta.getY() * 90 new_pitch = max(-90, min(-10, new_pitch)) base.camera.setP(new_pitch) def rotateCamera(self): self.button2 = True def stopCamera(self): self.button2 = False def zoomIn(self): lens = base.cam.node().getLens() size = lens.getFilmSize() if size.length() >= 75: lens.setFilmSize(size / 1.2) def zoomOut(self): lens = base.cam.node().getLens() size = lens.getFilmSize() if size.length() <= 250: lens.setFilmSize(size * 1.2)
class NodeRaycaster: def __init__(self, renderer): self.log = logging.getLogger('pano.raycaster') self.renderer = renderer #Stores the collisions of the camera ray with the cubemap self.collisionsQueue = None #Variables for setting up collision detection in Panda self.pickerNP = None self.pickerNode = None self.pickerRay = None self.traverser = None def initialize(self): """ To setup collision detection we need: a. A CollisionNode having a ray as its solid and placed at the position of the camera while also having the same orientation as the camera. b. A new nodepath placed in the scenegraph as an immediate child of the camera. It will be used to insert the collision node in the scenegraph. c. A CollisionRay for firing rays based on mouse clicks. d. A collisions traverser. e. A collisions queue where all found collisions will be stored for later processing. """ self.traverser = CollisionTraverser('Hotspots collision traverser') self.collisionsQueue = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.pickerNP = self.renderer.getCamera().attachNewNode( self.pickerNode) self.traverser.addCollider(self.pickerNP, self.collisionsQueue) def dispose(self): if self.pickerNP is not None: self.traverser.removeCollider(self.pickerNP) self.pickerNode.clearSolids() self.pickerNP.removeNode() def raycastWindow(self, x, y, returnAll=False): ''' Casts a camera ray, whose origin is implicitly defined by the given window coordinates, against the rendered scene returns information regarding the hit point, if any. @param x: The x window coordinate of the ray's origin in render2d space. @param y: The y window coordinate of the ray's origin in render2d space @param returnAll: If set to False then only the closest collided geometry is returned, otherwise all nodepaths whose collision nodes were intersected by the camera ray will be returned. @return: If returnAll was False, then a list containing a tuple of the form (topmost intersected NodePath, contact point Point3f). if returnAll was set to True, a list of tuples in the same form as above, one tuple for each intersection. None if no collision occurred. ''' #This makes the ray's origin the camera and makes the ray point #to the screen coordinates of the mouse self.pickerRay.setFromLens(self.renderer.getCamera().node(), x, y) #Check for collision only with the node self.traverser.traverse(self.renderer.getSceneRoot()) if self.collisionsQueue.getNumEntries() > 0: if not returnAll: self.collisionsQueue.sortEntries() cEntry = self.collisionsQueue.getEntry(0) if cEntry.hasInto(): return [(cEntry.getIntoNodePath(), cEntry.getSurfacePoint())] else: return None else: nodepaths = [] for i in xrange(self.collisionsQueue.getNumEntries()): cEntry = self.collisionsQueue.getEntry(i) if cEntry.hasInto(): # self.log.debug('adding collision into-nodepath: %s' % str(cEntry.getIntoNodePath())) intoNP = cEntry.getIntoNodePath() nodepaths.append( (intoNP, cEntry.getSurfacePoint(intoNP))) return nodepaths
class cWorld: def __init__( self ): # set background color base.setBackgroundColor( 0, 0, 0 ) # create target self.createTarget( ) # create boids self.createBoids( ) # setup camera self.setupCamera( ) # setup lights self.setupLights( ) # setup collision detection self.setupCollision( ) # add task taskMgr.add( self.steer, 'steer' ) # steer task taskMgr.add( self.moveTarget, 'moveTarget' ) # mouse move target task def createBoids( self ): self.redBoid = cBoid( ) # create red boid # setup blue boid with model path, starting location, max force, and max speed self.redBoid.setup( 'assets/models/boid_one.egg', Vec3( 0.0, 0.0, 0.0 ), 4.0, 0.1 ) # create blue boid self.blueBoid = cBoid( ) # setup blue boid with model path, starting location, max force, and max speed self.blueBoid.setup( 'assets/models/boid_two.egg', Vec3( 0.0, 0.0, 0.0 ), 4.0, 1.0 ) def createTarget( self ): # load in model file self.target = loader.loadModel( 'assets/models/target.egg' ) # parent self.target.reparentTo( render ) # set location self.target.setPos( Vec3( 0.0, 0.0, 0.0 ) ) def setupCamera( self ): # disable auto controls base.disableMouse() # set position, heading, pitch, and roll camera.setPosHpr( Vec3( 0.0, -45.0, 45.0), Vec3( 0.0, -45.0, 0 ) ) def setupLights( self ): # create a point light plight = PointLight( 'plight' ) # set its color plight.setColor( VBase4( 1.0, 1.0, 1.0, 1 ) ) # attach the light to the render plnp = render.attachNewNode( plight ) # set position plnp.setPos( 0.0, 0.0, 2.0 ) # turn on light render.setLight( plnp ) def setupCollision( self ): # create collision traverser self.picker = CollisionTraverser( ) # create collision handler self.pq = CollisionHandlerQueue( ) # create collision node self.pickerNode = CollisionNode( 'mouseRay' ) # create collision node # attach new collision node to camera node self.pickerNP = camera.attachNewNode( self.pickerNode ) # attach collision node to camera # set bit mask to one self.pickerNode.setFromCollideMask( BitMask32.bit( 1 ) ) # set bit mask # create a collision ray self.pickerRay = CollisionRay( ) # create collision ray # add picker ray to the picker node self.pickerNode.addSolid( self.pickerRay ) # add the collision ray to the collision node # make the traverser know about the picker node and its even handler queue self.picker.addCollider( self.pickerNP, self.pq ) # add the colision node path and collision handler queue #self.picker.showCollisions( render ) # render or draw the collisions #self.pickerNP.show( ) # render picker ray # create col node self.colPlane = CollisionNode( 'colPlane' ) # add solid to col node plane self.colPlane.addSolid( CollisionPlane( Plane( Vec3( 0, 0, 1 ), Point3( 0, 0, 0 ) ) ) ) # attach new node to the render self.colPlanePath = render.attachNewNode( self.colPlane ) #self.colPlanePath.show( ) # render node # make the col plane look at the camera # this makes it alway look at the camera no matter the orientation # we need this because the ray nees to intersect a plane parallel # to the camera self.colPlanePath.lookAt( camera ) # prop up the col plane self.colPlanePath.setP( -45 ) # set bit mask to one # as I understand it, this makes all col nodes with bit mask one # create collisions while ignoring others of other masks self.colPlanePath.node( ).setIntoCollideMask( BitMask32.bit( 1 ) ) def steer( self, Task ): # seek after target self.redBoid.seek( Vec3( self.target.getPos( ) ) ) # run the algorithm self.redBoid.run( ) # arrive at the target self.blueBoid.arrive( Vec3( self.target.getPos( ) ) ) # run the algorithm self.blueBoid.run( ) return Task.cont # continue task def moveTarget( self, Task ): # traverse through the render tree self.picker.traverse( render ) # go through the queue of collisions for i in range( self.pq.getNumEntries( ) ): entry = self.pq.getEntry( i ) # get entry surfacePoint = entry.getSurfacePoint( render ) # get surface point of collision self.target.setPos( surfacePoint ) # set surface point to target's position if base.mouseWatcherNode.hasMouse( ): # if we have a mouse mpos = base.mouseWatcherNode.getMouse( ) # get the path to the mouse # shoot ray from camera # based on X & Y coordinate of mouse self.pickerRay.setFromLens( base.camNode, mpos.getX( ), mpos.getY( ) ) return Task.cont # continue task
class MousePicker(p3d.SingleTask): """ Class to represent a ray fired from the input camera lens using the mouse. """ def __init__(self, *args, **kwargs): p3d.SingleTask.__init__(self, *args, **kwargs) self.fromCollideMask = kwargs.pop('fromCollideMask', None) self.node = None self.collEntry = None # Create collision nodes self.collTrav = CollisionTraverser() #self.collTrav.showCollisions( render ) self.collHandler = CollisionHandlerQueue() self.pickerRay = CollisionRay() # Create collision ray pickerNode = CollisionNode(self.name) pickerNode.addSolid(self.pickerRay) pickerNode.setIntoCollideMask(BitMask32.allOff()) pickerNp = self.camera.attachNewNode(pickerNode) self.collTrav.addCollider(pickerNp, self.collHandler) # Create collision mask for the ray if one is specified if self.fromCollideMask is not None: pickerNode.setFromCollideMask(self.fromCollideMask) # Bind mouse button events eventNames = ['mouse1', 'control-mouse1', 'mouse1-up'] for eventName in eventNames: self.accept(eventName, self.FireEvent, [eventName]) def OnUpdate(self, task, x=None, y=None): # Update the ray's position if self.mouseWatcherNode.hasMouse(): mp = self.mouseWatcherNode.getMouse() x, y = mp.getX(), mp.getY() if x is None or y is None: return self.pickerRay.setFromLens(self.camera.node(), x, y) # Traverse the hierarchy and find collisions self.collTrav.traverse(self.rootNp) if self.collHandler.getNumEntries(): # If we have hit something, sort the hits so that the closest is first self.collHandler.sortEntries() collEntry = self.collHandler.getEntry(0) node = collEntry.getIntoNode() # If this node is different to the last node, send a mouse leave # event to the last node, and a mouse enter to the new node if node != self.node: if self.node is not None: messenger.send('%s-mouse-leave' % self.node.getName(), [self.collEntry]) messenger.send('%s-mouse-enter' % node.getName(), [collEntry]) # Send a message containing the node name and the event over name, # including the collision entry as arguments messenger.send('%s-mouse-over' % node.getName(), [collEntry]) # Keep these values self.collEntry = collEntry self.node = node elif self.node is not None: # No collisions, clear the node and send a mouse leave to the last # node that stored messenger.send('%s-mouse-leave' % self.node.getName(), [self.collEntry]) self.node = None def FireEvent(self, event): """ Send a message containing the node name and the event name, including the collision entry as arguments. """ if self.node is not None: messenger.send('%s-%s' % (self.node.getName(), event), [self.collEntry]) def GetFirstNodePath(self): """ Return the first node in the collision queue if there is one, None otherwise. """ if self.collHandler.getNumEntries(): collEntry = self.collHandler.getEntry(0) return collEntry.getIntoNodePath() return None
class World(DirectObject): def __init__(self): self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "shoot":0} base.win.setClearColor(Vec4(0,0,0,1)) # Post the instructions self.inst6 = addInstructions(0.95, "Mad Max's Revenge!") self.inst1 = addInstructions(0.90, "[ESC]: Quit") self.inst2 = addInstructions(0.85, "[a]: Left Turn") self.inst3 = addInstructions(0.80, "[d]: Right Turn") self.inst4 = addInstructions(0.75, "[w]: Drive Forward") self.inst4 = addInstructions(0.70, "[s]: Reverse") self.inst5 = addInstructions(0.65, "[mouse]: Fire Rocket") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. self.environ = loader.loadModel("Assets/Models/env") #models/environment self.environ.reparentTo(render) self.environ.setPos(0,0,0) self.sky = loader.loadModel("Assets/Models/sky") #models/environment self.sky.reparentTo(render) self.sky.setPos(0,0,0) # Create the main character, player playerStartPos = Point3(8,14,1) #self.environ.find("**/start_point").getPos() enemyStartPos = Point3(-7,-8,1) #self.environ.find("**/start_point").getPos() #~ print enemyStartPos enemyStartPos.addX(1.0) enemyStartPos.addY(1.0) #~ print enemyStartPos self.player = Actor("Assets/Models/player_model", {"drive":"Assets/Models/player_drive", "fire":"Assets/Models/player_turret", "drivefire":"Assets/Models/player_both"}) self.player.reparentTo(render) self.player.setScale(0.1) self.player.setPos(playerStartPos) #~ self.playerdrive=self.player.actorInterval("drive") #~ self.playerfire=self.player.actoraaaaaaaInterval("fire") #~ self.playerdrivefire=self.player.actorInterval("drivefire") # Create the enemy, Enemy self.enemy = Actor("Assets/Models/enemy_model", {"drive":"Assets/Models/enemy_drive", "fire":"Assets/Models/enemy_turret", "drivefire":"Assets/Models/enemy_both"}) self.enemy.reparentTo(render) self.enemy.setScale(0.1) tex = loader.loadTexture("Assets/Models/cartexture1.png") self.enemy.setTexture(tex, 1) self.enemy.setPos(enemyStartPos) self.enemyrockettiming = globalClock.getFrameTime() #print self.enemy.getCurrentAnim() #print self.enemy.getCurrentAnim() #~ self.enemydrive=self.enemy.actorInterval("drive") #~ self.enemyfire=self.enemy.actorInterval("fire") #~ self.enemydrivefire=self.enemy.actorInterval("drivefire") self.music = loader.loadMusic("Assets/Sound/music.mp3") SoundInterval(self.music).loop() audio3d.attachSoundToObject(EnemyRunning, self.enemy) audio3d.attachSoundToObject(EnemyIdling, self.enemy) backward = self.enemy.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() #self.enemy.setPos(self.enemy.getPos() - backward*(50)) #Set up the lighting self.playerleftlight=self.player.attachNewNode(Spotlight("playerheadleft")) self.playerleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.playerleftlight.node().setLens( PerspectiveLens() ) self.playerleftlight.node().getLens().setFov( 50, 50) self.playerleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.playerleftlight.node().setExponent( 60.0 ) self.playerleftlight.setPos(-1, -0.1, 1.5) self.playerleftlight.setHpr(180, -10, 0) render.setLight(self.playerleftlight) self.playerrightlight=self.player.attachNewNode(Spotlight("playerheadright")) self.playerrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.playerrightlight.node().setLens( PerspectiveLens() ) self.playerrightlight.node().getLens().setFov( 50, 50) self.playerrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.playerrightlight.node().setExponent( 60.0 ) self.playerrightlight.setPos(1, -0.1, 1.5) self.playerrightlight.setHpr(180, -10, 0) render.setLight(self.playerrightlight) self.playerlightson=1 self.enemyleftlight=self.enemy.attachNewNode(Spotlight("enemyheadleft")) self.enemyleftlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.enemyleftlight.node().setLens( PerspectiveLens() ) self.enemyleftlight.node().getLens().setFov( 50, 50) self.enemyleftlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.enemyleftlight.node().setExponent( 60.0 ) self.enemyleftlight.setPos(-1, -0.1, 1.5) self.enemyleftlight.setHpr(180, -10, 0) render.setLight(self.enemyleftlight) self.enemyrightlight=self.enemy.attachNewNode(Spotlight("enemyheadright")) self.enemyrightlight.node().setColor(Vec4(0.75, 0.75, 0.75, 1)) self.enemyrightlight.node().setLens( PerspectiveLens() ) self.enemyrightlight.node().getLens().setFov( 50, 50) self.enemyrightlight.node().setAttenuation( Vec3( 0.1, 0.005, 0.0 ) ) self.enemyrightlight.node().setExponent( 60.0 ) self.enemyrightlight.setPos(1, -0.1, 1.5) self.enemyrightlight.setHpr(180, -10, 0) render.setLight(self.enemyrightlight) self.enemylightson=1 self.spotlight=camera.attachNewNode(PointLight("spotlight")) #self.spotlight.setPos(0, 3, 0.5) #self.spotlight.setHpr(0, 0, 0) self.spotlight.node().setColor(Vec4(1, 1, 1, 1)) #self.spotlight.node().setLens( PerspectiveLens() ) #self.spotlight.node().getLens().setFov( 180, 120) self.spotlight.node().setAttenuation( Vec3( 1, 0, 0.05 )) #self.spotlight.node().setExponent( 60.0 ) render.setLight(self.spotlight) self.playerlight=self.player.attachNewNode(PointLight("spotlight")) self.playerlight.node().setColor(Vec4(1, 1, 1, 1)) #self.spotlight.node().setLens( PerspectiveLens() ) #self.spotlight.node().getLens().setFov( 180, 120) self.playerlight.node().setAttenuation( Vec3( 1, 0, 0.05 )) #self.spotlight.node().setExponent( 60.0 ) render.setLight(self.playerlight) self.ambientlight=self.sky.attachNewNode(AmbientLight("ambientLight")) self.ambientlight.node().setColor(Vec4(1, 1, 1, 1)) self.sky.setLight(self.ambientlight) # Create a floater object. We use the "floater" as a temporary # variable in a variety of calculations. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("a", self.setKey, ["left",1]) self.accept("d", self.setKey, ["right",1]) self.accept("w", self.setKey, ["forward",1]) self.accept("s", self.setKey, ["backward",1]) self.accept("a-up", self.setKey, ["left",0]) self.accept("d-up", self.setKey, ["right",0]) self.accept("w-up", self.setKey, ["forward",0]) self.accept("s-up", self.setKey, ["backward",0]) self.accept("l", self.playerLights,[]) self.accept("mouse1", self.setKey, ["shoot", 1]) self.accept("mouse1-up", self.setKey, ["shoot", 0]) #self.shootRocketshootRocket taskMgr.add(self.playerMove,"moveTask") taskMgr.add(self.enemyMove,"moveTask") taskMgr.add(self.shoot,"shootTask") taskMgr.add(self.rocketCollision,"rocketCollision") # Game state variables self.prevtime = 0 self.isMoving = False self.prevShotTime = 0 self.prevEnemyMoveTime = 0 # Set up the camera base.disableMouse() base.camera.setPos(self.player.getX(),self.player.getY()+10,2) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above player's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.playerGroundRay = CollisionRay() self.playerGroundRay.setOrigin(0,0,1000) self.playerGroundRay.setDirection(0,0,-1) self.playerGroundCol = CollisionNode('playerRay') self.playerGroundCol.addSolid(self.playerGroundRay) self.playerGroundCol.setFromCollideMask(BitMask32.bit(3)) self.playerGroundCol.setIntoCollideMask(BitMask32.allOff()) self.playerGroundColNp = self.player.attachNewNode(self.playerGroundCol) self.playerGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0,0,1000) self.camGroundRay.setDirection(0,0,-1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(3)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.playerGroundColNp.show() #self.camGroundColNp.show() #Uncomment this line to show a visual representation of the #collisions occuring #self.cTrav.showCollisions(render) #Code for Enemy player self.enemyGroundRay = CollisionRay() self.enemyGroundRay.setOrigin(0,0,1000) self.enemyGroundRay.setDirection(0,0,-1) self.enemyGroundCol = CollisionNode('enemyRay') self.enemyGroundCol.addSolid(self.enemyGroundRay) self.enemyGroundCol.setFromCollideMask(BitMask32.bit(3)) self.enemyGroundCol.setIntoCollideMask(BitMask32.allOff()) self.enemyGroundColNp = self.enemy.attachNewNode(self.enemyGroundCol) self.enemyGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.enemyGroundColNp, self.enemyGroundHandler) self.cRocketHandler = CollisionHandlerQueue() self.worldEdge = CollisionInvSphere(0, 0, 0, 50) cNode = CollisionNode("worldEdge") cNode.addSolid(self.worldEdge) cNode.setFromCollideMask(BitMask32.allOff()) cNode.setIntoCollideMask(BitMask32.allOn()) self.worldEdgeNp=self.environ.attachNewNode(cNode) #self.cTrav.addCollider(self.worldEdgeNp, self.cRocketHandler) #cNP = render.attachNewNode(cNode) cNode2 = CollisionNode("wall") cNode2.addSolid(CollisionPlane(Plane(Vec3(-1,0,0), Point3(22.5,0,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(1,0,0), Point3(-22.5,0,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(0,-1,0), Point3(0,22.5,0)))) cNode2.addSolid(CollisionPlane(Plane(Vec3(0,1,0), Point3(0,-22.5,0)))) cNode2.setFromCollideMask(BitMask32.allOff()) cNode2.setIntoCollideMask(BitMask32.allOn()) cNP2=self.environ.attachNewNode(cNode2) self.picker = CollisionTraverser() #Make a traverser self.pq = CollisionHandlerQueue() #Make a handler #Make a collision node for our picker ray self.pickerNode = CollisionNode('mouseRay') #Attach that node to the camera since the ray will need to be positioned #relative to it self.pickerNP = camera.attachNewNode(self.pickerNode) #Everything to be picked will use bit 1. This way if we were doing other #collision we could seperate it self.pickerNode.setFromCollideMask(BitMask32.allOn()) self.pickerRay = CollisionRay() #Make our ray self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node #Register the ray as something that can cause collisions self.picker.addCollider(self.pickerNP, self.pq) self.playerrocket = None self.enemyrocket = None self.enemyTurn = 0 self.enemyDestAng = 180 self.enemyHp = 3 self.playerHp = 3 #Collisions self.setupCollisions() self.playermoving = False #setup hud self.drawHud() def drawHud(self): #Player OnscreenText(text="Player Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.9), align=TextNode.ALeft, scale = .08) self.playerHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .84), scale = .12) self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) #Enemy OnscreenText(text="Enemy Health", style=1, fg=(1,1,1,1), pos=(0.85, 0.7), align=TextNode.ALeft, scale = .08) self.enemyHealthImg = OnscreenImage(image = 'Assets/Images/healthFull.png', pos = (1.05, 0, .64), scale = .12) self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) def updateGui(self): #player bar if self.playerHp == 2: self.playerHealthImg.setImage('Assets/Images/healthMedium.png') self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) elif self.playerHp == 1: self.playerHealthImg.setImage('Assets/Images/healthLow.png') self.playerHealthImg.setTransparency(TransparencyAttrib.MAlpha) #enemy bar if self.enemyHp == 2: self.enemyHealthImg.setImage('Assets/Images/healthMedium.png') self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) elif self.enemyHp == 1: self.enemyHealthImg.setImage('Assets/Images/healthLow.png') self.enemyHealthImg.setTransparency(TransparencyAttrib.MAlpha) def setupCollisions(self): #player sphere cPlayerSphere = CollisionSphere(Point3(0, 0, .5), 10) cPlayerNode = CollisionNode("Player") cPlayerNode.addSolid(cPlayerSphere) cPlayerNode.setFromCollideMask(BitMask32.bit(4)) cPlayerNode.setIntoCollideMask(BitMask32(20)) cPlayerNP = self.player.attachNewNode(cPlayerNode) self.cTrav.addCollider(cPlayerNP, self.playerGroundHandler) #self.cTrav.addCollider(cPlayerNP, self.cRocketHandler) #cPlayerNP.show() #enemy sphere cEnemySphere = CollisionSphere(Point3(0, 0, .5), 10) cEnemyNode = CollisionNode("Enemy") cEnemyNode.addSolid(cEnemySphere) cEnemyNode.setFromCollideMask(BitMask32.bit(4)) cEnemyNode.setIntoCollideMask(BitMask32(18)) cEnemyNP = self.enemy.attachNewNode(cEnemyNode) self.cTrav.addCollider(cEnemyNP, self.enemyGroundHandler) #self.cTrav.addCollider(cEnemyNP, self.cRocketHandler) #cEnemyNP.show() def rocketCollision(self, task): """Check for rocket collisions with players and objects""" toRemove = [] for i in range(self.cRocketHandler.getNumEntries()): entry = self.cRocketHandler.getEntry(i) #~ print entry if entry.getFromNode().getName() == "PlayerRocket" and entry.getIntoNode().getName() == "Enemy": self.enemyHp -= 1 self.updateGui() if self.enemyHp == 0: print "Victory!" OnscreenText(text="Victory!", style=2, fg=(0,1,0,1), pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0)) self.playerHp += 5 #LerpFunc(end_game, fromData = 0, toData = 1, duration = 3.0, #blendType = 'noBlend', extraArgs = [], name = None) taskMgr.remove("moveTask") taskMgr.remove("shootTask") #print "GAME OVER, YOU WIN" #sys.exit(0) elif entry.getFromNode().getName() == "EnemyRocket" and entry.getIntoNode().getName() == "Player": self.playerHp -= 1 self.updateGui() if self.playerHp == 0: #~ print "GAME OVER, YOU LOSE" OnscreenText(text="Failure!", style=2, fg=(1,0,0,1), pos=(-0.6, 0), align=TextNode.ALeft, scale = .5, shadow=(0,0,0,0)) self.enemyHp += 5 taskMgr.remove("moveTask") taskMgr.remove("shootTask") #Add to remove list if entry.getFromNodePath() not in toRemove: toRemove.append(entry.getFromNodePath()) #remove for np in toRemove: if np.getNode(0).getName() == "PlayerRocket": if self.playerrocket: self.playerrocket.kill_light() #~ print "BOOM!, PLAYER ROCKET EXPLODED" BoomSound.play() RocketFire.stop() Explosion.Explosion(self.playerrocket.rocket.getPos(), render) self.playerrocket = None np.getParent().remove() else: if self.enemyrocket: self.enemyrocket.kill_light() #~ print "BOOM!, ENEMY ROCKET EXPLODED" BoomSound.play() RocketFire.stop() Explosion.Explosion(self.enemyrocket.rocket.getPos(), render) self.enemyrocket = None np.getParent().remove() self.cRocketHandler.clearEntries() return Task.cont def shootPlayerRocket(self): """Shoot a player rocket""" #Check to see if we can access the mouse. We need it to do anything else if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() #Set the position of the ray based on the mouse position self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY()) #Do the actual collision pass pickerpoint=Point3(0,0,0) self.picker.traverse(render) for i in range(self.pq.getNumEntries()): entry = self.pq.getEntry(i) if entry.getFromNode().getName() == "mouseRay" and entry.getIntoNode().getName()=="terrain": pickerpoint=entry.getSurfacePoint(render) direction=pickerpoint-Point3(self.player.getX(), self.player.getY(), self.player.getZ()+0.5) #~ if self.playerrocket is None: #~ angle = math.radians(self.player.getH()) playerpos=self.player.getPos() self.playerrocket = Rocket.Rocket(Point3(playerpos.getX(), playerpos.getY(), playerpos.getZ()+0.5), direction, "PlayerRocket", render) self.playerrocket.setupCollision(self.cTrav, self.cRocketHandler) RocketFire.play() if self.player.getCurrentAnim()=="drive": self.player.play("drivefire") else: self.player.play("fire") def shootEnemyRocket(self): """Shoot a enemy rocket""" if not (self.enemyrocket) and self.enemyrockettiming <= globalClock.getFrameTime() : #~ angle = math.radians(self.enemy.getH()) #~ self.enemyrocket = Rocket.Rocket(self.enemy.getPos(), angle, "EnemyRocket", render) #~ self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler) direction = self.player.getPos() - self.enemy.getPos() enemyPos = self.enemy.getPos() self.enemyrocket = Rocket.Rocket(enemyPos + Point3(0,0,.5),direction,"EnemyRocket",render) self.enemyrocket.setupCollision(self.cTrav, self.cRocketHandler) RocketFire.play() self.enemy.play("drivefire") self.enemyrockettiming = globalClock.getFrameTime() + 2.0 #Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value def shoot(self, task): elapsed = task.time - self.prevShotTime if(self.keyMap["shoot"]!=0 and elapsed > 1): self.shootPlayerRocket() self.prevShotTime = task.time return Task.cont def playerLights(self): if self.playerlightson: self.playerleftlight.node().setColor(Vec4(0,0,0,1)) self.playerrightlight.node().setColor(Vec4(0,0,0,1)) self.playerlightson=0 else: self.playerleftlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.playerrightlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.playerlightson=1 def enemyLights(self): if self.enemylightson: self.enemyleftlight.node().setColor(Vec4(0,0,0,1)) self.enemyrightlight.node().setColor(Vec4(0,0,0,1)) self.enemylightson=0 else: self.enemyleftlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.enemyrightlight.node().setColor(Vec4(0.75,0.75,0.75,1)) self.enemylightson=1 def enemyMove(self, task): elapsed = task.time - self.prevEnemyMoveTime startpos = self.enemy.getPos() #Calculate distance to the enemy distvec = self.player.getPos() - self.enemy.getPos() distvec.setZ(0) dist = distvec.length() backward = self.enemy.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() #Drive! if self.enemy.getCurrentAnim() is None: self.enemy.loop("drive") #Find the vector from the enemy to the player, then find the angle of that vector vec = self.enemy.getPos() - self.player.getPos() angle = math.degrees(math.atan2(vec.getX(), vec.getY())) #Find the angle left to turn according to the enemy's current angle angleToPlayer = (-self.enemy.getH() - angle) % 360 #Fire rocket if within 60 degree arc of player #~ print angleToPlayer if angleToPlayer < 30 or angleToPlayer > 330: self.shootEnemyRocket() #AI control code starts here #enemyTurn is zero for heading straight, -1 to turn full left, +1 to turn full right #Turning rate is currently maxed at 100 degrees per second #drivedir is for forward (1) or backward (-1) #Wall avoidance stuff enemyTurn=0 myh=self.player.getH()%360 print myh if abs(self.enemy.getPos().getX())>19 or abs(self.enemy.getPos().getX())>19: drivedir=-1.0 else: drivedir=1.0 if self.playerrocket: playerpos=self.player.getPos() if playerpos.getX()>12.5 and (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180) print 1 elif playerpos.getX()<12.5 and not (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180) print 2 elif playerpos.getY()>12.5 and myh<180: self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90) print 3 elif playerpos.getY()<12.5 and myh>180: self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270) print 4 elif self.enemy.getPos().getX()>12.5 and (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(self.enemy.getX()-12.5))*sign(myh-180) print 5 elif self.enemy.getPos().getX()<-12.5 and not (myh<90 or myh>270): self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getX()))*sign(myh-180) print 6 elif self.enemy.getPos().getY()>12.5 and myh<180: self.enemyTurn = -(0.5+0.05*(self.enemy.getY()-12.5))*sign(myh-90) print 7 elif self.enemy.getPos().getY()<-12.5 and myh>180: self.enemyTurn = -(0.5+0.05*(12.5-self.enemy.getY()))*sign(myh-270) print 8 elif not(math.fabs(self.enemyDestAng - angleToPlayer) > 3 and math.fabs(self.enemyDestAng - angleToPlayer) < 357): print 9 self.enemyTurn = 0 else: print 10 if dist > 5: self.enemyDestAng = 0 if angleToPlayer > 1 and angleToPlayer <= 180: #Turn left self.enemyTurn = -0.5 elif angleToPlayer > 180 and angleToPlayer < 359: #Turn right self.enemyTurn = 0.5 elif dist < 5: self.enemyDestAng = 180 if angleToPlayer >= 0 and angleToPlayer < 179: #Turn left self.enemyTurn = 0.5 elif angleToPlayer > 181 and angleToPlayer < 360: #Turn right self.enemyTurn = -0.5 #Replace later #drivedir=1.0 #End of AI code #Enemy always tries to move forward, regardless of where the player is self.enemy.setPos(self.enemy.getPos() - backward*(drivedir*elapsed*5)) self.enemy.setH(self.enemy.getH() - elapsed *100.0*self.enemyTurn) EnemyRunning.play() self.cTrav.traverse(render) entries = [] terrain = [] for i in range(self.enemyGroundHandler.getNumEntries()): entry = self.enemyGroundHandler.getEntry(i) if entry.getFromNode().getName() == "enemyRay": terrain.append(entry) elif entry.getFromNode().getName() == "Enemy" and entry.getIntoNode().getName() != "terrain": entries.append(entry) terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0): self.enemy.setPos(startpos) if (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"): self.enemy.setZ(terrain[0].getSurfacePoint(render).getZ()+.5) else: self.enemy.setPos(startpos) # Store the task time and continue. self.prevEnemyMoveTime = task.time return Task.cont # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def playerMove(self, task): elapsed = task.time - self.prevtime base.camera.lookAt(self.player) camright = base.camera.getNetTransform().getMat().getRow3(0) camright.normalize() # save player's initial position so that we can restore it, # in case he falls off the map or runs into something. startpos = self.player.getPos() # If a move-key is pressed, move player in the specified direction. if ((self.keyMap["left"]!=0) & (self.keyMap["forward"]!=0)): self.player.setH(self.player.getH() + elapsed*50) Idling.stop() Running.play() self.playermoving = True elif((self.keyMap["left"]!=0) & (self.keyMap["backward"]!=0)): self.player.setH(self.player.getH() - elapsed*50) Idling.stop() Running.play() self.playermoving = True if ((self.keyMap["right"]!=0) & (self.keyMap["forward"]!=0)): self.player.setH(self.player.getH() - elapsed*50) Idling.stop() Running.play() self.playermoving = True elif ((self.keyMap["right"]!=0) & (self.keyMap["backward"]!=0)): self.player.setH(self.player.getH() + elapsed*50) Idling.stop() Running.play() self.playermoving = True if (self.keyMap["forward"]!=0): backward = self.player.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() self.player.setPos(self.player.getPos() - backward*(elapsed*5)) Running.play() Idling.stop() self.playermoving = True if (self.keyMap["backward"]!=0): backward = self.player.getNetTransform().getMat().getRow3(1) backward.setZ(0) backward.normalize() self.player.setPos(self.player.getPos() + backward*(elapsed*5)) Idling.stop() Running.play() self.playermoving = True if (self.keyMap["backward"]==0 and self.keyMap["forward"]==0 and self.keyMap["left"]==0 and self.keyMap["right"]==0): Running.stop() Idling.play() self.playermoving = False if self.player.getCurrentAnim()=="drive": self.player.stop() #print "STOP MOVING" #DRIVE! if self.player.getCurrentAnim() is None and self.playermoving: self.player.loop("drive") #print "DRIVE ON!" dist = 10.0 angle = math.radians(self.player.getH()) + math.pi dx = dist * math.sin(angle) dy = dist * -math.cos(angle) dest = Point3(self.player.getX() + dx, self.player.getY() + dy, self.player.getZ()+1) base.camera.setPos(dest) # If player is moving, loop the run animation. # If he is standing still, stop the animation. if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0): if self.isMoving is False: #self.player.loop("run") self.isMoving = True else: if self.isMoving: #self.player.stop() #self.player.pose("walk",5) self.isMoving = False # If the camera is too far from player, move it closer. # If the camera is too close to player, move it farther. camvec = self.player.getPos() - base.camera.getPos() camvec.setZ(0) camdist = camvec.length() camvec.normalize() if (camdist > 20.0): base.camera.setPos(base.camera.getPos() + camvec*(camdist-20)) camdist = 20.0 if (camdist < 10.0): base.camera.setPos(base.camera.getPos() - camvec*(10-camdist)) camdist = 10.0 # Now check for collisions. self.cTrav.traverse(render) # Adjust player's Z coordinate. If player's ray hit terrain, # update his Z. If it hit anything else, or didn't hit anything, put # him back where he was last frame. terrain = [] entries = [] for i in range(self.playerGroundHandler.getNumEntries()): entry = self.playerGroundHandler.getEntry(i) if entry.getFromNode().getName() == "playerRay": terrain.append(entry) elif entry.getFromNode().getName() == "Player" and entry.getIntoNode().getName() != "terrain": entries.append(entry) terrain.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0): self.player.setPos(startpos) elif (len(terrain)>0) and (terrain[0].getIntoNode().getName() == "terrain"): self.player.setZ(terrain[0].getSurfacePoint(render).getZ()+.5) else: self.player.setPos(startpos) # Keep the camera at one foot above the terrain, # or two feet above player, whichever is greater. entries = [] for i in range(self.camGroundHandler.getNumEntries()): entry = self.camGroundHandler.getEntry(i) entries.append(entry) entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"): base.camera.setZ(entries[0].getSurfacePoint(render).getZ()+ 1.5) if (base.camera.getZ() < self.player.getZ() + 2.5): base.camera.setZ(self.player.getZ() + 2.5) # The camera should look in player's direction, # but it should also try to stay horizontal, so look at # a floater which hovers above player's head. self.floater.setPos(self.player.getPos()) self.floater.setZ(self.floater.getZ()+1) base.camera.lookAt(self.floater) # Store the task time and continue. self.prevtime = task.time return Task.cont
class NavMesh(object): notify = directNotify.newCategory("NavMesh") def __init__(self, filepath=None, filename=None): if filename is not None: self._initFromFilename(filepath, filename) def initFromPolyData(self, polyToVerts, vertToPolys, polyToAngles, vertexCoords, environmentHash): ''' Initialize the mesh from a set of polygons. polyToVerts: Dictionary mapping a polygon ID to a set of N vertex IDs vertToPolys: Dictionary mapping a vertex ID to a set of poly IDs (of every poly that includes it) polyToAngles: Dictionary mapping a polygon ID to a set of N angles (in vertex order) vertexCoords: Dictionary mapping a vertex ID to the coordinates of the vertex in worldspace environmentHash: Hash value derived from the same collision geometry as the other arguments. See AreaMapper.getEnvironmentHash(). ''' self.polyToVerts = polyToVerts self.vertToPolys = vertToPolys self.polyToAngles = polyToAngles self.vertexCoords = vertexCoords self.environmentHash = environmentHash self.connectionLookup = {} self.connections = [] self._discoverInitialConnectivity() self.optimizeMesh() def visualize(self, parentNodePath, highlightVerts=[], pathVerts=[], visitedVerts=[]): ''' XXX Should move this into a product-specific class. ''' gFormat = GeomVertexFormat.getV3cp() self.visVertexData = GeomVertexData("OMGVERTEXDATA2", gFormat, Geom.UHDynamic) self.visVertexWriter = GeomVertexWriter(self.visVertexData, "vertex") self.visVertexColorWriter = GeomVertexWriter(self.visVertexData, "color") vertToWriterIndex = {} currIndex = 0 for v in self.vertexCoords.keys(): vertToWriterIndex[v] = currIndex x = self.vertexCoords[v][0] y = self.vertexCoords[v][1] z = self.vertexCoords[v][2] self.visVertexWriter.addData3f(x, y, z + 0.5) if v in highlightVerts: self.visVertexColorWriter.addData4f(1.0, 0.0, 0.0, 1.0) elif v in visitedVerts: self.visVertexColorWriter.addData4f(0.0, 0.0, 1.0, 1.0) else: self.visVertexColorWriter.addData4f(1.0, 1.0, 0.0, 1.0) currIndex += 1 pathOffsetIntoIndex = currIndex for v in pathVerts: self.visVertexWriter.addData3f(v[0], v[1], v[2] + 0.5) self.visVertexColorWriter.addData4f(0.0, 1.0, 0.0, 1.0) currIndex += 1 lines = GeomLinestrips(Geom.UHStatic) for p in self.polyToVerts.keys(): for v in self.polyToVerts[p]: lines.addVertex(vertToWriterIndex[v]) lines.addVertex(vertToWriterIndex[self.polyToVerts[p][0]]) lines.closePrimitive() if len(pathVerts) > 0: for i in xrange(len(pathVerts)): lines.addVertex(pathOffsetIntoIndex + i) lines.closePrimitive() self.visGeom = Geom(self.visVertexData) self.visGeom.addPrimitive(lines) self.visGN = GeomNode("NavMeshVis") self.visGN.addGeom(self.visGeom) self.visNodePath = parentNodePath.attachNewNode(self.visGN) self.visNodePath.setTwoSided(True) def _discoverInitialConnectivity(self): print "Building initial connectivity graph..." for pId in self.polyToVerts.keys(): verts = self.polyToVerts[pId] numVerts = len(verts) candidates = [] neighborPolys = [] for v in verts: candidates += [ p for p in self.vertToPolys[v] if (p not in candidates) and (p != pId) ] for vNum in xrange(numVerts): neighbor = [p for p in candidates if ((verts[vNum] in self.polyToVerts[p]) and \ (verts[(vNum+1)%numVerts] in self.polyToVerts[p]))] if len(neighbor) == 0: neighborPolys.append(None) elif len(neighbor) == 1: neighborPolys.append(neighbor[0]) else: raise "Two neighbors found for the same edge?!?!" self.connectionLookup[pId] = neighborPolys # --------- Begin stitching code --------- def _attemptToMergePolys(self, polyA, polyB): newVerts = [] newAngles = [] newConnections = [] vertsA = self.polyToVerts[polyA] vertsB = self.polyToVerts[polyB] lenA = len(vertsA) lenB = len(vertsB) anglesA = self.polyToAngles[polyA] anglesB = self.polyToAngles[polyB] sharedVerts = [v for v in vertsA if (v in vertsB)] locA = 0 while vertsA[locA] not in sharedVerts: locA += 1 while vertsA[locA] in sharedVerts: locA = (locA - 1) % lenA locA = (locA + 1) % lenA CCWmost = vertsA[locA] CCWmostLocA = locA while vertsA[locA] in sharedVerts: locA = (locA + 1) % lenA locA = (locA - 1) % lenA CWmost = vertsA[locA] CWmostLocA = locA # Convexity Check. # Verify that removing the edge preserves convexity and bail out if not. locA = 0 locB = 0 while vertsA[locA] != CCWmost: locA += 1 while vertsB[locB] != CCWmost: locB += 1 CCWmostAngleSum = anglesA[locA] + anglesB[locB] CCWmostLocB = locB if CCWmostAngleSum > 180: return False locA = 0 locB = 0 while vertsA[locA] != CWmost: locA += 1 while vertsB[locB] != CWmost: locB += 1 CWmostAngleSum = anglesA[locA] + anglesB[locB] if CWmostAngleSum > 180: return False # We've found the CW-most vert of the shared edge. # Now walk A clockwise until we hit the CCW-most vert of the shared edge. newVerts.append(CWmost) newAngles.append(CWmostAngleSum) newConnections.append(self.connectionLookup[polyA][locA]) locA = (locA + 1) % lenA while vertsA[locA] != CCWmost: newVerts.append(vertsA[locA]) newAngles.append(anglesA[locA]) newConnections.append(self.connectionLookup[polyA][locA]) locA = (locA + 1) % lenA # Now we've hit the CCW-most vert of the shared edge. # Walk B clockwise until we get back to the CW-most vert of the shared edge. locB = CCWmostLocB newVerts.append(CCWmost) newAngles.append(CCWmostAngleSum) neighbor = self.connectionLookup[polyB][locB] newConnections.append(neighbor) if neighbor is not None: for i in xrange(len(self.connectionLookup[neighbor])): if self.connectionLookup[neighbor][i] == polyB: self.connectionLookup[neighbor][i] = polyA locB = (locB + 1) % lenB while vertsB[locB] != CWmost: newVerts.append(vertsB[locB]) newAngles.append(anglesB[locB]) neighbor = self.connectionLookup[polyB][locB] newConnections.append(neighbor) if neighbor is not None: for i in xrange(len(self.connectionLookup[neighbor])): if self.connectionLookup[neighbor][i] == polyB: self.connectionLookup[neighbor][i] = polyA locB = (locB + 1) % lenB # We've added every vertex, its proper angle, and connectivity info # to the new polygon. Now replace A with the new guy and remove B. self.polyToVerts[polyA] = newVerts self.polyToAngles[polyA] = newAngles self.connectionLookup[polyA] = newConnections # Make sure we have vertex->poly pointers for all the new verts we added to A. for v in newVerts: if polyA not in self.vertToPolys[v]: self.vertToPolys[v].append(polyA) # Clean up all of B's old vertices. for v in vertsB: self.vertToPolys[v].remove(polyB) if len(self.vertToPolys[v]) == 0: # No one's using this vertex anymore, remove it del self.vertToPolys[v] del self.vertexCoords[v] del self.polyToVerts[polyB] del self.polyToAngles[polyB] del self.connectionLookup[polyB] return True def _attemptToGrowPoly(self, pId): for neighbor in self.connectionLookup.get(pId, []): if (neighbor is not None) and self._attemptToMergePolys( pId, neighbor): return True return False def _growEachPolyOnce(self): grewAtLeastOne = False for pId in self.connectionLookup.keys(): if self._attemptToGrowPoly(pId): grewAtLeastOne = True return grewAtLeastOne def optimizeMesh(self): ''' Takes a mesh that is already functionally complete and optimizes it for better performance. Reduces poly count and cuts out redundant vertices. Also compacts the polygon IDs into a contiguous range from 0 to N. No need to do the same for vertex IDs yet. ''' '''print "Stitching polygons: %s -> " % (len(self.polyToVerts)), orig = len(self.polyToVerts) numPasses = 1 while self._growEachPolyOnce(): print "%s -> " % (len(self.polyToVerts)), numPasses += 1 print "Done!\nPoly count reduced to %0.1f%% of original." % (len(self.polyToVerts)/float(orig)*100.0)''' self._pruneExtraVerts() self._compactPolyIds() self.numNodes = len(self.connections) biggest = 0 biggestPoly = -1 for p in self.polyToVerts: if len(self.polyToVerts[p]) > biggest: biggest = len(self.polyToVerts[p]) biggestPoly = p print "Most verts in a single poly: ", biggest assert biggest < 256 def _cleanPoly(self, polyId): verts = self.polyToVerts[polyId] angles = self.polyToAngles[polyId] neighbors = self.connectionLookup[polyId] numVerts = len(verts) newVerts = [] newAngles = [] newNeighbors = [] for i in xrange(numVerts): if (angles[i] != 180) or \ (len(self.vertToPolys.get(verts[i],[])) > 2) or \ (neighbors[i] != neighbors[(i-1)%numVerts]): # Keep vertex newVerts.append(verts[i]) newAngles.append(angles[i]) newNeighbors.append(neighbors[i]) else: # Remove vertex, this will happen twice so pop it self.vertToPolys.pop(verts[i], None) self.vertexCoords.pop(verts[i], None) if len(verts) != len(newVerts): self.polyToVerts[polyId] = newVerts self.polyToAngles[polyId] = newAngles self.connectionLookup[polyId] = newNeighbors assert len(newVerts) < 256 def _pruneExtraVerts(self): print "Pruning extra vertices..." print "Starting verts: %s" % len(self.vertToPolys) for polyId in self.connectionLookup.keys(): self._cleanPoly(polyId) print "Ending verts: %s" % len(self.vertToPolys) def _compactPolyIds(self): polyList = self.polyToVerts.keys() polyList.sort() oldToNewId = {None: None} newPolyToVerts = {} newPolyToAngles = {} self.connections = [] currId = 0 for oldId in polyList: oldToNewId[oldId] = currId self.connections.append([]) currId += 1 for oldId in polyList: newPolyToVerts[oldToNewId[oldId]] = self.polyToVerts[oldId] newPolyToAngles[oldToNewId[oldId]] = self.polyToAngles[oldId] #self.connections[oldToNewId[oldId]] = [] for edgeNum in xrange(len(self.connectionLookup[oldId])): self.connections[oldToNewId[oldId]].append( oldToNewId[self.connectionLookup[oldId][edgeNum]]) self.polyToVerts = newPolyToVerts self.polyToAngles = newPolyToAngles del self.connectionLookup # --------- Begin pathfinding code --------- def _findCentroid(self, polyId): verts = self.polyToVerts[polyId] numVerts = len(verts) x = 0 y = 0 z = 0 for v in verts: x += self.vertexCoords[v][0] y += self.vertexCoords[v][1] z += self.vertexCoords[v][2] x /= numVerts y /= numVerts z /= numVerts return (x, y, z) ## def _estimateDistanceBetweenPolys(self, polyA, polyB): ## centroidA = self._findCentroid(polyA) ## centroidB = self._findCentroid(polyB) ## dx = centroidA[0] - centroidB[0] ## dy = centroidA[1] - centroidB[1] ## dz = centroidA[2] - centroidB[2] ## return math.sqrt(dx*dx + dy*dy + dz*dz) def _walkToNeighbor(self, currPoly, neighborPoly): currVerts = self.polyToVerts[currPoly] neighborVerts = self.polyToVerts[neighborPoly] lenCurr = len(currVerts) sharedVerts = [v for v in currVerts if (v in neighborVerts)] loc = 0 while currVerts[loc] not in sharedVerts: loc += 1 while currVerts[loc] in sharedVerts: loc = (loc - 1) % lenCurr loc = (loc + 1) % lenCurr CCWmost = currVerts[loc] CCWmostLoc = loc while currVerts[loc] in sharedVerts: loc = (loc + 1) % lenCurr loc = (loc - 1) % lenCurr CWmost = currVerts[loc] CCWmostCoords = self.vertexCoords[CCWmost] CWmostCoords = self.vertexCoords[CWmost] # For now, walk to the midpoint of the connecting edge departingEdge = CCWmostLoc # Don't need this with goal->start search neighborsEdge = 0 while self.connections[neighborPoly][neighborsEdge] != currPoly: neighborsEdge += 1 return (neighborsEdge, ((CWmostCoords[0] + CCWmostCoords[0]) / 2.0, (CWmostCoords[1] + CCWmostCoords[1]) / 2.0, (CWmostCoords[2] + CCWmostCoords[2]) / 2.0)) ## def _remakePath(self,walkBack,currNode): ## if currNode in walkBack: ## p = self._remakePath(walkBack,walkBack[currNode]) ## return p + [currNode,] ## return [currNode,] ## def findRoute(self, startNode, goalNode): ## ''' ## So much love for A*. ## ''' ## nodeToF = {} ## nodeToG = {} ## nodeToH = {} ## walkBack = {} ## #nodeToEntryPoint = {} ## self.nodeToEntryPoint[startNode] = self._findCentroid(startNode) ## nodeToG[startNode] = 0 ## nodeToH[startNode] = self._estimateDistanceBetweenPolys(startNode,goalNode) ## nodeToF[startNode] = nodeToG[startNode] + nodeToH[startNode] ## closedSet = {} ## openSet = {} ## openQueue = PriQueue() # Priority = F score ## openSet[startNode] = 1 ## openQueue.push((nodeToF[startNode],startNode)) ## goalPoint = self._findCentroid(goalNode) ## while len(openSet) > 0: ## f,currNode = openQueue.pop(0) ## del openSet[currNode] ## self.aStarWasHere[currNode] = 1 ## if currNode == goalNode: ## return self._remakePath(walkBack,currNode) ## closedSet[currNode] = 1 ## currPoint = self.nodeToEntryPoint[currNode] ## for neighbor in self.connections[currNode]: ## if (neighbor is not None) and (neighbor not in closedSet): ## departingEdge,newEntryPoint = self._walkToNeighbor(currNode,currPoint,neighbor) ## newG = nodeToG[currNode] + math.sqrt((newEntryPoint[0] - currPoint[0])**2 + \ ## (newEntryPoint[1] - currPoint[1])**2 + \ ## (newEntryPoint[2] - currPoint[2])**2) ## gotHereFasterThanBefore = False ## if neighbor not in openSet: ## openSet[neighbor] = 1 ## gotHereFasterThanBefore = True ## elif newG < nodeToG[neighbor]: ## openQueue.remove((nodeToF[neighbor],neighbor)) ## gotHereFasterThanBefore = True ## if gotHereFasterThanBefore: ## walkBack[neighbor] = currNode ## self.nodeToEntryPoint[neighbor] = newEntryPoint ## nodeToH[neighbor] = math.sqrt((goalPoint[0] - newEntryPoint[0])**2 + \ ## (goalPoint[1] - newEntryPoint[1])**2 + \ ## (goalPoint[2] - newEntryPoint[2])**2) ## nodeToG[neighbor] = newG ## nodeToF[neighbor] = nodeToG[neighbor] + nodeToH[neighbor] ## openQueue.push((nodeToF[neighbor],neighbor)) ## raise "No path found! D:" def _findAllRoutesToGoal(self, goalNode): ''' Find the shortest path from ALL start nodes to the given goal node. (Djikstra) After running, self.pathData[startNode][goalNode] == outgoing edge from startNode to the next node for the given value of goalNode and ALL values of startNode. ''' nodeToG = {} walkBack = {} nodeDeparturePoint = {} nodeDeparturePoint[goalNode] = self._findCentroid(goalNode) nodeToG[goalNode] = 0 closedSet = {} openSet = {} openQueue = PriQueue() openSet[goalNode] = 1 openQueue.push((nodeToG[goalNode], goalNode)) walkBack[goalNode] = (0, goalNode) while len(openSet) > 0: f, currNode = openQueue.pop(0) del openSet[currNode] closedSet[currNode] = 1 currPoint = nodeDeparturePoint[currNode] for neighbor in self.connections[currNode]: if (neighbor is not None) and (neighbor not in closedSet): neighborsEdge, newPoint = self._walkToNeighbor( currNode, neighbor) newG = nodeToG[currNode] + math.sqrt((newPoint[0] - currPoint[0])**2 + \ (newPoint[1] - currPoint[1])**2 + \ (newPoint[2] - currPoint[2])**2) gotHereFasterThanBefore = False if neighbor not in openSet: openSet[neighbor] = 1 gotHereFasterThanBefore = True elif newG < nodeToG[neighbor]: openQueue.remove((nodeToG[neighbor], neighbor)) gotHereFasterThanBefore = True if gotHereFasterThanBefore: walkBack[neighbor] = (neighborsEdge, currNode) nodeDeparturePoint[neighbor] = newPoint nodeToG[neighbor] = newG openQueue.push((nodeToG[neighbor], neighbor)) for startNode in xrange(len(self.connections)): departingEdge = walkBack[startNode][0] assert self.pathData[startNode][goalNode] is None self.pathData[startNode][goalNode] = departingEdge def generatePathData(self, rowRange=None): ''' Entry point for path preprocessing. Solves all pairs shortest path for this mesh. Stores the result in self.pathData. SLOW. Expect 8-10 minutes on Port Royal alone. Currently runs Djikstra on every possible start node. There are faster approaches for APSP, but... ''' if rowRange is None: rowRange = (0, self.numNodes) self.initPathData() for goalNode in xrange(rowRange[0], rowRange[1]): self._findAllRoutesToGoal(goalNode) def createPathTable(self): ''' Takes a 2D array self.pathData and changes it in place. Each row is changed into a run-length encoded string. Then, feeds the data into a new PathTable instance. ''' for row in self.pathData: for val in row: if val == None: raise "Incomplete path data!" shortestPathLookup = self.pathData self.pathData = [] # Run-Length Encode the whole thing! for start in xrange(self.numNodes): row = [] lastVal = None nodesInRow = 0 for goal in xrange(self.numNodes): val = shortestPathLookup[start][goal] if val != lastVal: row.append([goal, val]) lastVal = val nodesInRow += 1 else: nodesInRow += 1 assert nodesInRow == self.numNodes stringsRow = [] # Convert row to a bytestring to save space for item in row: assert item[0] < 65536 assert item[1] < 256 stringsRow.append( chr(item[0] / 256) + chr(item[0] % 256) + chr(item[1])) assert len(stringsRow[-1]) == 3 rowString = string.join(stringsRow, "") self.pathData.append(rowString) self.pathTable = PathTable(self.pathData, self.connections) def printPathData(self): ''' Outputs the pickled path table to stdout. ''' import sys sys.stdout.write(pickle.dumps(self.pathData, protocol=0)) def initPathData(self): self.pathData = [] for i in xrange(self.numNodes): self.pathData.append([ None, ] * self.numNodes) def addPaths(self, partialData): for i in xrange(len(partialData)): for j in xrange(len(partialData[i])): if partialData[i][j] is not None: assert self.pathData[i][j] is None self.pathData[i][j] = partialData[i][j] ## def pathTableLookup(self, startNode, goalNode): ## ''' ## Look up the equivalent of pathData[goalNode][startNode] in our run-length encoded data. ## ''' ## if startNode >= self.numNodes or goalNode >= self.numNodes: ## raise "Invalid node ID. Must be less than self.numNodes (%s)." % self.numNodes ## str = self.pathData[startNode] ## pos = 0 ## while (pos < len(str)) and (256*ord(str[pos]) + ord(str[pos+1]) <= goalNode): ## #print pos, ": ",256*ord(str[pos]) + ord(str[pos+1]) ## pos += 3 ## pos -= 3 ## return ord(str[pos+2]) def findRoute(self, startNode, goalNode): ''' Returns the node-by-node route from startNode to goalNode. ''' return self.pathTable.findRoute(startNode, goalNode) def makeNodeLocator(self, environment): meshNode = CollisionNode("NavMeshNodeLocator") meshNode.setFromCollideMask(BitMask32.allOff()) meshNode.setIntoCollideMask(OTPGlobals.PathFindingBitmask) self.polyHashToPID = {} for pId in self.polyToAngles: vertCount = 0 corners = [] for angle in self.polyToAngles[pId]: if angle != 180: # It's a corner corners.append(vertCount) vertCount += 1 # XXX this code only works for square nodes at present # Unfortunately we can only make triangle or square CollisionPolygons on the fly assert len(corners) == 4 #import pdb #pdb.set_trace() verts = [] for vert in corners: verts.append( (self.vertexCoords[self.polyToVerts[pId][vert]][0], self.vertexCoords[self.polyToVerts[pId][vert]][1], 0)) #import pdb #pdb.set_trace() poly = CollisionPolygon(verts[0], verts[1], verts[2], verts[3]) assert poly not in self.polyHashToPID self.polyHashToPID[poly] = pId meshNode.addSolid(poly) ray = CollisionRay() ray.setDirection(0, 0, -1) ray.setOrigin(0, 0, 0) rayNode = CollisionNode("NavMeshRay") rayNode.setFromCollideMask(OTPGlobals.PathFindingBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) rayNode.addSolid(ray) self.meshNodePath = environment.attachNewNode(meshNode) self.rayNodePath = environment.attachNewNode(rayNode) self.meshNodePath.setTwoSided(True) self.chq = CollisionHandlerQueue() self.traverser = CollisionTraverser() self.traverser.addCollider(self.rayNodePath, self.chq) def findNodeFromPos(self, environment, x, y): self.rayNodePath.setPos(environment, x, y, 50000) self.chq.clearEntries() self.traverser.traverse(self.meshNodePath) if self.chq.getNumEntries() != 1: self.notify.warning("No node found at position: %s, %s in %s" % (x, y, environment)) return 0 e = self.chq.getEntry(0) assert e.hasInto() if not e.hasInto(): self.notify.warning("No into found for collision %s" % (e)) pId = self.polyHashToPID[e.getInto()] return pId # --------- Begin long-term storage code --------- def writeToFile(self, filename, storePathTable=True): ''' Output the contents of this mesh to the file specified. Saving to a file lets us avoid doing expensive precomputation every time a mesh instance is required. ''' if self.environmentHash is None: raise "Attempted write to file without valid environment hash!" if storePathTable and not self.pathData: raise "Attempted to write empty pathData. Call NavMesh.generatePathTable() first!" f = open(filename, 'wb') if storePathTable: pickle.dump([ self.environmentHash, self.polyToVerts, self.polyToAngles, self.vertexCoords, self.connections, self.pathData ], f, protocol=2) f.close() self.pathData = None else: pickle.dump([ self.environmentHash, self.polyToVerts, self.polyToAngles, self.vertexCoords, self.connections, None ], f, protocol=2) f.close() print "Successfully wrote to file %s." % filename def _initFromString(self, str): contents = pickle.loads(str) self.environmentHash = contents[0] self.polyToVerts = contents[1] self.polyToAngles = contents[2] self.vertexCoords = contents[3] self.connections = contents[4] self.pathData = contents[5] if self.pathData is not None: self.pathTable = PathTable(self.pathData, self.connections) self.pathData = None self.numNodes = len(self.connections) def _initFromFilename(self, filepath, filename): vfs = VirtualFileSystem.getGlobalPtr() filename = Filename(filename) searchPath = DSearchPath() #searchPath.appendDirectory(Filename('.')) #searchPath.appendDirectory(Filename('etc')) #searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('~'))) #searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('$HOME'))) searchPath.appendDirectory( Filename.fromOsSpecific(os.path.expandvars(filepath))) found = vfs.resolveFilename(filename, searchPath) if not found: raise IOError, "File not found!" str = vfs.readFile(filename, 1) self._initFromString(str) def checkHash(self, envHash): ''' "Does this mesh represent the environment I think it does?" If this check fails, the mesh is out of date (or being used with the wrong environment). In either case, whoever generated this instance should discard it and create a new mesh from scratch. ''' return envHash == self.environmentHash
class ArcadeFlightGame(ShowBase): def __init__(self): ShowBase.__init__(self) self.debug = False self.maxdistance = 400 self.statusLabel = self.makeStatusLabel(0) self.collisionLabel = self.makeStatusLabel(1) self.player = AlliedFlanker(self.loader, self.render, self.taskMgr) self.world = GameWorld(1024, self.loader, self.render, self.camera) self.taskMgr.add(self.updateTask, "update") self.keyboardSetup() # performance and map to player so can't fly beyond visible terrain self.player.setMaxHeight(self.maxdistance) if self.debug == False: self.camLens.setFar(self.maxdistance) else: base.oobe() self.camLens.setFov(60) self.setupCollisions() self.textCounter = 0 def makeStatusLabel(self, i): """ Create a status label at the top-left of the screen, Parameter 'i' is the row number """ return OnscreenText(style=2, fg=(.5,1,.5,1), pos=(-1.3,0.92-(.08 * i)), \ align=TextNode.ALeft, scale = .08, mayChange = 1) def keyboardSetup(self): self.keyMap = {"left":0, "right":0, "climb":0, "fall":0, \ "accelerate":0, "decelerate":0, "fire":0} self.accept("escape", sys.exit) self.accept("a", self.setKey, ["accelerate", 1]) self.accept("a-up", self.setKey, ["accelerate", 0]) self.accept("z", self.setKey, ["decelerate", 1]) self.accept("z-up", self.setKey, ["decelerate", 0]) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_down", self.setKey, ["climb", 1]) self.accept("arrow_down-up", self.setKey, ["climb", 0]) self.accept("arrow_up", self.setKey, ["fall", 1]) self.accept("arrow_up-up", self.setKey, ["fall", 0]) self.accept("space", self.setKey, ["fire", 1]) self.accept("space-up", self.setKey, ["fire", 0]) base.disableMouse() # or updateCamera will fail! def setKey(self, key, value): """ Used by keyboard setup """ self.keyMap[key] = value def setupCollisions(self): self.collTrav = CollisionTraverser() # rapid collisions detected using below plus FLUID pos self.collTrav.setRespectPrevTransform(True) self.playerGroundSphere = CollisionSphere(0, 1.5, -1.5, 1.5) self.playerGroundCol = CollisionNode('playerSphere') self.playerGroundCol.addSolid(self.playerGroundSphere) # bitmasks self.playerGroundCol.setFromCollideMask(BitMask32.bit(0)) self.playerGroundCol.setIntoCollideMask(BitMask32.allOff()) self.world.setGroundMask(BitMask32.bit(0)) self.world.setWaterMask(BitMask32.bit(0)) # and done self.playerGroundColNp = self.player.attach(self.playerGroundCol) self.playerGroundHandler = CollisionHandlerQueue() self.collTrav.addCollider(self.playerGroundColNp, self.playerGroundHandler) # DEBUG as per video: if (self.debug == True): self.playerGroundColNp.show() self.collTrav.showCollisions(self.render) def updateTask(self, task): """ Gets added to the task manager, updates the player, deals with inputs, collisions, game logic etc. """ self.player.calculate() self.actionInput() validMove = self.player.move(self.world.getSize()) # lets not be doing this every frame... if validMove == False and self.textCounter > 30: self.statusLabel.setText("STATUS: MAP END; TURN AROUND") elif self.textCounter > 30: self.statusLabel.setText("STATUS: OK") if self.textCounter > 30: self.textCounter = 0 else: self.textCounter = self.textCounter + 1 self.updateCamera() self.collTrav.traverse(self.render) for i in range(self.playerGroundHandler.getNumEntries()): entry = self.playerGroundHandler.getEntry(i) if (self.debug == True): self.collisionLabel.setText("DEAD:" + str(globalClock.getFrameTime())) self.player.die() return Task.cont def actionInput(self): """ Used by updateTask to process keyboard input """ if (self.keyMap["climb"] != 0): self.player.climb() elif (self.keyMap["fall"] != 0): self.player.dive() else: self.player.unwindVertical() if (self.keyMap["left"] != 0): self.player.bankLeft() elif (self.keyMap["right"] != 0): self.player.bankRight() else: self.player.unwindHorizontal() if (self.keyMap["accelerate"] != 0): self.player.accelerate() elif (self.keyMap["decelerate"] != 0): self.player.brake() def updateCamera(self): self.player.lookAtMe(self.camera)