def __localCannonMoveTask(self, task): pos = self.cannonPosition oldRot = pos[0] oldAng = pos[1] rotVel = 0 if self.leftPressed: rotVel += CANNON_ROTATION_VEL if self.rightPressed: rotVel -= CANNON_ROTATION_VEL pos[0] += rotVel * globalClock.getDt() if pos[0] < CANNON_ROTATION_MIN: pos[0] = CANNON_ROTATION_MIN elif pos[0] > CANNON_ROTATION_MAX: pos[0] = CANNON_ROTATION_MAX angVel = 0 if self.upPressed: angVel += CANNON_ANGLE_VEL if self.downPressed: angVel -= CANNON_ANGLE_VEL pos[1] += angVel * globalClock.getDt() if pos[1] < CANNON_ANGLE_MIN: pos[1] = CANNON_ANGLE_MIN elif pos[1] > CANNON_ANGLE_MAX: pos[1] = CANNON_ANGLE_MAX if oldRot != pos[0] or oldAng != pos[1]: if self.cannonMoving == 0: self.cannonMoving = 1 base.playSfx(self.sndCannonMove, looping=1) self.__updateCannonPosition() elif self.cannonMoving: self.cannonMoving = 0 if self.sndCannonMove: self.sndCannonMove.stop() return Task.cont
def update_bullet(task): """ Invokes the physics engine to update and simulate the next step. """ dt = globalClock.getDt() # get elapsed time self.world.doPhysics(dt) # actually update return task.cont
def camera_movement(self, task): dt = globalClock.getDt() direction = self.render.getRelativeVector(self.camera, (0, 1, 0)) direction.normalize() position = self.camera.getPos() move_speed = VisualizerApp.MOVE_SPEED if self.keyMap['shift']: move_speed *= VisualizerApp.MOVE_SPEED_MULTIPLIER if self.keyMap['forward']: position += direction * dt * move_speed if self.keyMap['backward']: position += direction * dt * -move_speed self.camera.setPos(position) chunk_x = position.x // self.level.chunk_width chunk_z = position.y // self.level.chunk_depth self.position_text.text = 'Position: (x: %04d, y: %04d, z: %04d)\nChunk (x: %02d, z: %02d)' % (position.x, position.z, position.y, chunk_x, chunk_z) return task.cont
def camera_control(self, task): dt = globalClock.getDt() if dt > .20: return task.cont if self.master.mouseWatcherNode.hasMouse(): mouse_position = self.master.mouseWatcherNode.getMouse() self.rotation[0] += mouse_position.getY() * 30 self.rotation[1] += mouse_position.getX() * -50 self.master.camera.setP(self.rotation[0]) self.master.camera.setH(self.rotation[1]) self.player_node_path.setH(self.player_node_path.getH() + mouse_position.getX() * -1) self.master.win.movePointer(0, int(self.master.win.getXSize() / 2), int(self.master.win.getYSize() / 2)) if self.keyMap["w"]: self.player_node_path.setY(self.player_node_path, SPEED * dt) if self.keyMap["s"]: self.player_node_path.setY(self.player_node_path, -SPEED * dt) if self.keyMap["a"]: self.player_node_path.setX(self.player_node_path, -SPEED * dt) if self.keyMap["d"]: self.player_node_path.setX(self.player_node_path, SPEED * dt) if self.keyMap["shift"]: self.player_node_path.setZ(self.player_node_path, SPEED * dt) if self.keyMap["control"]: self.player_node_path.setZ(self.player_node_path, -SPEED * dt) if self.keyMap["space"]: self.jump() return task.cont
def update(self, task): """Updates the actor action following the key event It is use as a callback task and instructs a movement to the actor following the key pressed by the player which relates to a specific type of movement (or other action). The movement is also based on the amount of time since the last movement. :param task: the task received by the callback :return: the priority of the task """ dt = globalClock.getDt() result_pos = Vec3(0, 0, 0) if self.action_map["up"][1]: result_pos = Vec3(0, 5.0 * dt, 0) if self.action_map["down"][1]: result_pos = Vec3(0, -5.0 * dt, 0) if self.action_map["left"][1]: result_pos = Vec3(-5.0 * dt, 0, 0) if self.action_map["right"][1]: result_pos = Vec3(5.0 * dt, 0, 0) if self.action_map["shoot"][1]: result_pos = Vec3(0, 0, 0) print("Zap!") if self.action_map["lift"][1]: result_pos = Vec3(0, 0, 5.0 * dt) if self.action_map["fall"][1]: result_pos = Vec3(0, 0, -5.0 * dt) self.dice_actor.setPos(self.dice_actor.getPos() + result_pos) return task.cont
def update(self, task: Task): dt, ft = globalClock.getDt(), globalClock.getFrameTime() heading, position, pitch = self.player.get_h(), self.player.get_pos(), self.player.get_p() # self.sun.set_p(self.sun.get_p() - (dt * 20)) # self.sun.set_h(self.sun.get_h() - (dt * 20)) if KEY_MAP["up"]: position.z += self.SPEED * dt self.player.set_pos(position) if KEY_MAP["down"]: position.z -= self.SPEED * dt self.player.set_pos(position) if KEY_MAP["q"]: position.x -= self.SPEED * dt self.player.set_pos(position) if KEY_MAP["e"]: position.x += self.SPEED * dt self.player.set_pos(position) if KEY_MAP["w"]: dx = (self.SPEED * dt) * np.cos(np.radians(heading + 90)) dy = (self.SPEED * dt) * np.sin(np.radians(heading + 90)) position.y, position.x = position.y + dy, position.x + dx self.player.set_pos(position) if KEY_MAP["s"]: dx = - (self.SPEED * dt) * np.cos(np.radians(heading + 90)) dy = - (self.SPEED * dt) * np.sin(np.radians(heading + 90)) position.y, position.x = position.y + dy, position.x + dx self.player.set_pos(position) if KEY_MAP["d"] and not KEY_MAP["s"]: heading -= self.SPEED * dt * 2 self.player.set_h(heading) if KEY_MAP["a"] and not KEY_MAP["s"]: heading += self.SPEED * dt * 2 self.player.set_h(heading) if KEY_MAP["d"] and KEY_MAP["s"]: heading += self.SPEED * dt * 2 self.player.set_h(heading) if KEY_MAP["a"] and KEY_MAP["s"]: heading -= self.SPEED * dt * 2 self.player.set_h(heading) if KEY_MAP["left"]: pitch += self.SPEED * dt * 2 self.player.set_p(pitch) if KEY_MAP["right"]: pitch -= self.SPEED * dt * 2 self.player.set_p(pitch) return task.cont
def update(self, task): # Get the amount of time since the last update dt = globalClock.getDt() # If any movement keys are pressed, use the above time # to calculate how far to move the character, and apply that. if self.keyMap["up"]: self.player.move(Vec3(0, - dt, 0)) if self.keyMap["down"]: self.player.move(Vec3(0, dt, 0)) if self.keyMap["left"]: self.player.move(Vec3(dt, 0, 0)) if self.keyMap["right"]: self.player.move(Vec3(- dt, 0, 0)) if self.keyMap["quit"]: self.exit_game() if self.mouseWatcherNode.hasMouse(): if self.mouseWatcherNode.getMouseX() < -self.mouse_check_value: self.player.rotate(Vec3(100.0 * dt, 0, 0)) elif self.mouseWatcherNode.getMouseX() > self.mouse_check_value: self.player.rotate(Vec3(-100.0 * dt, 0, 0)) if self.keyMap["shoot"]: self.player.shoot() if not (self.keyMap["up"] or self.keyMap["down"] or self.keyMap["left"] or self.keyMap["right"]): self.player.stop() self.scene.update(dt) return task.cont
def update(self, task: Task): dt = globalClock.getDt() if KEY_MAP["e"]: pos = self.sphere.get_pos() pos.z += self.SPEED * dt self.sphere.set_pos(pos) if KEY_MAP["q"]: pos = self.sphere.get_pos() pos.z -= self.SPEED * dt self.sphere.set_pos(pos) if KEY_MAP["a"]: pos = self.sphere.get_pos() pos.x -= self.SPEED * dt self.sphere.set_pos(pos) if KEY_MAP["d"]: pos = self.sphere.get_pos() pos.x += self.SPEED * dt self.sphere.set_pos(pos) if KEY_MAP["w"]: pos = self.sphere.get_pos() pos.y += self.SPEED * dt self.sphere.set_pos(pos) if KEY_MAP["s"]: pos = self.sphere.get_pos() pos.y -= self.SPEED * dt self.sphere.set_pos(pos) return task.cont
def update(self, task: Task): dt = globalClock.getDt() self.plane.setTexOffset(TextureStage.getDefault(), self.tx, 0) self.texture_update += 5 if self.texture_update % 6 * dt == 0: self.tx += self.tx_offset self.texture_update = 0 return task.cont
def update(self, task: Task): dt, ft = globalClock.getDt(), globalClock.getFrameTime() if KEY_MAP["up"]: self.bc304.set_pos(self.x, self.y, self.z) self.z += self.speed * dt if KEY_MAP["down"]: self.bc304.set_pos(self.x, self.y, self.z) self.z -= self.speed * dt if KEY_MAP["right"]: self.bc304.set_pos(self.x, self.y, self.z) self.x += self.speed * dt if KEY_MAP["left"]: self.bc304.set_pos(self.x, self.y, self.z) self.x -= self.speed * dt if KEY_MAP["e"]: pos = self.sphere.get_pos() pos.z += self.speed * dt self.sphere.set_pos(pos) if KEY_MAP["q"]: pos = self.sphere.get_pos() pos.z -= self.speed * dt self.sphere.set_pos(pos) if KEY_MAP["a"]: pos = self.sphere.get_pos() pos.x -= self.speed * dt self.sphere.set_pos(pos) if KEY_MAP["d"]: pos = self.sphere.get_pos() pos.x += self.speed * dt self.sphere.set_pos(pos) if KEY_MAP["w"]: pos = self.sphere.get_pos() pos.y += self.speed * dt self.sphere.set_pos(pos) if KEY_MAP["s"]: pos = self.sphere.get_pos() pos.y -= self.speed * dt self.sphere.set_pos(pos) # self.sphere.set_pos(float(np.cos(ft) * 4), float(np.sin(ft) * 4), float(np.sin(ft) * 10)) # self.z -= 0.5 * dt # self.bc304.set_hpr(self.h, self.p, 0) # self.h += 0.1 # self.p += 0.1 return task.cont
def update(self, task): """Update the world using physics.""" dt = globalClock.getDt() self.world.doPhysics(dt) self.clock += 1 if TARGETING[0] and self.clock % 10 == 0: for (character, side), target in zip(product(self.characterList, sides), self.targets): character.position_shoulder(side, target) return Task.cont
def updateState(self): ''' Called every frame - if w,a,s,d pressed, move self accordingly If mouse location different and not in a menu, rotate actor by delta radians Adjust camera to keep up with move ''' # call parent entity.updateState(self) # get time since last frame (multiply by distance to get actual distance to displace dt = globalClock.getDt() #update camera (also updates model using mouselook) self.updateCamera() # check if there is any movement if (self.keyMap["forward"] or self.keyMap["back"] or self.keyMap["left"] or self.keyMap["right"]): #isMobile tracks whether object is moving or not for other functions #TODO: direction specific animations #for now just loop walking if not self.isMobile: self.loop("walk", restart=0) self.isMobile = True # for every direction that is true, move object that way # do the same with the camera if self.keyMap["forward"]: self.setY(self, -self.speed * dt) # camera too.. #self.camera.setY(self.camera.getY() - 25 * dt) if self.keyMap["back"]: self.setY(self, +self.speed * dt) #self.camera.setY(self.camera.getY() + 25 * dt) if self.keyMap["left"]: #self.setX(self, + 100 * dt) self.setH(self.getH() + self.turnSpeed * dt) #counter movement of torso self.neck.setR(self.neck.getR() - self.turnSpeed * dt) if self.keyMap["right"]: #self.setX(self, - 100 * dt) self.setH(self.getH() - self.turnSpeed * dt) self.neck.setR(self.neck.getR() + self.turnSpeed * dt) # lastly if attempting move simulate gravity as well #self.setZ(self.getZ() - 50 * dt) else: self.isMobile = False #otherwise stop walk animation self.stop() #check if shooting, if so, shoot if self.keyMap['firing']: self.shoot()
def move_orbital_camera_task(self, task): # First compute new camera angles and distance if self.key_map["left"] != 0: self.longitude_deg = self.longitude_deg - self.deg_per_sec * globalClock.getDt( ) if self.key_map["right"] != 0: self.longitude_deg = self.longitude_deg + self.deg_per_sec * globalClock.getDt( ) if self.key_map["up"] != 0: self.latitude_deg = self.latitude_deg - self.deg_per_sec * globalClock.getDt( ) if self.key_map["down"] != 0: self.latitude_deg = self.latitude_deg + self.deg_per_sec * globalClock.getDt( ) if self.key_map["wheelup"] != 0: self.dist = self.dist * ( 1 + (self.zoom_per_sec - 1) * globalClock.getDt()) self.update_key_map("wheelup", 0) if self.key_map["wheeldown"] != 0: self.dist = self.dist / ( 1 + (self.zoom_per_sec - 1) * globalClock.getDt()) self.update_key_map("wheeldown", 0) if self.key_map["top_view"] != 0: self.latitude_deg = -90 self.longitude_deg = 0 self.update_key_map("top_view", 0) if self.longitude_deg > 180.0: self.longitude_deg = self.longitude_deg - 360.0 if self.longitude_deg < -180.0: self.longitude_deg = self.longitude_deg + 360.0 if self.dist < self.min_dist: self.dist = self.min_dist if self.dist > self.max_dist: self.dist = self.max_dist # Convert to Radians angle_longitude_radians = self.longitude_deg * (pi / 180.0) angle_latitude_radians = self.latitude_deg * (pi / 180.0) # Compute the target object's position with respect to the camera x = -self.dist * self.target_size * sin(angle_longitude_radians) * cos( angle_latitude_radians) y = self.dist * self.target_size * cos(angle_longitude_radians) * cos( angle_latitude_radians) z = self.dist * self.target_size * sin(angle_latitude_radians) # Compute the world origin's position with respect to the camera x = (x * self.render_ratio) y = (y * self.render_ratio) z = (z * self.render_ratio) # Apply the position self.__origin.set_pos(x, y, z) # Rotate the camera self.__cam.set_hpr(self.longitude_deg, self.latitude_deg, 0) # End task return task.cont
def execute(self, task): dt = globalClock.getDt() if self.stater.states["walk"]: self.straight_walk(dt) if self.stater.states["jump"]: self.jump(dt) if self.stater.states["fly"]: self.fly(dt) self.turn(dt) if self.actor.getZ() > initial_actor_pos.z: self.actor_obj.apply_gravity() else: self.actor_obj.v = util.VEC3_NULL self.actor_obj.move(dt) return Task.cont
def doGravity(self): dt = globalClock.getDt() #gravity - if not grounded, make it so if not self.isGrounded: self.setZ(self.getZ() - 50 * dt) return else: entries = [] for entry in base.groundHandler.getEntries(): if entry.getFromNodePath().getParent() == self \ or entry.getIntoNodePath().getParent() == self: entries.append(entry) if (len(entries) > 0) and (entries[0].getIntoNode().getName() == "terrain"): self.setZ(entries[0].getSurfacePoint(base.render).getZ() + 2)
def update(self, task: Task): dt = globalClock.getDt() if KEY_MAP["up"]: self.bc304.set_pos(self.x, self.y, self.z) self.z += 2.0 * dt if KEY_MAP["down"]: self.bc304.set_pos(self.x, self.y, self.z) self.z -= 2.0 * dt if KEY_MAP["right"]: self.bc304.set_pos(self.x, self.y, self.z) self.x += 2.0 * dt if KEY_MAP["left"]: self.bc304.set_pos(self.x, self.y, self.z) self.x -= 2.0 * dt if KEY_MAP["w"]: pos = self.sphere.get_pos() pos.z += 3 * dt self.sphere.set_pos(pos) if KEY_MAP["s"]: pos = self.sphere.get_pos() pos.z -= 3 * dt self.sphere.set_pos(pos) if KEY_MAP["a"]: pos = self.sphere.get_pos() pos.x -= 3 * dt self.sphere.set_pos(pos) if KEY_MAP["d"]: pos = self.sphere.get_pos() pos.x += 3 * dt self.sphere.set_pos(pos) # self.z -= 0.5 * dt # self.bc304.set_hpr(self.h, self.p, 0) # self.h += 0.1 # self.p += 0.1 return task.cont
def accelerate(self, task): """ Task moves bullet forward until it hits an object or range is met """ #range is decremented each tick #check to make sure not 0 if self.range <= 0: #if range has ran out kill task and this object self.delete() return task.done #otherwise proceed, move object and decrement range dt = globalClock.getDt() #distVec=min((self.start-self.target),(self.target-self.start)) #distVec=distVec.normalized() #print(distVec) #print(self.direction) #take normalized direction vector and apply to transform self.model.setFluidX(self.model, self.direction[0] * self.speed * dt) self.model.setFluidY(self.model, self.direction[1] * self.speed * dt) self.model.setFluidZ(self.model, self.direction[2] * self.speed * dt) self.range -= (self.speed * dt) return task.cont
def update_bullets(self, task: Task): if settings.SHOW_COLLIDERS: for b_collider in self.bullet_colliders: b_collider.show() dt = globalClock.getDt() rmi = [] + self.object_ids_to_indices() for idx, entry in enumerate(self.bullets): bullet, heading = entry bullet_pos = bullet.get_pos() if abs(np.sqrt(bullet_pos.y**2 + bullet_pos.x**2)) > 300: rmi.append(idx) continue dx = (self.BULLET_SPEED * dt) * np.cos(np.radians(heading)) dy = (self.BULLET_SPEED * dt) * np.sin(np.radians(heading)) bullet_pos.y += dy bullet_pos.x += dx bullet.set_fluid_pos(bullet_pos) for idx in rmi: self.bullets[idx][0].removeNode() self.bullet_colliders[idx].node().clearSolids() self.f.cTrav.removeCollider(self.bullet_colliders[idx]) pass self.bullet_colliders = [ b for i, b in enumerate(self.bullet_colliders) if i not in rmi ] self.bullets = [b for i, b in enumerate(self.bullets) if i not in rmi] # print(f"available {len(self.bullet_colliders)} colliders and {len(self.bullets)} bullets") return task.cont
def shoot(self): dt = globalClock.getDt() # print(self.rayQueue.getNumEntries()) # print(self.rayQueue) if self.rayQueue.getNumEntries() > 0: self.rayQueue.sortEntries() rayHit = self.rayQueue.getEntry(1) hitPos = rayHit.getSurfacePoint(self.base.render) # print(hitPos, "hitpos") # print(rayHit, "rayhit") # beamLength = (hitPos - self.actor.getPos()).length() # print("length: ", beamLength) hitNodePath = rayHit.getIntoNodePath() # print(hitNodePath) # print(hitNodePath.getPythonTag) # print(hitPos) # print(hitNodePath.getTag) # print(hitNodePath.hasPythonTag("enemy")) # print(rayHit.getFrom()) if hitNodePath.hasPythonTag("enemy"): # print("here") hitObject = hitNodePath.getPythonTag("enemy") hitObject.change_health(-1) # Find out how long the beam is, and scale the # beam-model accordingly. # print(self.actor.getPos()) beamLength = (hitPos - (self.actor.getPos())).length() self.beamModel.setSy(-beamLength) self.score += 1 self.update_score() self.beamModel.show() else: # If we're not shooting, don't show the beam-model. self.beamModel.hide()
def update(self, task): dt = globalClock.getDt() self.world.doPhysics(dt, 10, 0.008) return task.cont
def physics_task(self, task): dt = globalClock.getDt() self.physics_world.doPhysics(dt) return Task.cont
def move_backward(self, task): self.controlling_node.set_y( self.controlling_node, self.movement_speed * globalClock.getDt() ) self.controlled_node.set_h(180) return Task.cont
def move_right(self, task): self.controlling_node.set_x( self.controlling_node, -self.movement_speed * 0.7 * globalClock.getDt() ) self.controlled_node.set_h(-90) return Task.cont
def rotate_right(self, task): self.controlling_node.set_h( self.controlling_node, -self.movement_speed * 80 * globalClock.getDt() ) return Task.cont
def update(self, task: Task): if self.f.state == settings.IN_MENU_STATE: return task.cont dt, ft = globalClock.getDt(), globalClock.getFrameTime() tank_heading, tank_position = self.tank.tank.get_h( ), self.tank.tank.get_pos() # # self.sun.set_p(self.sun.get_p() - (dt * 40)) # # self.sun.set_h(self.sun.get_h() - (dt * 20)) # self.tank.hit() z_pos = 0.01 if settings.DISABLE_Z_MOV else tank_position.z self.tank.tank.set_fluid_pos(tank_position.x, tank_position.y, z_pos) self.tank.handle_sfx() if self.enemy.hp <= 0 and self.enemy.is_alive: self.enemy.tank.removeNode() del self.environment["enemy"] self.enemy.is_alive = False print("defeated") if KEY_MAP["up"]: tank_position.z += self.SPEED * dt self._tank.set_fluid_pos(tank_position) if KEY_MAP["down"]: tank_position.z -= self.SPEED * dt self._tank.set_fluid_pos(tank_position) if KEY_MAP["q"]: tank_position.x -= self.SPEED * dt self._tank.set_fluid_pos(tank_position) if KEY_MAP["e"]: tank_position.x += self.SPEED * dt self._tank.set_fluid_pos(tank_position) if KEY_MAP["w"]: dx = (self.SPEED * dt) * np.cos(np.radians(tank_heading + 90)) dy = (self.SPEED * dt) * np.sin(np.radians(tank_heading + 90)) tank_position.y, tank_position.x = tank_position.y + dy, tank_position.x + dx self._tank.set_fluid_pos(tank_position) if KEY_MAP["s"]: dx = -(self.SPEED * dt) * np.cos(np.radians(tank_heading + 90)) dy = -(self.SPEED * dt) * np.sin(np.radians(tank_heading + 90)) tank_position.y, tank_position.x = tank_position.y + dy, tank_position.x + dx self._tank.set_fluid_pos(tank_position) if KEY_MAP["d"] and not KEY_MAP["s"]: tank_heading -= self.TURN_SPEED * dt * 2 self._tank.set_h(tank_heading) if KEY_MAP["a"] and not KEY_MAP["s"]: tank_heading += self.TURN_SPEED * dt * 2 self._tank.set_h(tank_heading) if KEY_MAP["d"] and KEY_MAP["s"]: tank_heading += self.TURN_SPEED * dt * 2 self._tank.set_h(tank_heading) if KEY_MAP["a"] and KEY_MAP["s"]: tank_heading -= self.TURN_SPEED * dt * 2 self._tank.set_h(tank_heading) return task.cont
def update(self, task): dt = globalClock.getDt() self.world.doPhysics(dt) self.camera.look_at(self.follow_np) return task.cont