def drive(self, carstate: State) -> Command: command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) input_data = np.reshape(input_data, (1, 22, 1)) # output = self.model.predict(input_data) # output = self.dense_model.predict(input_data) # output = self.lstm_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0.5: brake = 0 else: acceleration = 0 if acceleration > 0: if carstate.rpm > 8000: command.gear = carstate.gear + 1 if carstate.rpm < 2500: command.gear = carstate.gear - 1 if not command.gear: command.gear = carstate.gear or 1 command.accelerator = acceleration command.brake = brake command.steering = steering return command
def drive(self, carstate: State) -> Command:
command = Command()
speed_x = carstate.speed_x
speed_y = carstate.speed_y
speed_z = carstate.speed_z
speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2)
distance = carstate.distance_from_start
distance_raced = carstate.distance_raced
curlaptime = carstate.current_lap_time
lastlaptime = carstate.last_lap_time
time = curlaptime
track_position = carstate.distance_from_center
angle = carstate.angle
track_edges = carstate.distances_from_edge
input_data = [speed, track_position, angle]
for edge in track_edges:
input_data.append(edge)
opponents = carstate.opponents
for i in range(9, len(opponents), 9):
input_data.append(opponents[i])
input_data = np.reshape(input_data, (1,len(input_data)))
output = self.alt_model.predict(input_data)
acceleration = output[0][0]
brake = output[0][1]
steering = output[0][2]
if acceleration > 0:
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
if track_edges[9] < 130.0 and track_edges[9] > 80.0:
if speed > 40:
acceleration = 0
brake = 0.05
elif track_edges[9] < 80 and track_edges[9] > 40:
if speed > 25:
acceleration = 0
brake = 0.05
elif track_edges[9] < 40:
if speed > 15:
acceleration = 0
brake = 0.05
if speed > 30:
acceleration = 0
brake = 0.05
command.accelerator = acceleration
command.brake = brake
command.steering = steering
# To train:
#if time > 6 and distance_raced > 80 and distance > 20:
# if lastlaptime < 2:
# fitness = (distance*distance)/(time*1000.)
# else:
# fitness = 200
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("down")
# pyautogui.press("enter")
# pyautogui.press("down")
# pyautogui.press("enter")
# pyautogui.press("right")
# pyautogui.press("enter")
# pyautogui.press("enter")
# pyautogui.press("enter")
# pyautogui.press("up")
# pyautogui.press("enter")
# exit(0)
#else:
# fitness = 0
#print(distance)
#print(fitness)
#if abs(angle) >= 80:
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#elif time > 5 and speed < 2:
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#elif time > 400:
# print("Stop2")
# print(fitness)
# fitness = 250
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#print(track_edges[9])
#print(command)
return command
def drive(self, carstate: State) -> Command:
command = Command()
speed_x = carstate.speed_x
speed_y = carstate.speed_y
speed_z = carstate.speed_z
speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2)
distance = carstate.distance_from_start
distance_raced = carstate.distance_raced
curlaptime = carstate.current_lap_time
lastlaptime = carstate.last_lap_time
time = curlaptime
track_position = carstate.distance_from_center
angle = carstate.angle
track_edges = carstate.distances_from_edge
input_data = [speed, track_position, angle]
for edge in track_edges:
input_data.append(edge)
opponents = carstate.opponents
for i in range(9, len(opponents), 9):
input_data.append(opponents[i])
input_data = np.reshape(input_data, (1, len(input_data)))
output = self.alt_model.predict(input_data)
acceleration = output[0][0]
brake = output[0][1]
steering = output[0][2]
if acceleration > 0:
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
if track_edges[9] < 130.0 and track_edges[9] > 80.0:
if speed > 40:
acceleration = 0
brake = 0.05
elif track_edges[9] < 80 and track_edges[9] > 40:
if speed > 25:
acceleration = 0
brake = 0.05
elif track_edges[9] < 40:
if speed > 15:
acceleration = 0
brake = 0.05
if speed > 30:
acceleration = 0
brake = 0.05
command.accelerator = acceleration
command.brake = brake
command.steering = steering
# To train:
#if time > 6 and distance_raced > 80 and distance > 20:
# if lastlaptime < 2:
# fitness = (distance*distance)/(time*1000.)
# else:
# fitness = 200
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("down")
# pyautogui.press("enter")
# pyautogui.press("down")
# pyautogui.press("enter")
# pyautogui.press("right")
# pyautogui.press("enter")
# pyautogui.press("enter")
# pyautogui.press("enter")
# pyautogui.press("up")
# pyautogui.press("enter")
# exit(0)
#else:
# fitness = 0
#print(distance)
#print(fitness)
#if abs(angle) >= 80:
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#elif time > 5 and speed < 2:
# print("Stop")
# print(fitness)
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#elif time > 400:
# print("Stop2")
# print(fitness)
# fitness = 250
# fi = open("fitness.p","wb")
# pickle.dump(fitness, fi)
# fi.close()
# pyautogui.press("esc")
# pyautogui.press("enter")
# exit(0)
#print(track_edges[9])
#print(command)
return command
def drive(self, carstate: State) -> Command:
command = Command()
speed_x = carstate.speed_x
speed_y = carstate.speed_y
speed_z = carstate.speed_z
speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2)
distance = carstate.distance_from_start
distance_raced = carstate.distance_raced
#print("Raced")
#print(distance_raced)
#print(distance)
curlaptime = carstate.current_lap_time
lastlaptime = carstate.last_lap_time
time = curlaptime + lastlaptime
#print(lastlaptime)
#print(time)
track_position = carstate.distance_from_center
angle = carstate.angle
track_edges = carstate.distances_from_edge
input_data = [speed, track_position, angle]
for edge in track_edges:
input_data.append(edge)
input_data = np.reshape(input_data, (1,22))
output = self.alt_model.predict(input_data)
#output = self.alt_model.activate(input_data)
#print(output)
acceleration = output[0][0]
brake = output[0][1]
steering = output[0][2]
if acceleration > 0:
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
if track_edges[9] < 130.0 and track_edges[9] > 80.0:
if speed > 40:
acceleration = 0
brake = 0.05
elif track_edges[9] < 60 and track_edges[9] > 40:
if speed > 25:
acceleration = 0
brake = 0.05
elif track_edges[9] < 40:
if speed > 15:
acceleration = 0
brake = 0.05
command.accelerator = acceleration
command.brake = brake
command.steering = steering
if time > 5 and distance_raced > 15 and distance > 15:
fitness = (distance*distance)/(time*1000.)
else:
fitness = 0
#print(distance)
#print(fitness)
if abs(angle) >= 90:
print("Stop")
print(fitness)
pickle.dump(fitness, open("fitness.p","wb"))
pyautogui.press("esc")
pyautogui.press("enter")
exit(0)
elif time > 5 and speed < 2:
print("Stop")
print(fitness)
pickle.dump(fitness, open("fitness.p","wb"))
pyautogui.press("esc")
pyautogui.press("enter")
exit(0)
elif time > 500:
print("Stop")
print(fitness)
pickle.dump(fitness, open("fitness.p","wb"))
pyautogui.press("esc")
pyautogui.press("enter")
exit(0)
#print(track_edges[9])
#print(command)
return command
def drive(self, carstate: State) -> Command:
if self.speedup is None:
self.speedup = any(opponent !=200 for opponent in carstate.opponents)
print(self.speedup)
command = Command()
print(self.offtrack, carstate.distance_from_center)
if(self.recovering): print('recovering')
if abs(carstate.distance_from_center) > 1 or (carstate.angle > 45 and carstate.angle < 315) or self.recovering:
self.offtrack += 1
if self.offtrack > 10:
self.recovering = True
self.accelerate(carstate, 20, command)
self.steer(carstate, 0, command)
if abs(carstate.distance_from_center) < 1 and (carstate.angle < 45 or carstate.angle > 315):
self.recovering = False
self.offtrack = 0
if command.steering < 0: command.steering = max(command.steering, -0.07)
elif command.steering > 0: command.steering = min(command.steering, 0.07)
return command
sample = self.state2sample(carstate)
result = self.net.activate(sample)
command.accelerator = self.my_accelerate(carstate.speed_x)
command.gear = self.shiftGears(carstate.gear, carstate.rpm)
command.steering = result[0] - 0.5
command.brake = 0
interval = 10
position = math.floor(int(carstate.distance_from_start) / interval)
with open('roadmap', 'rb') as file:
self.roadmap = pickle.load(file)
if self.speedup and position + 1 < len(self.roadmap):
if max(self.roadmap[position:position + int(200 / interval)]) < 0.1 and carstate.speed_x < 180:
command.accelerator = 1
else:
if carstate.speed_x > 80:
command.brake = 1
command.accelerator = 0
if len(self.roadmap) == position and int(carstate.distance_from_start) % interval == 0:
self.roadmap.append(abs(command.steering))
print('Pos: {}, len(RM): {}'.format(position, len(self.roadmap)))
with open('roadmap', 'wb') as file:
pickle.dump(self.roadmap, file)
print('brake: {}, acc: {}, steering: {}'.format(command.brake, command.accelerator, command.steering))
return command
def drive(self, carstate: State):
# at the begin of the race: determine on which position the car starts
if self.previous_position == 0:
self.previous_position = carstate.race_position
print('Starting in %s position'%carstate.race_position)
self.ID = carstate.race_position
self.team_mate_pos = self.ID + 1 # in the very beginning, both team mates should behave as if they were first
if self.use_team:
self.position_file = './team_communication/positions/'+str(self.ID)+'.txt'
with open(self.position_file, 'w') as file:
file.write(str(carstate.race_position)+"\n")
if self.use_team:
"""
determine position relative to team mate
"""
# if not team_check:
# check if there are 2 files
for root, dirs, files in os.walk("./team_communication/positions"):
if len(files) < 2:
# no team mate
self.team_mate_pos = 100
for filename in files:
if filename != str(self.ID)+'.txt':
team_mate_pos = np.loadtxt("./team_communication/positions/"+filename, ndmin=1)
self.team_mate_pos = int(team_mate_pos[-1])
if carstate.race_position < self.team_mate_pos:
self.is_first = True
else:
self.is_first = False
self.team_check = False
if carstate.race_position != self.previous_position:
# log the changed race position
with open(self.position_file, 'a') as file:
file.write(str(carstate.race_position)+"\n")
t = carstate.current_lap_time
if t < self.last_cur_lap_time:
# made a lap, adjust timing events accordingly
print('Lap completed, in position %s'%carstate.race_position)
self.off_time -= carstate.last_lap_time
self.recovered_time -= carstate.last_lap_time
self.stopped_time -= carstate.last_lap_time
self.last_cur_lap_time = t
# initialize the driving command
command = Command()
"""
Collect Input Data.
Speed, Track Position, Angle on the track and the 19 values of the
Track Edges
"""
sensor_SPEED = carstate.speed_x * 3.6 # Convert from MPS to KPH
sensor_TRACK_POSITION = carstate.distance_from_center
sensor_ANGLE_TO_TRACK_AXIS = carstate.angle * math.pi / 180
sensor_TRACK_EDGES = carstate.distances_from_edge
if sensor_SPEED < 2:
if not self.is_stopped:
self.is_stopped = True
self.stopped_time = t
else:
self.is_stopped = False
"""
Process Inputs.
Feed the sensor data into the network to produce a Accelrator, Brake
and Steering command
"""
sensor_data = [min(sensor_SPEED, 300)/300, sensor_TRACK_POSITION, sensor_ANGLE_TO_TRACK_AXIS]
x = np.array(sensor_TRACK_EDGES) / 200
sensor_data += list(x)
if self.is_stopped & (t > self.stopped_time + 2) & (not self.recovering):
self.recovering = True
self.is_stopped = False
#print(self.RECOVER_MSG)
print('Stopped for 2 seconds...')
if self.recovering:
"""
Recovery Bot
"""
self.simpleDriver(sensor_data, carstate, command)
if np.abs(sensor_TRACK_POSITION) < 1:
# recovered!
# self.stuck = 0
if not self.warm_up:
#print('Back on track...')
self.recovered_time = t
self.warm_up = True
self.off_track = False
# considered recovered if moving fast and straightish
if (t > self.recovered_time + 2) & (sensor_SPEED > 50) & (np.abs(sensor_ANGLE_TO_TRACK_AXIS) < 0.5):
self.recovering = False
self.warm_up = False
self.init_time = t + 1
print('~~ Recovered! ~~')
#print('+-'*18)
else:
self.off_track = True
self.warm_up = False
else:
"""
Drive using the EchoStateNet
"""
# check if car is off road and if so, for how long
if np.abs(sensor_TRACK_POSITION) > 1:
if self.off_track == False:
#print("### OFF ROAD ###")
if self.use_team:
# write to pheromone.txt warning team mate:
self.drop_pheromone(carstate.distance_from_start)
self.off_time = t
self.off_track = True
if t > self.off_time + 3:
# haven't recovered in 3 seconds
# get back on road and start new evaluation
self.recovering = True
print('Off road for 3 seconds...')
else:
self.off_track = False
"""
apply team strategy: if the car is behind his team mate, try to block opponents comming from behind
"""
# print(self.is_first)
if self.use_team and not self.is_first and abs(carstate.distance_from_center) < 0.6:
closest_opponent = np.argmin(carstate.opponents)
if closest_opponent > 26:
delta = abs(closest_opponent-35) # get values between 0 (if opponent is directly behind) and 8 (if opponent is at to the car's right )
delta /= 10.0 # scale to values between 0 and 1
# delta = 0.2
adjusted_track_position = min(1, sensor_TRACK_POSITION + delta)
sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer towards the opponent
if closest_opponent < 9:
delta = closest_opponent/10.0 # scale to values between 0 (if opponent is directly behind) and 1 (if opponent is at to the car's left )
adjusted_track_position = max(-1, sensor_TRACK_POSITION - delta)
sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer towards the opponent
print('Blocking Opponent')
"""
overtaking strategy
"""
if self.use_overtaking_assistant:
closest_opponent = np.argmin(carstate.opponents)
distance_to_opponent = carstate.opponents[closest_opponent]
#print(closest_opponent)
close_opponents_left = carstate.opponents[3:9]
left = min(close_opponents_left) < 20
close_opponents_front_left = carstate.opponents[9:18] # front left quarter
front_left = min(close_opponents_front_left) < 100
close_opponents_front_right = carstate.opponents[18:28] # front right quarter
front_right = min(close_opponents_front_right) < 100
close_opponents_right = carstate.opponents[28:32]
right = min(close_opponents_right) < 20
"""
overtaking
"""
#if (closest_opponent > 5 and closest_opponent < 12) or (closest_opponent > 24 and closest_opponent < 30):
if not (front_left or front_right): # if no opponents are in front
if abs(carstate.angle) < 20 and distance_to_opponent > 5: # assure that overtaking makes sense
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_OVERTAKE # increase speed limit to enable fast overtaking
#print('speed up!')
"""
get around an opponent on the car's left/front
"""
#if closest_opponent >= 12 and closest_opponent < 18 and carstate.distance_from_center > -0.75:
if front_left and not (front_right or right) and carstate.distance_from_center > -0.75:
if np.argmin(close_opponents_front_left) < 50:
delta = 0.5
else:
delta = 0.3
#scale = 1/(max(1,distance_to_opponent))
#delta = (np.argmin(close_opponents_front_left))/len(close_opponents_front_left) # dependent on angle: if opponent is in the front, steer stronger
#print('move to the right!')
#print('delta = '+str(delta))
adjusted_track_position = min(1, sensor_TRACK_POSITION + delta)
sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer away from the opponent
"""
get around an opponent on the car's right/front
"""
#if closest_opponent >= 18 and closest_opponent <= 24 and carstate.distance_from_center < 0.75:
if front_right and not (front_left or left) and carstate.distance_from_center < 0.75:
if np.argmin(close_opponents_front_right) < 50:
delta = 0.5
else:
delta = 0.3
#scale = 1/(max(1,distance_to_opponent))
delta = abs(np.argmin(close_opponents_front_right) - len(close_opponents_front_right) + 1)/len(close_opponents_front_right)
#print('move to the left!')
#print('delta = '+str(delta))
adjusted_track_position = max(-1, sensor_TRACK_POSITION - delta)
sensor_data[1] = adjusted_track_position # adjust sensor input for ESN to motivate the car to steer away from the opponent
"""
load ESN if it is not yet available,
predict the driving command
"""
try:
output = self.esn.predict(sensor_data,continuation=True)
# print('esn already loaded')
except:
# load ESN from specified path
self.esn = neuralNet.restore_ESN(self.PATH_TO_ESN)
# start a new 'history of states'
output = self.esn.predict(sensor_data,continuation=False)
print('Loaded ESN from %s'%self.PATH_TO_ESN)
"""
Controller extension: Multi-Layer Perceptron that adjust the driving commands if opponents are close
"""
# modifiy ESN output based on the opponents data
# only if car is not racing at the first position
self.active_mlp = False
#if self.use_mlp_opponents and carstate.race_position > 1:
if self.use_mlp_opponents:
opponents_data = carstate.opponents
# if closest opponent is less than 50m away, use mlp to adjust outputs
distance_limit = 50.0
if min(opponents_data) < distance_limit:
self.active_mlp = True
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_OVERTAKE
#print('-------------use mlp---------------')
mlp_input = [output[0],output[1]]
#print(opponents_data)
for sensor in opponents_data:
# normalize opponents_data to [0,1]
mlp_input.append(sensor/distance_limit)
"""
load MLP if it is not yet available,
predict the driving commands
"""
try:
change_output = self.mlp.predict(np.asarray(mlp_input))
except:
self.mlp = neuralNet.restore_MLP(self.PATH_TO_MLP)
change_output = self.mlp.predict(np.asarray(mlp_input))
print('Loaded MLP for overtaking')
# adjust the ESN output based on the MLP output
output += change_output
self.esn.set_last_outputs(output)
"""
determine if car should accelerate or brake
"""
if self.use_team:
# check if near any difficult positions that have been communicated by pheromones:
pheromones = np.loadtxt(open('./team_communication/pheromones.txt', 'rb'), ndmin=1)
if pheromones.size > 0:
for p in pheromones:
dist = float(p) - carstate.distance_from_start
if np.abs(dist) < 100:
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_CAREFUL
# print('### CAREFUL MODE ###')
break
else:
if not self.active_mlp:
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL
else:
# if on second position in team, slow down when opponent is directly behind
if not self.is_first:
closest_opponent = np.argmin(carstate.opponents)
if closest_opponent == 0 or closest_opponent == 35:
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_BLOCKING
else:
if not self.active_mlp:
# print('### NORMAL MODE ###')
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL
else:
if not self.active_mlp:
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL
else:
if not self.active_mlp:
# print('### NORMAL MODE ###')
self.CURRENT_SPEED_LIMIT = self.SPEED_LIMIT_NORMAL
if output[0] > 0:
if sensor_SPEED < self.CURRENT_SPEED_LIMIT:
accel = min(max(output[0],0),1)
else:
accel = 0
brake = 0.0
else:
accel = 0.0
brake = min(max(-output[0],0),1)
steer = min(max(output[1],-1),1)
# uncomment to print current input and output data
"""
print('Speed: %.2f, Track Position: %.2f, Angle to Track: %.2f\n'%(sensor_data[0], sensor_data[1], sensor_data[2]))
print('Accelrator: %.2f, Brake: %.2f, Steering: %.2f'%(accel, brake, steer))
print('Field View:')
print(''.join('{:3f}, '.format(x) for x in sensor_data[3:]))
"""
"""
Apply Accelrator, Brake and Steering Commands.
"""
# for the first second do not listen to the network
# this allows it to initate it's state
if t > self.init_time:
command.accelerator = accel
command.brake = brake
command.steering = steer
else:
self.simpleDriver(sensor_data, carstate, command)
"""
Automatic Transmission.
Automatically change gears depending on the engine revs
"""
if not self.recovering:
if carstate.rpm > 8000 and command.accelerator > 0:
command.gear = carstate.gear + 1
elif carstate.rpm < 2500:
command.gear = max(1, carstate.gear - 1)
if not command.gear:
command.gear = carstate.gear or 1
# save position information for the next simulation step
self.previous_position = carstate.race_position
return command
def drive(self, carstate: State) -> Command: # threading.Thread(target=c.communicate, args=(carstate, "communication.csv")).start() command = Command() speed_x = carstate.speed_x speed_y = carstate.speed_y speed_z = carstate.speed_z speed = math.sqrt(speed_x**2 + speed_y**2 + speed_z**2) track_position = carstate.distance_from_center angle = carstate.angle track_edges = carstate.distances_from_edge input_data = [speed, track_position, angle] for edge in track_edges: input_data.append(edge) opponents = carstate.opponents for i in range(0, len(opponents), 9): if not i == 27: input_data.append(opponents[i]) input_data = np.reshape(input_data, (1,len(input_data))) # output = self.model.predict(input_data) # output = self.alt_model.predict(input_data) output = self.opponents_model.predict(input_data) acceleration = output[0][0] brake = output[0][1] steering = output[0][2] if acceleration > 0: if carstate.rpm > 8000: command.gear = carstate.gear + 1 if carstate.rpm < 2500: command.gear = carstate.gear - 1 if not command.gear: command.gear = carstate.gear or 1 if track_edges[9] < 130.0 and track_edges[9] > 80.0: if speed > 40: acceleration = 0 brake = 0.05 elif track_edges[9] < 60 and track_edges[9] > 40: if speed > 25: acceleration = 0 brake = 0.05 elif track_edges[9] < 40: if speed > 15: acceleration = 0 brake = 0.05 command.accelerator = acceleration command.brake = brake command.steering = steering return command
def drive(self, carstate: State) -> Command:
# count from race start
global count_s
global ACC
global client
global TRAIN
# if race finished
global termination
global CAR_ID
global CAR2_ID
global CAR_FILE_A
global CAR_FILE_B
global CAR2_FILE_A
global CAR2_FILE_B
global accerlate_credit
global break_penalty
global last_steering
global stable_penalty
global speed_reward
command = Command()
self.current_accelerator_controller = 'NEAT'
self.current_break_controller = 'NEAT'
self.current_steer_controller = 'NEAT'
self.swing = False
self.closer = False
count_s += 1
# * 3.6 to KM/H
speed = carstate.speed_x * 3.6
min_edge_value = 199.0
closest_edge_idx = -1
for idx, value in enumerate(carstate.distances_from_edge):
if value < min_edge_value:
min_edge_value = value
closest_edge_idx = idx
# calculate top speed
if not hasattr(self, 'top_speed'):
self.top_speed = 0.0
if speed > self.top_speed:
self.top_speed = speed
if not hasattr(self, 'stuck'):
self.stuck = False
self.stuck_count = 0
# calculate average speed
if not hasattr(self, 'average_speed'):
self.average_speed = 0.0
if not hasattr(self, 'volatility'):
self.volatility = 0.0
if not hasattr(self, 'volatility'):
self.volatility = 0.0
if not hasattr(self, 'average_angle'):
self.average_angle = 0.0
if not hasattr(self, 'speed_reward'):
self.speed_reward = 0.0
# some candidate of fitness funtion factors
self.speed_reward += speed*math.cos(math.radians(carstate.angle))
self.average_speed = (self.average_speed * (count_s - 1) + speed) / float(count_s)
self.average_angle = (self.average_angle * (count_s - 1) + np.cos(math.radians(carstate.angle))) / float(count_s)
if not hasattr(self, 'prev_steering'):
self.prev_steering = 0.0
if not hasattr(self, 'accumulate_speed_multiple_cos_angle'):
self.accumulate_speed_multiple_cos_angle = 0.0
if not hasattr(self, 'never_use_steer'):
self.never_use_steer = True
# input features
if carstate.speed_x < 1:
speed_x = 1
else:
speed_x = carstate.speed_x
radio_speed_xy = carstate.speed_z / speed_x
x = [(carstate.speed_x * 3.6 - 100) / 200, carstate.distance_from_center, carstate.angle / 360, radio_speed_xy] + ((np.array(list(carstate.distances_from_edge)) - 100) / 200).tolist()
self.accumulate_speed_multiple_cos_angle += speed * np.cos(math.radians(carstate.angle))
if DEBUG:
print('x', x)
# create output
y = self.output_net.activate(x)
# some candidate of fitness funtion factors
self.volatility = (self.volatility * (count_s - 1) + 5 * abs(y[2] - self.prev_steering)) / float(count_s)
self.prev_steering = y[2]
if DEBUG:
print('y', y)
# some candidate of fitness funtion factors
if abs(y[2]) > 0.1 and speed > 1:
self.never_use_steer = False
# automatically switch gear
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
# assign output
command.accelerator = y[0]
command.brake = y[1]
command.steering = y[2]
# Termination condition
# 1. speed too low for long time.
# 2. hit wall
# 3. off track
# 4. run long enough
if TRAIN or DUMP_WINNER:
if (carstate.current_lap_time > 3 and abs(speed - 0.0) < 3) or \
(carstate.current_lap_time > 30 and abs(speed - 0.0) < 20) or \
carstate.damage > 0 or \
carstate.distance_from_center >= 1 or \
carstate.distance_from_center <= -1 or \
carstate.distance_raced > 13000:
termination = True
if termination:
# fitness factors
fitness_factor['raced_distance'] = carstate.distance_raced
fitness_factor['top_speed'] = self.top_speed
fitness_factor['average_speed'] = self.average_speed
fitness_factor['volatility'] = self.volatility
fitness_factor['average_angle'] = self.average_angle
fitness_factor['accumulate_speed_multiple_cos_angle'] = self.accumulate_speed_multiple_cos_angle
fitness_factor['damage'] = carstate.damage
fitness_factor['never_use_steer'] = self.never_use_steer
fitness_factor['speed_reward'] = self.speed_reward
fitness_factor['time'] = carstate.current_lap_time
fitness_factor['last_lap_time'] = carstate.last_lap_time
print('fitness_factor:', fitness_factor)
# Reset parameters
termination = False
count_s = 0
# Ask server to restart
command.meta = 1
return command
def cheesy_drive(self, carstate):
'''
Opponent obstruction behaviour
'''
command = Command()
angle_change = 2
self.check_jesus_position(carstate)
# enter obstruction mode
if self.cheesus_state == 0:
# come to a stop
if carstate.speed_x > 1:
command.brake = 1
# once stopped, measure track and enter turning procedure
else:
self.track_width = carstate.distances_from_edge[
0] + carstate.distances_from_edge[18]
self.cheesus_state = 1
# turning procedure
elif self.cheesus_state == 1:
if carstate.angle < self.last_angle - angle_change:
self.last_angle = carstate.angle
self.cheesus_state = 2
else:
command.gear = 1
if carstate.speed_x < 5:
command.accelerator = 1
if carstate.speed_x > 0:
command.steering = 1
else:
command.brake = 1
# turning procedure
elif self.cheesus_state == 2:
if np.abs(carstate.angle) > 88:
self.cheesus_state = 3
else:
if carstate.angle < self.last_angle - angle_change:
self.last_angle = carstate.angle
self.cheesus_state = 1
else:
command.gear = -1
if carstate.speed_x < 0:
command.steering = -1
else:
command.brake = 1
if carstate.speed_x > -5:
command.accelerator = 1
# exit turning procedure
elif self.cheesus_state == 3:
command.brake = 1
command.steering = 0
command.accelerator = 0
if carstate.speed_x > -1:
self.cheesus_state = 4
# oscillation forward
elif self.cheesus_state in [4, 5]:
command.gear = 1 if self.cheesus_state == 4 else -1
command.steering = 0
if np.abs(carstate.speed_x) < 3:
command.accelerator = 1
if (self.cheesus_state == 4 and carstate.distance_from_center > .03 * self.track_width)\
or (self.cheesus_state == 5 and carstate.distance_from_center < -.03 * self.track_width):
command.brake = 1
if not self.close_to_jesus:
self.cheesus_state = 5 if self.cheesus_state == 4 else 4
if np.abs(carstate.angle) < 89:
command.steering = -0.2
if np.abs(carstate.angle) > 91:
command.steering = 0.2
return command
def drive(self, carstate: State, offroad_count, turn_around_count,
negative_speed_count) -> Command:
command = Command()
max_dist = 200.0
react_dist = 200.0
max_angle = 180.0
max_speed = 200.0 / 3.6
max_rpm = 10000
# left_side = list(carstate.distances_from_edge[:9])[::-1]
# right_side = list(carstate.distances_from_edge[10:])
middle_sens = carstate.distances_from_edge[9]
opps = list(carstate.opponents)
for i, dist in enumerate(opps):
if dist == 200.:
opps[i] = 0.
# back_opp = opponents[0]
# left_opp = opponents[1:18][::-1]
# forward_opp = opponents[18]
# right_opp = opponents[19:]
# even_sens = [x + y for x,y in zip(left_side, right_side)]
# uneven_sens = [x - y for x,y in zip(left_side, right_side)]
# edges = even_sens + uneven_sens + [middle_sens]
edges = [np.exp(-x / react_dist) for x in carstate.distances_from_edge]
# even_opp = even_sens = [x + y for x,y in zip(left_opp, right_opp)]
# uneven_opp = even_sens = [x - y for x,y in zip(left_opp, right_opp)]
# opps = even_opp + uneven_opp + [forward_opp] + [back_opp]
offroad = False
if middle_sens == -1.:
offroad_count += 1
offroad = True
edges = 19 * [0]
else:
for i, dist in enumerate(edges):
if dist > 0:
edges[i] = np.exp(-dist / react_dist)
else:
edges[i] = -np.exp(dist / react_dist)
turn_around = False
if carstate.angle > 100 or carstate.angle < -100:
turn_around_count += 1
turn_around = True
negative_speed = False
if carstate.speed_x < 0:
negative_speed_count += 1
negative_speed = True
for i, dist in enumerate(opps):
if dist != 0.:
opps[i] = np.exp(-dist / react_dist)
input_vector = edges + [carstate.speed_x/max_speed] + [carstate.speed_y/max_speed] + [carstate.speed_z/max_speed] + [carstate.angle/max_angle] + \
[carstate.distance_from_center] + [carstate.rpm/max_rpm] #+ opps
# print("LEN", len(input_vector))
output_vector = self.network.NN(input_vector)
# speed_value = 200. * (output_vector[0] + 1.)/2.
speed_value = output_vector[0]
# Combination of acceleration and brake
acceleration_value = 0.
brake_value = 0.
if speed_value > 0:
acceleration_value = speed_value
elif speed_value < 0:
brake_value = -speed_value
steer_value = output_vector[1]
if not math.isnan(output_vector[2]):
gear_value = int(((output_vector[2] + 1) / 2) * 5 + 1)
else:
gear_value = 1
command.gear = gear_value
command.accelerator = acceleration_value
command.brake = brake_value
command.steering = steer_value
# self.accelerate(carstate, speed_value, command)
# self.steer(carstate, steer_value, command)
fitness = fitness_function(carstate.distance_from_start,
carstate.distance_raced, carstate.damage,
offroad_count, carstate.race_position,
carstate.last_lap_time, turn_around_count,
negative_speed_count)
# print('------')
# # print()
# # print("input_vector ", input_vector)
# # print()
# # print("weights_matrix ", np.array(self.network.weights_matrix))
# # print()
# # print("output vector ", output_vector)
# print()
# print("acceleration_value ", acceleration_value)
# print("brake_value ", brake_value)
# print("steer_value ", steer_value)
# print("gear_value ", gear_value)
# print()
# # print("input vector ", input_vector)
# print("turn_around_count " , turn_around_count)
# print("negative speed count " , negative_speed_count)
# print("carstate.speed_x " , carstate.speed_x )
# print("carstate.speed_y " , carstate.speed_y )
# print("carstate.speed_z " , carstate.speed_z )
# print()
# print("distance_from_start ", carstate.distance_from_start)
# print("distance_raced ", carstate.distance_raced)
# print("damage ", carstate.damage)
# print("offroad ", offroad)
# print("offroad count ", offroad_count)
# print("race_position ", carstate.race_position)
# print()
# # print(list(carstate.opponents))
# # print()
# print("fitness ", fitness)
# # print()
return command, fitness, offroad_count, turn_around_count, negative_speed_count
def drive(self, carstate: State) -> Command:
if carstate.distance_raced < 3:
try:
self.dict["position"] = carstate.race_position
with open("mjv_partner{}.txt".format(self.port),
"wb") as handle:
pickle.dump(self.dict,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
except:
pass
path = os.path.abspath(os.path.dirname(__file__))
for i in os.listdir(path):
if os.path.isfile(os.path.join(
path,
i)) and 'mjv_partner' in i and not str(self.port) in i:
self.partner = i.strip('mjv_partner').strip('.txt')
else:
self.race_started = True
try:
with open("mjv_partner{}.txt".format(self.partner),
'rb') as handle:
self.dict_teammate = pickle.load(handle)
self.dict["position"] = carstate.race_position
with open("mjv_partner{}.txt".format(self.port),
"wb") as handle:
pickle.dump(self.dict,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
# print(self.port, self.dict_teammate["position"])
# print("RESULT", carstate.race_position > int(self.dict_teammate["position"]))
if carstate.race_position > int(
self.dict_teammate["position"]):
self.is_leader = False
else:
self.is_leader = True
except:
print("Not able to read port", self.port)
pass
# print(self.dict_teammate)
# print(self.port, self.leader)
# print("Distance: {}".format(carstate.distance_from_start))
# Select the sensors we need for our model
self.speeds.append(carstate.speed_x)
command = Command()
distances = list(carstate.distances_from_edge)
sensors = [
carstate.speed_x, carstate.distance_from_center, carstate.angle,
*(carstate.distances_from_edge)
]
# CRASHED
off_road = all(distance == -1.0 for distance in distances)
standing_still = self.recovers == 0 and all(
abs(s) < 1.0 for s in self.speeds[-5:])
if self.race_started and (off_road or self.recovers > 0):
command = self.recover(carstate, command)
if not self.crash_recorded:
self.crash_recorded = True
self.dict["crashes"].append(carstate.distance_raced)
# NOT CRASHED
else:
self.crash_recorded = False
if carstate.gear == -1:
carstate.gear = 2
if self.norm:
# Sensor normalization -> ?
sensors = self.normalize_sensors(sensors)
# Forward pass our model
y = self.model(Variable(torch.Tensor(sensors)))[0]
# Create command from model output
command.accelerator = np.clip(y.data[0], 0, 1)
command.brake = np.clip(y.data[1], 0, 1)
command.steering = np.clip(y.data[2], -1, 1)
command = self.smooth_commands(command)
# print(self.race_started and not self.is_leader)
# print("LEADER", self.is_leader)
if self.race_started and not self.is_leader and carstate.distance_from_start > 50:
command = self.check_swarm(command, carstate)
# Naive switching of gear
self.switch_gear(carstate, command)
# print("Accelerate: {}".format(command.accelerator))
# print("Brake: {}".format(command.brake))
# print("Steer: {}".format(command.steering))
if self.record is True:
sensor_string = ",".join([str(x) for x in sensors]) + "\n"
self.file_handler.write(
str(y.data[0]) + "," + str(y.data[1]) + "," + str(y.data[2]) +
"," + sensor_string)
return command