def drive(self, carstate: State) -> Command:
command = Command()
# Fill sensor data
self.sensors[0] = carstate.speed_x
self.sensors[1] = carstate.distance_from_center
self.sensors[2] = carstate.angle * np.pi / 180
self.sensors[3:] = np.array(carstate.distances_from_edge)
# Input to steering reservoir
echo = self.esn.transform(self.sensors.reshape(1, 22))
if abs(carstate.distance_from_center) < 1:
# Readout reservoir using neural network, predict and set steering
steer_idx = self.steer_model.predict(echo)
command.steering = MyDriver.steering_levels[steer_idx]
# Determine car state using SOM to set the speed
car_state = self.som.get_closer(self.sensors[3:, np.newaxis])
target_speed = self.map_speeds[car_state]
self.accelerate(carstate, target_speed, command)
else:
self.steer(carstate, 0, command)
self.accelerate(carstate, 20, command)
return command
def drive(self, carstate):
""" Gets the car out of a difficult situation
Tries different approaches and gives each one a time out.
A class level variable keeps track of the current approach
across game cycles. If the timer runs out, the approach
is terminated and the next approach gets initiated.
Args:
carstate: All parameters packed in a State object
Returns:
command: The next move packed in a Command object
"""
command = Command()
command.accelerator = 0
self.appr_counter += 1
if self.appr_counter > APPROACH_TIMEOUT:
self.next_approach()
try:
command = self.approaches[self.approach](carstate, command)
self.previous_accels.append(command.accelerator)
self.previous_gears.append(command.gear)
except Exception as e:
err(self.iter, "ERROR:", str(e))
return command
def shift(self, carstate: State, command: Command):
if carstate.rpm > 9000:
command.gear = carstate.gear + 1
if carstate.rpm < 2500 and carstate.gear > 1:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
def drive(self, carstate: State) -> Command:
print('Drive')
input = carstate.to_input_array()
if np.isnan(input).any():
if not self.stopped:
self.saveResults()
print(input)
print('NaN INPUTS!!! STOP WORKING')
return Command()
self.stopped = np.isnan(input).any()
self.print_log(carstate)
self.update(carstate)
try:
output = self.net.activate(input)
command = Command()
if self.unstuck and self.isStuck(carstate):
print('Ops! I got STUCK!!!')
self.reverse(carstate, command)
else:
if self.unstuck and carstate.gear <= 0:
carstate.gear = 1
for i in range(len(output)):
if np.isnan(output[i]):
output[i] = 0.0
print('Out = ' + str(output))
self.accelerate(output[0], output[1], 0, carstate, command)
if len(output) == 3:
# use this if the steering is just one output
self.steer(output[2], 0, carstate, command)
else:
# use this command if there are 2 steering outputs
self.steer(output[2], output[3], carstate, command)
except:
print('Error!')
self.saveResults()
raise
if self.data_logger:
self.data_logger.log(carstate, command)
return command
def drive(self, carstate: State) -> Command:
print('Drive')
self.print_log(carstate)
self.update(carstate)
command = Command()
command.accelerator = 1
command.gear = 1
command.brake = 0
command.steering = 0 #-1 * carstate.angle * np.pi / (180.0 * 0.785398)
if carstate.speed_x > 1 and command.gear >= 0 and command.brake < 0.1 and carstate.rpm > 8000:
command.gear = min(6, command.gear + 1)
if carstate.rpm < 2500 and command.gear > 1:
command.gear = command.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
return command
def to_command(self, accelerate, steer):
command = Command()
if accelerate >= 0:
command.accelerator = accelerate
else:
command.brake = abs(accelerate)
command.steering = (self.prev_command.steering + steer) / 2
return command
def step(self, carstate: State, command: Command):
command.accelerator = min(
1, (carstate.distance_from_center -
0.2)**4) #2 - min(carstate.distances_from_edge)
command.gear = -1
command.brake = 0.0
command.clutch = 0.0
command.steering = -1 * carstate.angle * np.pi / (180.0 *
0.785398) * 1.5
return True
def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track.
"""
command = Command()
stateList = self.stateToArray(carstate)
# output = self.network.activate(stateList)
output = self.network.forward(stateList).data
print(output)
#self.steer(carstate, output[0, 2], command)
command.steering = output[0, 0]
command.accelerator = output[0, 1]
command.brake = output[0, 2]
if command.accelerator > 0:
if carstate.rpm > 8000:
command.gear = carstate.gear + 1
if command.accelerator < 0:
if carstate.rpm < 2500:
command.gear = carstate.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
#acceleration = output[0,1]*129
#acceleration = math.pow(acceleration, 3)
#if acceleration > 0:
# if abs(carstate.distance_from_center) >= 1:
# off track, reduced grip:
# acceleration = min(0.4, acceleration)
# command.accelerator = min(acceleration, 1)
# if carstate.rpm > 8000:
# command.gear = carstate.gear + 1
#else:
# command.brake = min(-acceleration, 1)
#if carstate.rpm < 2500:
# command.gear = carstate.gear - 1
#if not command.gear:
# command.gear = carstate.gear or 1
#if output[0,0]>0.5:
# ACC_LATERAL_MAX = 6400 * 5
# v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
#else:
# v_x = 0
#self.accelerate(carstate, 85, command)
if self.data_logger:
self.data_logger.log(carstate, command)
return command
def drive(self, carstate: State) -> Command:
'''
Main driving method
'''
command = Command()
# if not cheesus, drive normally
if not self.is_cheesus(carstate):
# Check if car is stuck
self.recovery = self.is_stuck(
carstate) if not self.recovery else self.recovery
# if car is stuck, go into recovery mode
if self.recovery:
command = self.recovery_drive(carstate)
# if car is not stuck, proceed normally
else:
# if car should overtake, go into overtaking mode
if self.should_overtake(carstate):
print("avoidance state:", self.avoidance_state)
command = self.overtake_drive(carstate)
# if car is free of opponents, drive normally
else:
command = self.default_drive(carstate)
# if car has entered cheesus mode
else:
command = self.cheesy_drive(carstate)
self.last_acceleration = command.accelerator
self.epoch += 1
# print("unmoved:", self.epochs_unmoved)
# print("angle:", carstate.angle)
# print("distance center:", carstate.distance_from_center)
# print("speed_x:", carstate.speed_x)
# print("cheesus:", self.cheesus_state)
# print(command)
return command
def overtake_drive(self, carstate):
'''
Behaviour for overtaking opponents
'''
print("Overtaking")
command = Command()
state = state_to_dict(carstate, apply_mask=False)
# collect distance to opponents in front
dist_opponents_f = state['opponents'][17]
dist_opponents_l = state['opponents'][8]
dist_opponents_r = state['opponents'][26]
# sanity checks
if min(state['opponents']) > min(carstate.speed_x, 40):
self.avoidance_state = 0
print("sanity giving back control (opponents)")
return command
if np.abs(carstate.distance_from_center) > .9:
self.avoidance_state = 0
print("sanity giving back control (center)")
return command
# init avoidance steering
avoidance_steering = .1 * np.sign(self.avoidance_state)
# check if already overtaking
if np.abs(self.avoidance_state) == 1 and np.abs(carstate.angle) > min(
10, 250 / carstate.speed_x):
self.avoidance_state = 2 * np.sign(self.avoidance_state)
# check if we should steer back
if np.abs(self.avoidance_state) == 2:
avoidance_steering *= -1
# check if car should stop steering
if np.abs(carstate.angle) < 5:
avoidance_steering = 0
self.avoidance_state = 3 * np.sign(self.avoidance_state)
# check if pass was completed
if self.avoidance_state == 3 and dist_opponents_l > 10:
avoidance_steering = 0
self.avoidance_state = 0
if self.avoidance_state == -3 and dist_opponents_r > 10:
avoidance_steering = 0
self.avoidance_state = 0
# create command
command.steering = avoidance_steering
print("avoidance steering: ", avoidance_steering)
command.accelerator = 1
command.gear = self.my_gear
return command
def drive(self, carstate):
command = Command()
command.steering = carstate.angle / 180
if carstate.angle > 30 or carstate.angle < -30:
command.brake = 0.5
command.accelerator = 0
else:
command.brake = 0
command.accelerator = 1
command.gear = 1
return command
def __init__(self, hidden_dimension, in_file): super(FFNN_Driver, self).__init__() self.model = FFNN(hidden_dimension) self.model.load_state_dict(torch.load(in_file)) self.last_command = Command() self.last_command.accelerator = 1 self.last_command.brake = 0 self.last_command.steering = 0 self.last_command.gear = 1 self.sensor_data = []
def drive(self, carstate: State) -> Command:
command = Command()
current_state = state_to_vector(carstate)
command_vector = self.jesus.take_wheel(current_state)
command = vector_to_command(command_vector)
self.calc_gear(command, carstate)
if self.epoch % 100 == 0:
print(command_vector)
self.epoch += 1
return command
def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track.
"""
global fullData
data = np.empty(25)
data[3] = carstate.speed_x
data[4] = carstate.z
data[5] = carstate.angle
for index, edge in enumerate(carstate.distances_from_edge):
data[3 + index] = edge
# data = torch.from_numpy(data.T)
# data = data.type(torch.FloatTensor)
# data=torch.unsqueeze(data,1)
# data = Variable(data)
net_input = torch.from_numpy(fullData.flatten())
net_input = Variable(net_input.type(torch.FloatTensor))
# force = np.random.random() < 0.5
# data = torch.transpose(data, 0, 1)
predict, hidden_layer = self.model.forward(net_input)
command = Command()
predict = predict[0].data.numpy()
data[0] = predict[0]
data[1] = predict[1]
data[2] = predict[2]
if predict[0] > 0.5:
command.accelerator = 1
else:
command.accelerator = 0
if predict[1] > 0.5:
command.brake = 1
print("BRAKING")
else:
command.brake = 0
command.steer = predict[2]
self.steer(carstate, 0.0, command)
# ACC_LATERAL_MAX = 6400 * 5
# v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
v_x = 300
self.accelerate(carstate, v_x, command)
if self.data_logger:
self.data_logger.log(carstate, command)
fullData = np.delete(fullData, 0, axis=1)
fullData = np.append(fullData, data.reshape((25,1)), axis=1)
return command
def drive(self, carstate: State) -> Command:
# Interesting stuff
command = Command()
self.calc_steering(command)
self.cal_acceleration(command,carstate)
apply_force_field(carstate, command)
self.epochCounter += 1
self.append_data(command,carstate)
self.check_save_data()
print(carstate.distance_from_start)
return command
def drive(self, carstate: State):
# https://github.com/lanquarden/pyScrcClient/blob/master/src/driver.py
steer = (carstate.angle -
carstate.distance_from_center * 0.5) / self.steer_lock
rpm = carstate.rpm
gear = carstate.gear
if self.prev_rpm is None:
up = True
else:
if (self.prev_rpm - rpm) < 0:
up = True
else:
up = False
if up and rpm > 7000:
gear += 1
if not up and rpm < 3000:
gear -= 1
speed = carstate.speed_x
accel = 1 if self.prev_accel is None else self.prev_accel
if speed < self.max_speed:
accel += 0.1
if accel > 1:
accel = 1.0
else:
accel -= 0.1
if accel < 0:
accel = 0.0
command = Command()
command.accelerator = accel
command.steering = steer
command.gear = gear
self.prev_accel = command.accelerator
return command
def drive(self, carstate: State) -> Command:
command = Command()
current_state = state_to_vector(carstate)
self.update_memory(current_state)
state_sequence = self.get_state_sequence()
command_vector = self.jesus.take_wheel(state_sequence)
command = vector_to_command(command_vector)
self.calc_gear(command, carstate)
if self.epoch % 100 == 0:
print(carstate.race_position)
self.epoch += 1
return command
def drive(self, carstate: State) -> Command:
command = Command()
self.smooth_steer(carstate, 0.0, command)
# ACC_LATERAL_MAX = 6400 * 5
# v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
v_x = 80
self.accelerate(carstate, v_x, command)
if self.epochCounter % 500 == 0:
print(state_to_dict(carstate))
self.epochCounter += 1
self.append_data(command, carstate)
return command
def drive(self, carstate: State) -> Command:
cmd = Command()
self.model.predict(carstate)
self.steer(carstate,cmd)
# ACC_LATERAL_MAX = 6400 * 5
# v_x = min(80, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
v_x = 80
self.accelerate(carstate, v_x, cmd)
if self.data_logger:
self.data_logger.log(carstate, cmd)
return cmd
def runModel(self, carstate: State) -> Command:
top_command = Command()
if self.runStack(carstate, top_command, self.toplayers, 'TopLayers'):
return top_command
else:
commands = []
for i, model in enumerate(self.layers):
command = Command()
if not self.runStack(carstate, command, model,
'model' + str(i + 1)):
print(
'Error!!! No layer applicable in model{}!!!!!'.format(
i + 1))
commands.append(command)
weight = self.oracle.activate(self.buildFeatures(carstate))
#weight = sigmoid(weight)
weights = [weight[0], 1.0 - weight[0]]
print('ORACLE:', weights[0])
N = 50
s = ''
for i in range(N):
if i < int(weights[0] * N):
s += '0'
else:
s += '1'
print(s)
command = Command()
for i, w in enumerate(weight):
command.accelerator = w * commands[i].accelerator * np.sign(
commands[i].gear)
command.brake = w * commands[i].brake
command.steering = w * commands[i].steering
self.shift(carstate, command)
return command
def runModel(self, model, carstate: State) -> Command:
command = Command()
l = len(model) - 1
while not model[l].applicable(carstate) and l >= 0:
l -= 1
if l < 0:
print('Error!!! No layer applicable!!!!!')
else:
print('USING LAYER', l)
model[l].step(carstate, command)
return command
def drive(self, carstate: State) -> Command:
# # NN_MODEL
# x_test = self.convert_carstate_to_array(carstate)
# predicted = self.nn_model(Variable(torch.from_numpy(x_test))).data.numpy()
#
# command = Command()
#
# command.accelerator = predicted[0][0]
# command.brake = predicted[0][1]
# command.steering = predicted[0][2]
#
# # if carstate.rpm < 2500:
# # command.gear = carstate.gear - 1
command = Command()
command = self.reservoir_computing(carstate, command)
if not command.gear:
command.gear = carstate.gear or 1
if carstate.rpm > 1500:
command.gear = carstate.gear + 1
return command
def drive(self, carstate: State) -> Command:
command = Command()
self.steer(carstate, 0.0, command)
ACC_LATERAL_MAX = 6400 * 5
#v_x = min(120, math.sqrt(ACC_LATERAL_MAX / abs(command.steering)))
v_x = 120
self.accelerate(carstate, v_x, command)
if self.data_logger:
self.data_logger.log(carstate, command)
return command
def drive(self, car_state: State) -> Command:
"""
Produces driving command in response to newly received car state.
"""
self.last_state = car_state
feature_vector = self.feature_transformer.transform(car_state)
steering, brake, acceleration = self.network.activate(feature_vector)
# print("steering", steering)
# print("brake", brake)
# print("acceleration", acceleration)
command = Command()
command.accelerator = acceleration
command.brake = brake
# push steering into a [-1, 1] range
command.steering = (steering * 2) - 1
if acceleration > 0:
if car_state.rpm > 8000:
command.gear = car_state.gear + 1
if car_state.rpm < 2500 and car_state.gear > 2:
command.gear = car_state.gear - 1
if not command.gear:
command.gear = car_state.gear or 1
if self.data_logger:
self.data_logger.log(car_state, command)
if self.call_number % 100 == 0:
print(command)
print(car_state.distance_raced)
print(self.stop_flag.value)
print()
# early stopping
if self.call_number > 100 and car_state.distance_raced < 10:
self.stop_flag.set(True)
self.call_number += 1
return command
def get_gear(self, carstate):
output = self.net.activate([carstate.rpm / 10000])
# convert the outcome into a command
command = Command()
if (output[0] < -0.5):
gear = carstate.gear - 1
elif (output[0] > 0.5):
gear = carstate.gear + 1
else:
gear = carstate.gear
if gear < 1:
gear = 1
if gear > 6:
gear = 6
return gear
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:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track.
"""
# f = open("Test_data3.txt","a+")
# f.write("\n*** "+str(carstate)+"\n")
command = Command()
# constructing the input
x_predict = [abs(carstate.speed_x)]
x_predict.append(carstate.distance_from_center)
x_predict.append(carstate.angle)
[x_predict.append(i) for i in carstate.distances_from_edge]
x_predict = np.array(x_predict)
x_predict = x_predict.reshape(1, 22)
x_predict = scaler.transform(x_predict)
input_sensor = tf.convert_to_tensor(data_np, np.float32)
# predicting the output
y_predict = output, s_prev = predict_action(x_predict, s_prev, u_z,
w_z, u_r, w_r, u_h, w_h,
w_out)
command.accelerator = y_predict[0][0]
if command.accelerator < 0:
command.brake = y_predict[0][1]
command.steering = y_predict[0][2]
if carstate.rpm < 2500 and carstate.gear > 0:
command.gear = carstate.gear - 1
elif carstate.rpm > 8000:
command.gear = carstate.gear + 1
if not command.gear:
command.gear = carstate.gear or 1
return command
def drive(self, carstate: State) -> Command:
"""
Produces driving command in response to newly received car state.
This is a dummy driving routine, very dumb and not really considering a
lot of inputs. But it will get the car (if not disturbed by other
drivers) successfully driven along the race track.
"""
print('Drive')
input = carstate.to_input_array()
self.distance = carstate.distance_raced
if self.curr_time > carstate.current_lap_time:
self.time += carstate.last_lap_time
self.curr_time = carstate.current_lap_time
try:
output = self.model.step(input)
for i in range(len(output)):
output[i] = max(0, output[i])
print('Out = ' + str(output))
command = Command()
self.accelerate(output[0], output[1], carstate, command)
self.steer(output[2], output[3], carstate, command)
# self.steer(carstate, 0.0, command)
#
# v_x = min(output[0], 300)
#
# self.accelerate(carstate, v_x, command)
except OverflowError as err:
print('--------- OVERFLOW! ---------')
self.saveResults()
raise err
if self.data_logger:
self.data_logger.log(carstate, command)
return command
def drive(self, carstate: State) -> Command:
command = Command()
if self.offTrack(carstate) == False:
current_state = state_to_vector(carstate)
command_vector = self.jesus.take_wheel(current_state)
command = vector_to_command(command_vector)
self.calc_gear(command, carstate)
self.epoch += 1
elif self.offTrack(carstate) == True:
print('Offtrack')
# Car points towards track center and is on LHS of track
if carstate.angle * carstate.distance_from_center > 0 and carstate.distance_from_center > 1:
self.steering = -carstate.angle
self.gear = 1
self.brake = 0
self.accelerate = 0.5
# Car points towards track center and is on RHS of track
if carstate.angle * carstate.distance_from_center > 0 and carstate.distance_from_center < -1:
self.steering = -carstate.angle
self.gear = 1
self.brake = 0
self.accelerate = 0.5
# Car points outwards and is on LHS of track
if carstate.angle * carstate.distance_from_center < 0 and carstate.distance_from_center > 1:
self.steering = -carstate.angle
self.gear = -1
self.brake = 0
self.accelerate = 0.5
# Car points outwards and is on RHS of track
if carstate.angle * carstate.distance_from_center < 0 and carstate.distance_from_center < -1:
self.steering = -carstate.angle
self.gear = -1
self.brake = 0
self.accelerate = 0.5
print(command)
return command
def step(self, carstate: State, command: Command):
command.accelerator = 1
command.brake = 0
command.gear = carstate.gear
if command.gear >= 0 and carstate.rpm > 8000:
command.gear = min(6, command.gear + 1)
if carstate.rpm < 2500 and command.gear > 1:
command.gear = command.gear - 1
if not command.gear:
command.gear = carstate.gear or 1
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:
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:
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
