def simulate(self, bot) -> vec3:
# print('simulate intercept')
# Init vars
c = Car(bot.game.my_car)
b = Ball(bot.game.ball)
t = vec3(bot.target)
intercept = self.location
dt = 1.0 / 60.0
hit = False
min_error = None
# Drive towards intercept (moving in direction of c.forward())
c.rotation = look_at(intercept, c.up())
direction = normalize(intercept - c.location) #c.forward()
advance_distance = norm(intercept - c.location) - c.hitbox(
).half_width[0] - b.collision_radius
translation = direction * advance_distance
sim_start_state: ThrottleFrame = BoostAnalysis().travel_distance(
advance_distance, norm(c.velocity))
c.velocity = direction * sim_start_state.speed
c.location += translation
c.time += sim_start_state.time
bot.ball_predictions = [vec3(b.location)]
while b.time < c.time:
b.step(dt)
bot.ball_predictions.append(vec3(b.location))
# print(c.time, b.time)
# print(c.location, b.location)
# Simulate the collision and resulting
for i in range(60 * 3):
c.location += c.velocity * dt
b.step(dt, c)
# Check if we hit the ball yet
if norm(b.location - c.location) < (c.hitbox().half_width[0] +
b.collision_radius) * 1.05:
hit = True
# print('hit')
# Measure dist from target
error = t - b.location
if hit and (min_error == None or norm(error) < norm(min_error)):
min_error = error
# Record trajectory
bot.ball_predictions.append(vec3(b.location))
if not hit: return None
return min_error
def calculate(car: Car, ball: Ball, target: vec3, ball_predictions=None):
# Init vars
b = Ball(ball)
dt = 1.0 / 60.0
# Generate predictions of ball path
if ball_predictions is None:
ball_predictions = []
for i in range(60 * 5):
b.step(dt)
ball_predictions.append(vec3(b.location))
# Gradually converge on ball location by aiming at a location, checking time to that location,
# and then aiming at the ball's NEW position. Guaranteed to converge (typically in <10 iterations)
# unless the ball is moving away from the car faster than the car's max boost speed
intercept = Intercept(b.location)
intercept.purpose = 'ball'
intercept.boost = True
intercept_ball_position = vec3(b.location)
collision_achieved = False
last_horizontal_error = None
last_horizontal_offset = None
i = 0
max_tries = 101
analyzer = BoostAnalysis() if intercept.boost else ThrottleAnalysis()
while i < max_tries:
i += 1
fake_car = Car(car)
direction = normalize(intercept.location - car.location)
fake_car.rotation = look_at(direction, fake_car.up())
for t in range(60 * 5):
# Step car location with throttle/boost analysis data
# Not super efficient but POITROAE
frame = analyzer.travel_time(dt, norm(fake_car.velocity))
# print('in 1 frame I travel', frame.time, frame.distance, frame.speed)
fake_car.location += direction * frame.distance
fake_car.velocity = direction * frame.speed
fake_car.time += dt
ball_location = ball_predictions[t]
# Check for collision
p = closest_point_on_obb(fake_car.hitbox(), ball_location)
if norm(p - ball_location) <= ball.collision_radius:
direction_vector = p - (fake_car.location - normalize(
fake_car.forward()) * 13.88) # octane center of mass
direction_vector[2] = 0
target_direction_vector = target - ball_location
target_direction_vector[2] = 0
intercept_ball_position = ball_location
direction = atan2(direction_vector[1], direction_vector[0])
ideal_direction = atan2(target_direction_vector[1],
target_direction_vector[0])
horizontal_error = direction - ideal_direction
# intercept.location = vec3(ball_location)
# intercept.time = fake_car.time
# return intercept
# Now descend the hit direction gradient
# Kick off the gradient descent with an arbitrary seed value
if last_horizontal_error is None:
last_horizontal_error = horizontal_error
last_horizontal_offset = 0
if horizontal_error > 0:
horizontal_offset = 25
else:
horizontal_offset = 25
intercept.location = ball_location - normalize(
fake_car.left()) * horizontal_offset
break
# Recursive case of gradient descent
if horizontal_offset == last_horizontal_offset:
gradient = 0
else:
gradient = (horizontal_error - last_horizontal_error
) / (horizontal_offset -
last_horizontal_offset)
if gradient == 0:
predicted_horizontal_offset = horizontal_offset
else:
predicted_horizontal_offset = horizontal_offset - horizontal_error / gradient
# Base case (convergence)
if abs(gradient) < 0.0005:
print(f'convergence in {i} iterations')
print(f'gradient = {gradient}')
print(
f'last_horizontal_offset = {last_horizontal_offset}'
)
print(f'direction = {degrees(direction)}')
print(f'ideal direction = {degrees(ideal_direction)}')
print(f'target = {target}')
print(f'ball_location = {ball_location}')
return intercept
# Edge case exit: offset maxed out
max_horizontal_offset = car.hitbox(
).half_width[1] + ball.collision_radius
if predicted_horizontal_offset > max_horizontal_offset:
predicted_horizontal_offset = max_horizontal_offset
elif predicted_horizontal_offset < -max_horizontal_offset:
predicted_horizontal_offset = -max_horizontal_offset
last_horizontal_offset = horizontal_offset
last_horizontal_error = horizontal_error
horizontal_offset = predicted_horizontal_offset
# Return the latest intercept location and continue descending the gradient
intercept.location = ball_location - normalize(
fake_car.left()) * predicted_horizontal_offset
print(f'iteration {i}')
print(f'gradient = {gradient}')
print(f'horizontal_offset = {horizontal_offset}')
print(f'horizontal_error = {degrees(horizontal_error)}')
# print(f'ideal direction = {degrees(ideal_direction)}')
break
# Check for arrival
if norm(fake_car.location -
intercept.location) < ball.collision_radius / 2:
intercept.location = ball_location
break
if i >= max_tries:
print(
f'Warning: max tries ({max_tries}) exceeded for calculating intercept'
)
return intercept
def get_car_front_center(car: Car):
return car.location + normalize(car.forward()) * car.hitbox(
).half_width[0] + normalize(car.up()) * car.hitbox().half_width[2]
