def reset(self, prev_step_info=None): """Reset Method. To be called at the end of each episode""" if self.initial_reset: while self.ob is None: try: self.client = snakeoil3.Client(p=self.port, vision=self.vision, visualise=self.visualise) # Open new UDP in vtorcs self.client.MAX_STEPS = self.CLIENT_MAX_STEPS self.client.get_servers_input(step=0) # Get the initial input from torcs raw_ob = self.client.S.d # Get the current full-observation self.ob = self.make_observation(raw_ob) except: pass self.initial_reset = False else: try: self.ob, self.client = TorcsEnv.reset(self, client=self.client, relaunch=True) except Exception as e: self.ob = None while self.ob is None: try: print("Hard Reset") # self.end(self.client) self.client = snakeoil3.Client(p=self.port, vision=self.vision) # Open new UDP in vtorcs self.client.MAX_STEPS = self.CLIENT_MAX_STEPS self.client.get_servers_input(step=0) # Get the initial input from torcs raw_ob = self.client.S.d # Get the current full-observation from torcs self.ob = self.make_observation(raw_ob) except: pass self.distance_traversed = 0 s_t = np.hstack((self.ob.angle, self.ob.track, self.ob.trackPos, self.ob.speedX, self.ob.speedY, self.ob.speedZ, self.ob.wheelSpinVel / 100.0, self.ob.rpm)) self.prev_angle = 0.0 self.prev_dist = 0.0 self.prev_lane = 0.0 self.accel_PID.reset_pid() self.steer_PID.reset_pid() return s_t
def reset(self, client, relaunch=True): self.time_step = 0 self.port = client.port if self.initial_reset is not True: ## TENTATIVE. Restarting TORCS every episode suffers the memory leak bug! if relaunch is True: self.reset_torcs(client) logging.debug("### TORCS is RELAUNCHED ###") # Modify here if you use multiple tracks in the environment logging.debug("Trying to connect {} client on port {}".format( self.name, self.port)) client = snakeoil3.Client( p=self.port, vision=self.vision, visualise=self.visualise, no_of_visualisations=self.no_of_visualisations, name=self.name) # Open new UDP in vtorcs client.MAX_STEPS = np.inf # client = self.client client.get_servers_input(step=0) # Get the initial input from torcs obs = client.S.d # Get the current full-observation from torcs self.observation = self.make_observation(obs) self.currState = np.hstack( (self.observation.angle, self.observation.track, self.observation.trackPos, self.observation.speedX, self.observation.speedY, self.observation.speedZ, self.observation.wheelSpinVel / 100.0, self.observation.rpm)) self.last_u = None self.initial_reset = False return self.get_obs(), client
def wait_for_observation(self): """Refresh client and wait for a valid observation to come in.""" self.ob = None while self.ob is None: logging.debug("{} Still waiting for observation at {}".format( self.name, self.port)) try: self.client = snakeoil3.Client( p=self.port, vision=(self.cfg["vision"] if "vision" in self.cfg else False), visualise=(self.cfg["visualise"] if "visualise" in self.cfg else False), name=self.name) # Open new UDP in vtorcs self.client.MAX_STEPS = self.cfg[ "client_max_steps"] if "client_max_steps" in self.cfg else np.inf self.client.get_servers_input(0) # Get the initial input from torcs raw_ob = self.client.S.d # Get the current full-observation from torcs self.ob = self.env.make_observation(raw_ob) except: pass
def wait_for_observation(self): """Refresh client and wait for a valid observation to come in.""" self.ob = None while self.ob is None: logging.debug("{} Still waiting for observation".format(self.name)) try: self.client = snakeoil3.Client(p=self.madras_agent_port, vision=self._config.vision, visualise=self._config.visualise) # Open new UDP in vtorcs self.client.MAX_STEPS = self._config.client_max_steps self.client.get_servers_input(0) # Get the initial input from torcs raw_ob = self.client.S.d # Get the current full-observation from torcs self.ob = self.make_observation(raw_ob) except: pass
if S['speedX'] > 50: R['gear'] = 2 if S['speedX'] > 80: R['gear'] = 3 if S['speedX'] > 110: R['gear'] = 4 if S['speedX'] > 140: R['gear'] = 5 if S['speedX'] > 170: R['gear'] = 6 # Throttle Control if S['speedX'] < target_speed - (R['steer'] * 50): R['accel'] += .01 else: R['accel'] -= .01 if S['speedX'] < 10: R['accel'] += 1 / (S['speedX'] + .1) print(S['speedX'], R['gear']) return if __name__ == "__main__": C = snakeoil3.Client(p=PORT, e=maxSteps, vision=False) print(sys.argv[1]) for step in range(C.maxSteps, 0, -1): C.get_servers_input(0) drive_traffic(C, sys.argv[1]) C.respond_to_server() C.shutdown()
def playTraffic(port=3101, target_vel=50.0, angle=0.0, sleep=0): """Traffic Play function.""" env = TorcsEnv(vision=False, throttle=True, gear_change=False) ob = None while ob is None: try: client = snakeoil3.Client(p=port, vision=False) client.MAX_STEPS = np.inf client.get_servers_input(step=0) obs = client.S.d ob = env.make_observation(obs) except: pass episode_count = cfg['traffic']['max_eps'] max_steps = cfg['traffic']['max_steps_eps'] early_stop = 0 velocity_i = target_vel / 300.0 accel_pid = PID(np.array([10.5, 0.05, 2.8])) steer_pid = PID(np.array([5.1, 0.001, 0.000001])) steer = 0.0 accel = 0.0 brake = 0 A = cfg['traffic']['amplitude'] / 300.0 T = cfg['traffic']['time_period'] # print(velocity_i) for i in range(episode_count): info = {'termination_cause': 0} steer = 0.0 accel = 0.0 brake = 0 S = 0.0 for step in range(max_steps): a_t = np.asarray([steer, accel, brake]) # [steer, accel, brake] try: ob, r_t, done, info = env.step(step, client, a_t, early_stop) if done: pass except Exception as e: print("Exception caught at point A at port " + str(i) + str(e)) ob = None while ob is None: try: client = snakeoil3.Client(p=port, vision=False) client.MAX_STEPS = np.inf client.get_servers_input(step=0) obs = client.S.d ob = env.make_observation(obs) except: pass continue if (step <= sleep): print("WAIT" + str(port)) continue velocity = velocity_i + A * math.sin(step / T) opp = ob.opponents front = np.array([opp[15], opp[16], opp[17], opp[18], opp[19]]) closest_front = np.min(front) if (step % T == 0): print("VEL_CHANGE: ", velocity * 300.0) vel_error = velocity - ob.speedX angle_error = -(ob.trackPos - angle) / 10 + ob.angle steer_pid.update_error(angle_error) accel_pid.update_error(vel_error) accel = accel_pid.output() steer = steer_pid.output() if accel < 0: brake = 1 else: brake = 0 if closest_front < ((float(0.5 * ob.speedX * 100) + 10.0) / 200.0): brake = 1 else: brake = 0 try: if 'termination_cause' in info.keys() and info['termination_cause'] == 'hardReset': print('Hard reset by some agent') ob, client = env.reset(client=client, relaunch=True) except Exception as e: print("Exception caught at point B at port " + str(i) + str(e) ) ob = None while ob is None: try: client = snakeoil3.Client(p=port, vision=False) # Open new UDP in vtorcs client.MAX_STEPS = np.inf client.get_servers_input(0) # Get the initial input from torcs obs = client.S.d # Get the current full-observation from torcs ob = env.make_observation(obs) except: print("Exception caught at at point C at port " + str(i) + str(e))
def step(self, desire): """Step method to be called at each time step.""" r_t = 0 for PID_step in range(self.PID_latency): # Implement the desired trackpos and velocity using PID if self.pid_assist: self.accel_PID.update_error((desire[1] - self.prev_vel)) self.steer_PID.update_error( (-(self.prev_lane - desire[0]) / 10 + self.prev_angle)) if self.accel_PID.output() < 0.0: brake = 1 else: brake = 0 a_t = np.asarray( [self.steer_PID.output(), self.accel_PID.output(), brake]) else: a_t = desire try: self.ob, r, done, info = TorcsEnv.step(self, PID_step, self.client, a_t, self.early_stop) except Exception as e: print(("Exception caught at port " + str(e))) self.ob = None while self.ob is None: try: self.client = snakeoil3.Client(p=self.port, vision=self.vision) # Open new UDP in vtorcs self.client.MAX_STEPS = self.CLIENT_MAX_STEPS self.client.get_servers_input(0) # Get the initial input from torcs raw_ob = self.client.S.d # Get the current full-observation from torcs self.ob = self.make_observation(raw_ob) except: pass continue self.prev_vel = self.ob.speedX self.prev_angle = self.ob.angle self.prev_lane = self.ob.trackPos if (math.isnan(r)): r = 0.0 r_t += r # accumulate rewards over all the time steps self.distance_traversed = self.client.S.d['distRaced'] r_t += (self.distance_traversed - self.prev_dist) /\ self.track_len self.prev_dist = deepcopy(self.distance_traversed) if self.distance_traversed >= self.track_len: done = True if done: # self.reset() break s_t1 = np.hstack((self.ob.angle, self.ob.track, self.ob.trackPos, self.ob.speedX, self.ob.speedY, self.ob.speedZ, self.ob.wheelSpinVel / 100.0, self.ob.rpm)) return s_t1, r_t, done, info