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: 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 fire(self): timeNow = globalClock.getFrameTime() #small check for reloading condition if self.isReloading != False: #if reloading is not false, is a time firing kosher again. check and see if past if timeNow > self.isReloading: self.isReloading = False #also fill mag self.ammo['currentMag'] = self.ammo['magSize'] else: #otherwise return with nothing to show for it return if (timeNow - self.lastFired) < self.fireRate: # if difference is SMALLER than firerate, don't do anything - exit return #targetVector will be owner's target if AI #targetVector = base.render.getRelativeVector(self.owner.target, Vec3(0, 1, 0)) startPos = base.render.getRelativePoint( self.model, Vec3(0, self.length, -self.height / 2)) #account for target height - shoot at center mass targetVector = self.owner.target.getPos() + Vec3( 0, 0, self.owner.target.height / 2) targetVector = (targetVector - startPos) targetVector.normalize() #create projectile at set offset in front of weapon bullet(self, startPos, targetVector, 3, 480, 400) #play firing noise self.firingNoise.play() #record in lastFired self.lastFired = timeNow #decrement ammo self.ammo['currentMag'] -= 1 #if this makes currentMag 0, reload if self.ammo['currentMag'] < 1: self.reload(timeNow)
def fire(self): ''' if owner is a player: Create projectile, play noise, decrement ammo counter Projectile goes towards joint owner.headgun otherwise just create projectile aimed at owner.target ''' #check if time since last fired > firerate timeNow = globalClock.getFrameTime() if (timeNow - self.lastFired) < self.fireRate: # if difference is SMALLER than firerate, don't do anything - exit return #initialize variables targetVector = None startPos = None if self.owner.isPlayer: #get player headgun targetVector = base.render.getRelativeVector( self.owner.headgun, Vec3(0, 1, 0)) #start pos should always be self.length from pos. Will experiment with # https://discourse.panda3d.org/t/calculating-forward-vector-from-hpr/6261/2 # Post describes how to get the forward vector from Panda's HPR format, particularly # in the context of a parent coordinate space rather than local. # This was critical to getting a vector that bullets should follow that approximates the # direction of the weapon, see line 78. startPos = base.render.getRelativePoint( self.model, Vec3(0, -self.length, -self.height / 2)) #create projectile at set offset in front of weapon bullet(self, startPos, targetVector, 6, 480, 400) self.firingNoise.play() #record in lastFired self.lastFired = timeNow
def control(self,ValveCommands): self.gimbalX = 0 self.gimbalY = 0 self.Valves = ValveCommands-(ValveCommands-self.Valves)*np.exp(-self.dt/self.tau) self.EngObs = self.vulcain.predict_data_point(np.array(self.Valves).reshape(1,-1 )) #Brennkammerdruck, Gaskammertemp, H2Massenstrom, LOX MAssentrom, Schub #Bar,K,Kg/s,Kg/s,kN #self.dt = globalClock.getDt() pos = self.rocketNP.getPos() vel = self.rocketNP.node().getLinearVelocity() quat = self.rocketNP.getTransform().getQuat() Roll, Pitch, Yaw = quat.getHpr() rotVel = self.rocketNP.node().getAngularVelocity() # CHECK STATE if self.fuelMass <= 0: self.EMPTY = True #if pos.getZ() <= 36: # self.LANDED = True self.LANDED = False self.processContacts() P, T, rho = air_dens(pos[2]) rocketZWorld = quat.xform(Vec3(0, 0, 1)) AoA = math.acos(min(max(dot(norm(vel), norm(-rocketZWorld)), -1), 1)) dynPress = 0.5 * dot(vel, vel) * rho dragArea = self.rocketCSLon + (self.rocketCSLat - self.rocketCSLon) * math.sin(AoA) drag = norm(-vel) * dynPress * self.Cd * dragArea time = globalClock.getFrameTime() liftVec = norm(vel.project(rocketZWorld) - vel) if AoA > 0.5 * math.pi: liftVec = -liftVec lift = liftVec * (math.sin(AoA * 2) * self.rocketCSLat * dynPress) if self.CONTROL: self.throttle = self.heightPID.control(pos.getZ(), vel.getZ(), 33) pitchTgt = self.XPID.control(pos.getX(), vel.getX(), 0) self.gimbalX = -self.pitchPID.control(Yaw, rotVel.getY(), pitchTgt) rollTgt = self.YPID.control(pos.getY(), vel.getY(), 0) self.gimbalY = -self.rollPID.control(Pitch, rotVel.getX(), -rollTgt) self.thrust = self.EngObs[0][4]*1000 #print(self.EngObs) quat = self.rocketNP.getTransform().getQuat() quatGimbal = TransformState.makeHpr(Vec3(0, self.gimbalY, self.gimbalX)).getQuat() thrust = quatGimbal.xform(Vec3(0, 0, self.thrust)) thrustWorld = quat.xform(thrust) #print(thrustWorld) self.npDragForce.reset() self.npDragForce.drawArrow2d(Vec3(0, 0, 0), quat.conjugate().xform(drag) / 1000, 45, 2) self.npDragForce.create() self.npLiftForce.reset() self.npLiftForce.drawArrow2d(Vec3(0, 0, 0), quat.conjugate().xform(lift) / 1000, 45, 2) self.npLiftForce.create() self.npThrustForce.reset() if self.EMPTY is False & self.LANDED is False: self.npThrustForce.drawArrow2d(Vec3(0, 0, -0.5 * self.length), Vec3(0, 0, -0.5 * self.length) - thrust / 30000, 45, 2) self.npThrustForce.create() self.rocketNP.node().applyForce(drag, Vec3(0, 0, 0)) self.rocketNP.node().applyForce(lift, Vec3(0, 0, 0)) #print(self.EMPTY,self.LANDED) if self.EMPTY is False & self.LANDED is False: self.rocketNP.node().applyForce(thrustWorld, quat.xform(Vec3(0, 0, -1 / 2 * self.length))) self.updateRocket(self.EngObs[0][2]+self.EngObs[0][3], self.dt) self.rocketNP.node().setActive(True) self.fuelNP.node().setActive(True) self.processInput() self.world.doPhysics(self.dt) self.steps+=1 if self.steps > 1000: self.DONE = True telemetry = [] telemetry.append('Thrust: {}'.format(int(self.EngObs[0][4]))) telemetry.append('Fuel: {}%'.format(int(self.fuelMass / self.fuelMass_full * 100.0))) telemetry.append('Gimbal: {}'.format(int(self.gimbalX)) + ',{}'.format(int(self.gimbalY))) telemetry.append('AoA: {}'.format(int(AoA / math.pi * 180.0))) telemetry.append('\nPos: {},{}'.format(int(pos.getX()), int(pos.getY()))) telemetry.append('Height: {}'.format(int(pos.getZ()))) telemetry.append('RPY: {},{},{}'.format(int(Roll), int(Pitch), int(Yaw))) telemetry.append('Speed: {}'.format(int(np.linalg.norm(vel)))) telemetry.append('Vel: {},{},{}'.format(int(vel.getX()), int(vel.getY()), int(vel.getZ()))) telemetry.append('Rot: {},{},{}'.format(int(rotVel.getX()), int(rotVel.getY()), int(rotVel.getZ()))) telemetry.append('LANDED: {}'.format(self.LANDED)) telemetry.append('Time: {}'.format(self.steps*self.dt)) telemetry.append('TARGET: {}'.format(self.targetAlt)) #print(pos) if self.VISUALIZE is True: self.ostData.setText('\n'.join(telemetry)) self.cam.setPos(pos[0] - 120 * self.scale, pos[1] - 120 * self.scale, pos[2] + 80 * self.scale) self.cam.lookAt(pos[0], pos[1], pos[2]) self.taskMgr.step()
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 render(self, visualize=False): #self.sim.setVisualization(visualize) ... def close(self): ... if __name__ == "__main__": env = LearningRocket() observation = env.reset() done = False while done is False: observation, reward, done, info = env.step([0.1, 0, 0]) # print(observation) time = globalClock.getFrameTime() print(time) print(observation) env.sim.VISUALIZE = True observation = env.reset() for i in range(1000): observation = env.step([0.1, 0, 0]) # print(observation) time = globalClock.getFrameTime() print(time) print(observation) # observation = env.reset() # If the environment don't follow the interface, an error will be thrown # check_env(env, warn=True)