def _aerial_rpy(ang_vel_start, ang_vel_next, rot, dt):
"""
:param ang_vel_start: beginning step angular velocity (world coordinates)
:param ang_vel_next: next step angular velocity (world coordinates)
:param rot: orientation matrix
:param dt: time step
:return: Vec3 with roll pitch yaw controls
"""
# car's moment of inertia (spherical symmetry)
J = 10.5
# aerial control torque coefficients
T = Vec3(-400.0, -130.0, 95.0)
# aerial damping torque coefficients
H = Vec3(-50.0, -30.0, -20.0)
# get angular velocities in local coordinates
w0_local = dot(ang_vel_start, rot)
w1_local = dot(ang_vel_next, rot)
# PWL equation coefficients
a = [T[i] * dt / J for i in range(0, 3)]
b = [-w0_local[i] * H[i] * dt / J for i in range(0, 3)]
c = [w1_local[i] - (1 + H[i] * dt / J) * w0_local[i] for i in range(0, 3)]
# RL treats roll damping differently
b[0] = 0
return Vec3(
solve_PWL(a[0], b[0], c[0]),
solve_PWL(a[1], b[1], c[1]),
solve_PWL(a[2], b[2], c[2])
)
def align(self, bot, target_rot: Mat33) -> SimpleControllerState:
car = bot.info.my_car
local_forward = dot(target_rot.col(0), car.rot)
local_up = dot(target_rot.col(2), car.rot)
local_ang_vel = dot(car.ang_vel, car.rot)
pitch_ang = math.atan2(-local_forward.z, local_forward.x)
pitch_ang_vel = local_ang_vel.y
yaw_ang = math.atan2(-local_forward.y, local_forward.x)
yaw_ang_vel = -local_ang_vel.z
roll_ang = math.atan2(-local_up.y, local_up.z)
roll_ang_vel = local_ang_vel.x
forwards_dot = dot(target_rot.col(0), car.forward)
roll_scale = forwards_dot**2 if forwards_dot > 0.85 else 0
self.controls.pitch = clip(-3.3 * pitch_ang + 0.8 * pitch_ang_vel, -1,
1)
self.controls.yaw = clip(-3.3 * yaw_ang + 0.9 * yaw_ang_vel, -1, 1)
self.controls.roll = clip(-3 * roll_ang + 0.5 * roll_ang_vel, -1,
1) * roll_scale
self.controls.throttle = 1
return self.controls
def towards(self, bot, target: Vec3, time: float, allowed_uncertainty: float = 0.3, dodge_hit: bool = True):
ball_soon = ball_predict(bot, time)
ball_soon_to_target_dir = normalize(target - ball_soon.pos)
right = dot(axis_to_rotation(Vec3(z=allowed_uncertainty)), ball_soon_to_target_dir)
left = dot(axis_to_rotation(Vec3(z=-allowed_uncertainty)), ball_soon_to_target_dir)
aim_cone = AimCone(right, left)
aim_cone.draw(ball_soon.pos, r=0, g=0)
return self.with_aiming(bot, aim_cone, time, dodge_hit)
def utility_score(self, bot) -> float:
car = bot.info.my_car
ball = bot.info.ball
my_hit_time = predict.time_till_reach_ball(car, ball)
ball_soon = predict.ball_predict(bot, min(my_hit_time, 1.0))
close_to_ball_01 = clip01(1.0 - norm(car.pos - ball_soon.pos) / 3500) ** 0.5 # FIXME Not great
reachable_ball = predict.ball_predict(bot, predict.time_till_reach_ball(bot.info.my_car, ball))
xy_ball_to_goal = xy(bot.info.opp_goal.pos - reachable_ball.pos)
xy_car_to_ball = xy(reachable_ball.pos - bot.info.my_car.pos)
in_position_01 = ease_out(clip01(dot(xy_ball_to_goal, xy_car_to_ball)), 0.5)
# Chase ball right after kickoff. High right after kickoff
kickoff_bias01 = max(0, 1 - bot.info.time_since_last_kickoff * 0.3) * float(bot.info.my_car.objective == Objective.UNKNOWN)
obj_bonus = {
Objective.UNKNOWN: 1,
Objective.GO_FOR_IT: 1,
Objective.FOLLOW_UP: 0,
Objective.ROTATING: 0,
Objective.SOLO: 1,
}[bot.info.my_car.objective]
return clip01(close_to_ball_01 * in_position_01 + kickoff_bias01) * obj_bonus
def exec(self, bot) -> SimpleControllerState:
ct = bot.info.time - self._start_time
controls = SimpleControllerState()
controls.throttle = 1
car = bot.info.my_car
# Target is allowed to be a function that takes bot as a parameter. Check what it is
if callable(self.target):
target = self.target(bot)
else:
target = self.target
# To boost or not to boost, that is the question
car_to_target = target - car.pos
vel_p = proj_onto_size(car.vel, car_to_target)
angle = angle_between(car_to_target, car.forward)
controls.boost = self.boost and angle < self._boost_ang_req and vel_p < self._max_speed
# States of dodge (note reversed order)
# Land on ground
if ct >= self._t_finishing:
self._almost_finished = True
if car.on_ground:
self.done = True
else:
bot.maneuver = RecoveryManeuver(bot)
self.done = True
return controls
elif ct >= self._t_second_unjump:
# Stop pressing jump and rotate and wait for flip is done
pass
elif ct >= self._t_aim:
if ct >= self._t_second_jump:
controls.jump = 1
# Direction, yaw, pitch, roll
if self.target is None:
controls.roll = 0
controls.pitch = -1
controls.yaw = 0
else:
target_local = dot(car_to_target, car.rot)
target_local.z = 0
direction = normalize(target_local)
controls.roll = 0
controls.pitch = -direction.x
controls.yaw = sign(car.rot.get(2, 2)) * direction.y
# Stop pressing jump
elif ct >= self._t_first_unjump:
pass
# First jump
else:
controls.jump = 1
return controls
def exec(self, bot):
car = bot.info.my_car
# For testing
# f = normalize(bot.info.ball.pos - car.pos)
# l = cross(f, Vec3(z=1))
# u = cross(l, f)
# self.target = Mat33.from_columns(f, l, u)
bot.renderer.draw_line_3d(car.pos, car.pos + 200 * self.target.col(0), bot.renderer.red())
bot.renderer.draw_line_3d(car.pos, car.pos + 200 * self.target.col(1), bot.renderer.green())
bot.renderer.draw_line_3d(car.pos, car.pos + 200 * self.target.col(2), bot.renderer.blue())
self.done |= car.on_ground
local_forward = dot(self.target.col(0), car.rot)
local_up = dot(self.target.col(2), car.rot)
local_ang_vel = dot(car.ang_vel, car.rot)
pitch_ang = math.atan2(local_forward.z, local_forward.x)
pitch_ang_vel = local_ang_vel.y
yaw_ang = math.atan2(-local_forward.y, local_forward.x)
yaw_ang_vel = -local_ang_vel.z
roll_ang = math.atan2(-local_up.y, local_up.z)
roll_ang_vel = local_ang_vel.x
P_pitch = 3.8
D_pitch = 0.8
P_yaw = -3.8
D_yaw = 0.9
P_roll = -3.3
D_roll = 0.5
uprightness = dot(car.up, self.target.col(2))
yaw_scale = 0.0 if uprightness < 0.6 else uprightness ** 2
return SimpleControllerState(
pitch=clip(P_pitch * pitch_ang + D_pitch * pitch_ang_vel, -1, 1),
yaw=clip((P_yaw * yaw_ang + D_yaw * yaw_ang_vel) * yaw_scale, -1, 1),
roll=clip(P_roll * roll_ang + D_roll * roll_ang_vel, -1, 1),
throttle=1.0,
)
def exec(self, bot):
controls = SimpleControllerState()
dt = bot.info.dt
car = bot.info.my_car
relative_rotation = dot(transpose(car.rot), self.target)
geodesic_local = rotation_to_axis(relative_rotation)
# figure out the axis of minimal rotation to target
geodesic_world = dot(car.rot, geodesic_local)
# get the angular acceleration
alpha = Vec3(
self.controller(geodesic_world.x, car.ang_vel.x, dt),
self.controller(geodesic_world.y, car.ang_vel.y, dt),
self.controller(geodesic_world.z, car.ang_vel.z, dt)
)
# reduce the corrections for when the solution is nearly converged
alpha.x = self.q(abs(geodesic_world.x) + abs(car.ang_vel.x)) * alpha.x
alpha.y = self.q(abs(geodesic_world.y) + abs(car.ang_vel.y)) * alpha.y
alpha.z = self.q(abs(geodesic_world.z) + abs(car.ang_vel.z)) * alpha.z
# set the desired next angular velocity
ang_vel_next = car.ang_vel + alpha * dt
# determine the controls that produce that angular velocity
roll_pitch_yaw = AerialTurnManeuver.aerial_rpy(car.ang_vel, ang_vel_next, car.rot, dt)
controls.roll = roll_pitch_yaw.x
controls.pitch = roll_pitch_yaw.y
controls.yaw = roll_pitch_yaw.z
self._timer += dt
if ((norm(car.ang_vel) < self.epsilon_ang_vel and
norm(geodesic_world) < self.epsilon_rotation) or
self._timer >= self.timeout or car.on_ground):
self.done = True
controls.throttle = 1.0
return controls
def draw_circle(bot, center: Vec3, normal: Vec3, radius: float, pieces: int):
# Construct the arm that will be rotated
arm = normalize(cross(normal, center)) * radius
angle = 2 * math.pi / pieces
rotation_mat = axis_to_rotation(angle * normalize(normal))
points = [center + arm]
for i in range(pieces):
arm = dot(rotation_mat, arm)
points.append(center + arm)
bot.renderer.draw_polyline_3d(points, bot.renderer.orange())
def circle(self, center: Vec3, normal: Vec3, radius: float, color):
# Construct the arm that will be rotated
pieces = int(radius**0.7) + 5
arm = normalize(vec.cross(normal, center)) * radius
angle = 2 * math.pi / pieces
rotation_mat = axis_to_rotation(angle * normalize(normal))
points = [center + arm]
for i in range(pieces):
arm = dot(rotation_mat, arm)
points.append(center + arm)
self.renderer.draw_polyline_3d(points, color)
def stay_at(self, bot, point: Vec3, looking_at: Vec3):
OKAY_DIST = 100
car = bot.info.my_car
car_to_point = point - car.pos
car_to_point_dir = normalize(point - car.pos)
dist = norm(car_to_point)
if dist > OKAY_DIST:
return self.towards_point(bot, point, int(dist * 2))
else:
look_dir = normalize(looking_at - car.pos)
facing_correctly = dot(car.forward, look_dir) > 0.9
if facing_correctly:
return SimpleControllerState()
else:
ctrls = SimpleControllerState()
ctrls.throttle = 0.7 * sign(dot(car.forward, car_to_point_dir))
ctrls.steer = -ctrls.throttle * sign(
dot(car.left, car_to_point_dir))
return ctrls
def exec(self, bot):
car = bot.info.my_car
ball = bot.info.ball
car_to_ball = ball.pos - car.pos
ball_to_enemy_goal = bot.info.enemy_goal - ball.pos
own_goal_to_ball = ball.pos - bot.info.own_goal
dist = norm(car_to_ball)
offence = ball.pos.y * bot.info.team_sign < 0
dot_enemy = dot(car_to_ball, ball_to_enemy_goal)
dot_own = dot(car_to_ball, own_goal_to_ball)
right_side_of_ball = dot_enemy > 0 if offence else dot_own > 0
if right_side_of_ball:
# Aim cone
dir_to_post_1 = (bot.info.enemy_goal +
Vec3(3800, 0, 0)) - bot.info.ball.pos
dir_to_post_2 = (bot.info.enemy_goal +
Vec3(-3800, 0, 0)) - bot.info.ball.pos
cone = AimCone(dir_to_post_1, dir_to_post_2)
cone.get_goto_point(bot, car.pos, bot.info.ball.pos)
if bot.do_rendering:
cone.draw(bot, bot.info.ball.pos)
# Chase ball
return bot.drive.go_towards_point(bot,
xy(ball.pos),
2000,
True,
True,
can_dodge=dist > 2200)
else:
# Go home
return bot.drive.go_towards_point(bot, bot.info.own_goal_field,
2000, True, True)
def sdf_wall_dist(point: Vec3) -> float:
"""
Returns the distance to the nearest wall of using an SDF approximation.
The result is negative if the point is outside the arena.
"""
# SDF box https://www.youtube.com/watch?v=62-pRVZuS5c
# SDF rounded corners https://www.youtube.com/watch?v=s5NGeUV2EyU
ONES = Vec3(1, 1, 1)
# Base cube
base_q = abs(point -
Vec3(z=Field.HEIGHT / 2)) - SEMI_SIZE + ONES * ROUNDNESS
base_dist_outside = norm(vec_max(base_q, Vec3()))
base_dist_inside = min(max_comp(base_q), 0)
base_dist = base_dist_outside + base_dist_inside
# Corners cube
corner_q = abs((dot(ROT_45_MAT, point)) - Vec3(
z=Field.HEIGHT / 2)) - CORNER_SEMI_SIZE + ONES * ROUNDNESS
corner_dist_outside = norm(vec_max(corner_q, Vec3()))
corner_dist_inside = min(max_comp(corner_q), 0)
corner_dist = corner_dist_outside + corner_dist_inside
# Intersection of base and corners
base_corner_dist = max(base_dist, corner_dist) - ROUNDNESS
# Goals cube
goals_q = abs(point - Vec3(z=Field.GOAL_HEIGHT /
2)) - GOALS_SEMI_SIZE + ONES * ROUNDNESS
goals_dist_outside = norm(vec_max(goals_q, Vec3()))
goals_dist_inside = min(max_comp(goals_q), 0)
goals_dist = base_dist_outside + base_dist_inside
# Union with goals and invert result
return -min(base_corner_dist, goals_dist)
def update(self, bot):
ball = bot.info.ball
# Find closest foe to ball
self.opp_closest_to_ball, self.opp_closest_to_ball_dist = argmin(bot.info.opponents, lambda opp: norm(opp.pos - ball.pos))
# Possession and on/off-site
self.car_with_possession = None
self.ally_with_possession = None
self.opp_with_possession = None
for car in bot.info.cars:
# Effective position
car.effective_pos = car.pos + xy(car.vel) * 0.8
# On site
car_to_ball = ball.pos - car.pos
car_to_ball_unit = normalize(car_to_ball)
car.onsite = dot(Vec3(y=-car.team_sign), car_to_ball_unit)
# Reach ball time
car.reach_ball_time = predict.time_till_reach_ball(car, ball)
reach01 = 1 - 0.9 * lin_fall(car.reach_ball_time, 4) ** 0.5
# Possession
point_in_front = car.pos + car.vel * 0.5
ball_point_dist = norm(ball.pos - point_in_front)
dist01 = 1000 / (1000 + ball_point_dist) # Halved after 1000 uu of dist, 1/3 at 2000
in_front01 = (dot(car.forward, car_to_ball_unit) + 1) / 2.0
car.possession = dist01 * in_front01 * reach01
if self.car_with_possession is None or car.possession > self.car_with_possession.possession:
self.car_with_possession = car
if car.team == bot.team and (self.ally_with_possession is None or car.possession > self.ally_with_possession.possession):
self.ally_with_possession = car
if car.team != bot.team and (self.opp_with_possession is None or car.possession > self.opp_with_possession.possession):
self.opp_with_possession = car
# Objectives
if len(bot.info.team_cars) == 1:
# No team mates. No roles
bot.info.my_car.objective = bot.info.my_car.last_objective = Objective.SOLO
return
for car in bot.info.cars:
car.last_objective = car.objective
car.objective = Objective.UNKNOWN
attacker, attacker_score = argmax(bot.info.team_cars,
lambda ally: ((1.0 if ally.last_objective == Objective.GO_FOR_IT else 0.73)
* ease_out(0.2 + 0.8 * ally.boost / 100, 2) # 50 boost is 0.85, 0 boost is 0.2
* ally.possession
* ally.got_it_according_to_quick_chat_01(bot.info.time)
* (1.0 if ally.onsite else 0.5)
* (0 if ally.is_demolished else 1)))
attacker.objective = Objective.GO_FOR_IT
self.ideal_follow_up_pos = xy(ball.pos + bot.info.own_goal.pos) * 0.5
follower, follower_score = argmax([ally for ally in bot.info.team_cars if ally.objective == Objective.UNKNOWN],
lambda ally: (1.0 if ally.last_objective == Objective.FOLLOW_UP else 0.73)
* ease_out(0.2 * 0.8 * ally.boost / 100, 2)
* (1 + ally.onsite / 2)
* lin_fall(norm(ally.effective_pos - self.ideal_follow_up_pos), 3000)
* (0 if ally.is_demolished else 1))
if follower is not None:
follower.objective = Objective.FOLLOW_UP
for car in bot.info.team_cars:
if car.objective == Objective.UNKNOWN:
car.objective = Objective.ROTATING
def exec(self, bot) -> SimpleControllerState:
car = bot.info.my_car
ball = bot.info.ball
my_hit_time = predict.time_till_reach_ball(car, ball)
shoot_controls = bot.shoot.with_aiming(bot, self.aim_cone, my_hit_time)
if bot.do_rendering:
self.aim_cone.draw(bot, bot.shoot.ball_when_hit.pos, b=0)
hit_pos = bot.shoot.ball_when_hit.pos
dist = norm(car.pos - hit_pos)
closest_enemy, enemy_dist = bot.info.closest_enemy(
0.5 * (hit_pos + ball.pos))
if not bot.shoot.can_shoot and is_closer_to_goal_than(
car.pos, hit_pos, bot.info.team):
# Can't shoot but or at least on the right side: Chase
goal_to_ball = normalize(hit_pos - bot.info.enemy_goal)
offset_ball = hit_pos + goal_to_ball * Ball.RADIUS * 0.9
enemy_hit_time = predict.time_till_reach_ball(closest_enemy, ball)
enemy_hit_pos = predict.ball_predict(bot, enemy_hit_time).pos
if enemy_hit_time < 1.5 * my_hit_time:
self.temp_utility_desire_boost -= bot.info.dt
if bot.do_rendering:
bot.renderer.draw_line_3d(closest_enemy.pos, enemy_hit_pos,
bot.renderer.red())
return bot.drive.go_home(bot)
if bot.do_rendering:
bot.renderer.draw_line_3d(car.pos, offset_ball,
bot.renderer.yellow())
return bot.drive.go_towards_point(bot,
offset_ball,
target_vel=2200,
slide=False,
boost_min=0)
elif not bot.shoot.aim_is_ok and hit_pos.y * -bot.info.team_sign > 4250 and abs(
hit_pos.x) > 900 and not dist < 420:
# hit_pos is an enemy corner and we are not close: Avoid enemy corners and just wait
enemy_to_ball = normalize(hit_pos - closest_enemy.pos)
wait_point = hit_pos + enemy_to_ball * enemy_dist # a point 50% closer to the center of the field
wait_point = lerp(wait_point,
ball.pos + Vec3(0, bot.info.team_sign * 3000, 0),
0.5)
if bot.do_rendering:
bot.renderer.draw_line_3d(car.pos, wait_point,
bot.renderer.yellow())
return bot.drive.go_towards_point(bot,
wait_point,
norm(car.pos - wait_point),
slide=False,
can_keep_speed=True,
can_dodge=False)
elif not bot.shoot.can_shoot:
enemy_to_ball = normalize(xy(ball.pos - closest_enemy.pos))
ball_to_my_goal = normalize(xy(bot.info.own_goal - ball.pos))
dot_threat = dot(
enemy_to_ball, ball_to_my_goal
) # 1 = enemy is in position, -1 = enemy is NOT in position
if car.boost == 0 and ball.pos.y * bot.info.team_sign < 500 and dot_threat < 0.1:
collect_center = ball.pos.y * bot.info.team_sign <= 0
collect_small = closest_enemy.pos.y * bot.info.team_sign <= 0 or enemy_dist < 900
pads = filter_pads(bot,
bot.info.big_boost_pads,
big_only=not collect_small,
enemy_side=False,
center=collect_center)
bot.maneuver = CollectClosestBoostManeuver(bot, pads)
# return home
return bot.drive.go_home(bot)
else:
# Shoot !
if bot.shoot.using_curve and bot.do_rendering:
rendering.draw_bezier(
bot, [car.pos, bot.shoot.curve_point, hit_pos])
return shoot_controls
def with_aiming(self,
bot,
aim_cone: AimCone,
time: float,
dodge_hit: bool = True):
# aim: | | | |
# ball | bad | ok | good |
# z pos: | | | |
# -----------+-----------+-----------+-----------+
# too high | give | give | wait/ |
# | up | up | improve |
# -----------+ - - - - - + - - - - - + - - - - - +
# medium | give | improve | aerial |
# | up | aim | |
# -----------+ - - - - - + - - - - - + - - - - - +
# soon on | improve | slow | small |
# ground | aim | curve | jump |
# -----------+ - - - - - + - - - - - + - - - - - +
# on ground | improve | fast | fast |
# | aim?? | curve | straight |
# -----------+ - - - - - + - - - - - + - - - - - +
# FIXME if the ball is not on the ground we treat it as 'soon on ground' in all other cases
self.controls = SimpleControllerState()
self.aim_is_ok = False
self.waits_for_fall = False
self.ball_is_flying = False
self.can_shoot = False
self.using_curve = False
self.curve_point = None
self.ball_when_hit = None
car = bot.info.my_car
ball_soon = ball_predict(bot, time)
car_to_ball_soon = ball_soon.pos - car.pos
dot_facing_score = dot(normalize(car_to_ball_soon),
normalize(car.forward))
vel_towards_ball_soon = proj_onto_size(car.vel, car_to_ball_soon)
is_facing = 0 < dot_facing_score
if ball_soon.pos.z < 110 or (ball_soon.pos.z < 475 and ball_soon.vel.z
<= 0) or True: #FIXME Always true
# The ball is on the ground or soon on the ground
if 275 < ball_soon.pos.z < 475 and aim_cone.contains_direction(
car_to_ball_soon):
# Can we hit it if we make a small jump?
vel_f = proj_onto_size(car.vel, xy(car_to_ball_soon))
car_expected_pos = car.pos + car.vel * time
ball_soon_flat = xy(ball_soon.pos)
diff = norm(car_expected_pos - ball_soon_flat)
ball_in_front = dot(ball_soon.pos - car_expected_pos,
car.vel) > 0
if bot.do_rendering:
bot.renderer.draw_line_3d(car.pos, car_expected_pos,
bot.renderer.lime())
bot.renderer.draw_rect_3d(car_expected_pos, 12, 12, True,
bot.renderer.lime())
if vel_f > 400:
if diff < 150 and ball_in_front:
bot.maneuver = SmallJumpManeuver(
bot, lambda b: b.info.ball.pos)
if 110 < ball_soon.pos.z: # and ball_soon.vel.z <= 0:
# The ball is slightly in the air, lets wait just a bit more
self.waits_for_fall = True
ball_landing = next_ball_landing(bot, ball_soon, size=100)
time = time + ball_landing.time
ball_soon = ball_predict(bot, time)
car_to_ball_soon = ball_soon.pos - car.pos
self.ball_when_hit = ball_soon
# The ball is on the ground, are we in position for a shot?
if aim_cone.contains_direction(car_to_ball_soon) and is_facing:
# Straight shot
self.aim_is_ok = True
self.can_shoot = True
if norm(car_to_ball_soon) < 240 + Ball.RADIUS and aim_cone.contains_direction(car_to_ball_soon)\
and vel_towards_ball_soon > 300:
bot.drive.start_dodge(bot)
offset_point = xy(
ball_soon.pos) - 50 * aim_cone.get_center_dir()
speed = self.determine_speed(norm(car_to_ball_soon), time)
self.controls = bot.drive.go_towards_point(
bot,
offset_point,
target_vel=speed,
slide=True,
boost_min=0,
can_keep_speed=False)
return self.controls
elif aim_cone.contains_direction(car_to_ball_soon, math.pi / 5):
# Curve shot
self.aim_is_ok = True
self.using_curve = True
self.can_shoot = True
offset_point = xy(
ball_soon.pos) - 50 * aim_cone.get_center_dir()
closest_dir = aim_cone.get_closest_dir_in_cone(
car_to_ball_soon)
self.curve_point = curve_from_arrival_dir(
car.pos, offset_point, closest_dir)
self.curve_point.x = clip(self.curve_point.x, -Field.WIDTH / 2,
Field.WIDTH / 2)
self.curve_point.y = clip(self.curve_point.y,
-Field.LENGTH / 2, Field.LENGTH / 2)
if dodge_hit and norm(car_to_ball_soon) < 240 + Ball.RADIUS and angle_between(car.forward, car_to_ball_soon) < 0.5\
and aim_cone.contains_direction(car_to_ball_soon) and vel_towards_ball_soon > 300:
bot.drive.start_dodge(bot)
speed = self.determine_speed(norm(car_to_ball_soon), time)
self.controls = bot.drive.go_towards_point(
bot,
self.curve_point,
target_vel=speed,
slide=True,
boost_min=0,
can_keep_speed=False)
return self.controls
else:
# We are NOT in position!
self.aim_is_ok = False
pass
else:
if aim_cone.contains_direction(car_to_ball_soon):
self.waits_for_fall = True
self.aim_is_ok = True
#self.can_shoot = False
pass # Allow small aerial (wait if ball is too high)
elif aim_cone.contains_direction(car_to_ball_soon, math.pi / 4):
self.ball_is_flying = True
pass # Aim is ok, but ball is in the air
def exec(self, bot):
if not self.announced_in_quick_chat:
self.announced_in_quick_chat = True
bot.send_quick_chat(QuickChats.CHAT_EVERYONE, QuickChats.Information_IGotIt)
ct = bot.info.time
car = bot.info.my_car
up = car.up
controls = SimpleControllerState()
# Time remaining till intercept time
T = self.intercept_time - bot.info.time
# Expected future position
xf = car.pos + car.vel * T + 0.5 * GRAVITY * T ** 2
# Expected future velocity
vf = car.vel + GRAVITY * T
# Is set to false while jumping to avoid FeelsBackFlipMan
rotate = True
if self.jumping:
if self.jump_begin_time == -1:
jump_elapsed = 0
self.jump_begin_time = ct
else:
jump_elapsed = ct - self.jump_begin_time
# How much longer we can press jump and still gain upward force
tau = JUMP_MAX_DUR - jump_elapsed
# Add jump pulse
if jump_elapsed == 0:
vf += up * JUMP_SPEED
xf += up * JUMP_SPEED * T
rotate = False
# Acceleration from holding jump
vf += up * JUMP_SPEED * tau
xf += up * JUMP_SPEED * tau * (T - 0.5 * tau)
if self.do_second_jump:
# Impulse from the second jump
vf += up * JUMP_SPEED
xf += up * JUMP_SPEED * (T - tau)
if jump_elapsed < JUMP_MAX_DUR:
controls.jump = True
else:
controls.jump = False
if self.do_second_jump:
if self.jump_pause_counter < 4:
# Do a 4-tick pause between jumps
self.jump_pause_counter += 1
else:
# Time to start second jump
# we do this by resetting our jump counter and pretend and our aerial started in the air
self.jump_begin_time = -1
self.jumping = True
self.do_second_jump = False
else:
# We are done jumping
self.jumping = False
else:
controls.jump = False
delta_pos = self.hit_pos - xf
direction = normalize(delta_pos)
car_to_hit_pos = self.hit_pos - car.pos
dodging = self.dodge_begin_time != -1
if dodging:
controls.jump = True
# We are not pressing jump, so let's align the car
if rotate and not dodging:
if self.do_dodge and norm(car_to_hit_pos) < Ball.RADIUS + 80:
# Start dodge
self.dodge_begin_time = ct
hit_local = dot(car_to_hit_pos, car.rot)
hit_local.z = 0
dodge_direction = normalize(hit_local)
controls.roll = 0
controls.pitch = -dodge_direction.x
controls.yaw = sign(car.rot.get(2, 2)) * direction.y
controls.jump = True
else:
# Adjust orientation
if norm(delta_pos) > 50:
pd = bot.fly.align(bot, looking_in_dir(delta_pos))
else:
if self.target_rot is not None:
pd = bot.fly.align(bot, self.target_rot)
else:
pd = bot.fly.align(bot, looking_in_dir(self.hit_pos - car.pos))
controls.roll = pd.roll
controls.pitch = pd.pitch
controls.yaw = pd.yaw
if not dodging and angle_between(car.forward, direction) < 0.3:
if norm(delta_pos) > 40:
controls.boost = 1
controls.throttle = 0
else:
controls.boost = 0
controls.throttle = clip01(0.5 * THROTTLE_AIR_ACCEL * T ** 2)
else:
controls.boost = 0
controls.throttle = 0
prediction = predict.ball_predict(bot, T)
self.done = T < 0
if norm(self.hit_pos - prediction.pos) > 50:
# Jump shot failed
self.done = True
bot.send_quick_chat(QuickChats.CHAT_EVERYONE, QuickChats.Apologies_Cursing)
if bot.do_rendering:
car_to_hit_dir = normalize(self.hit_pos - car.pos)
color = bot.renderer.pink()
rendering.draw_cross(bot, self.hit_pos, color, arm_length=100)
rendering.draw_circle(bot, lerp(car.pos, self.hit_pos, 0.25), car_to_hit_dir, 40, 12, color)
rendering.draw_circle(bot, lerp(car.pos, self.hit_pos, 0.5), car_to_hit_dir, 40, 12, color)
rendering.draw_circle(bot, lerp(car.pos, self.hit_pos, 0.75), car_to_hit_dir, 40, 12, color)
bot.renderer.draw_line_3d(car.pos, self.hit_pos, color)
return controls
def towards_point(self,
bot,
point: Vec3,
target_vel=1430,
slide=False,
boost_min=101,
can_keep_speed=True,
can_dodge=True,
wall_offset_allowed=125) -> SimpleControllerState:
REQUIRED_ANG_FOR_SLIDE = 1.65
REQUIRED_VELF_FOR_DODGE = 1100
car = bot.info.my_car
# Dodge is done
if self.dodge is not None and self.dodge.done:
self.dodge = None
self.last_dodge_end_time = bot.info.time
# Continue dodge
elif self.dodge is not None:
self.dodge.target = point
return self.dodge.exec(bot)
# Begin recovery
if not car.on_ground:
bot.maneuver = RecoveryManeuver()
return self.controls
# Get down from wall by choosing a point close to ground
if not is_near_wall(point, wall_offset_allowed) and angle_between(
car.up, Vec3(0, 0, 1)) > math.pi * 0.31:
point = lerp(xy(car.pos), xy(point), 0.5)
# If the car is in a goal, avoid goal posts
self._avoid_goal_post(bot, point)
car_to_point = point - car.pos
# The vector from the car to the point in local coordinates:
# point_local.x: how far in front of my car
# point_local.y: how far to the left of my car
# point_local.z: how far above my car
point_local = dot(point - car.pos, car.rot)
# Angle to point in local xy plane and other stuff
angle = math.atan2(point_local.y, point_local.x)
dist = norm(point_local)
vel_f = proj_onto_size(car.vel, car.forward)
vel_towards_point = proj_onto_size(car.vel, car_to_point)
# Start dodge
if can_dodge and abs(angle) <= 0.02 and vel_towards_point > REQUIRED_VELF_FOR_DODGE\
and dist > vel_towards_point + 500 + 900 and bot.info.time > self.last_dodge_end_time + self.dodge_cooldown:
self.dodge = DodgeManeuver(bot, point)
# Start half-flip
elif can_dodge and abs(angle) >= 3 and vel_towards_point < 0\
and dist > -vel_towards_point + 500 + 900 and bot.info.time > self.last_dodge_end_time + self.dodge_cooldown:
self.dodge = HalfFlipManeuver(bot,
boost=car.boost > boost_min + 10)
# Is point right behind? Maybe reverse instead
if -100 < point_local.x < 0 and abs(point_local.y) < 50:
#bot.print("Reversing?")
pass
# Is in turn radius deadzone?
tr = turn_radius(abs(vel_f + 50)) # small bias
tr_side = sign(angle)
tr_center_local = Vec3(0, tr * tr_side, 10)
point_is_in_turn_radius_deadzone = norm(point_local -
tr_center_local) < tr
# Draw turn radius deadzone
if car.on_ground and False:
tr_center_world = car.pos + dot(car.rot, tr_center_local)
tr_center_world_2 = car.pos + dot(car.rot, -1 * tr_center_local)
color = draw.orange()
draw.circle(tr_center_world, car.up, tr, color)
draw.circle(tr_center_world_2, car.up, tr, color)
if point_is_in_turn_radius_deadzone:
# Hard turn
self.controls.steer = sign(angle)
self.controls.boost = False
self.controls.throttle = 0 if vel_f > 150 else 0.1
if point_local.x < 110 and point_local.y < 400 and norm(
car.vel) < 300:
# Brake or go backwards when the point is really close but not in front of us
self.controls.throttle = clip(-0.25 + point_local.x / -110.0,
0, -1)
self.controls.steer = -0.5 * sign(angle)
else:
# Should drop speed or just keep up the speed?
if can_keep_speed and target_vel < vel_towards_point:
target_vel = vel_towards_point
else:
# Small lerp adjustment
target_vel = lerp(vel_towards_point, target_vel, 1.1)
# Turn and maybe slide
self.controls.steer = clip(angle + (2.5 * angle)**3, -1.0, 1.0)
if slide and abs(angle) > REQUIRED_ANG_FOR_SLIDE:
self.controls.handbrake = True
self.controls.steer = sign(angle)
else:
self.controls.handbrake = False
# Overshoot target vel for quick adjustment
target_vel = lerp(vel_towards_point, target_vel, 1.2)
# Find appropriate throttle/boost
if vel_towards_point < target_vel:
self.controls.throttle = 1
if boost_min < car.boost and vel_towards_point + 80 < target_vel and target_vel > 1400 \
and not self.controls.handbrake and is_heading_towards(angle, dist):
self.controls.boost = True
else:
self.controls.boost = False
else:
vel_delta = target_vel - vel_towards_point
self.controls.throttle = clip(0.2 + vel_delta / 500, 0, -1)
self.controls.boost = False
if self.controls.handbrake:
self.controls.throttle = min(0.4, self.controls.throttle)
# Saved if something outside calls start_dodge() in the meantime
self.last_point = point
return self.controls
def with_aiming(self, bot, aim_cone: AimCone, time: float, dodge_hit: bool = True):
# aim: | | | |
# ball | bad | ok | good |
# z pos: | | | |
# -----------+-----------+-----------+-----------+
# too high | give | give | wait/ |
# > 1200 | up | up | improve |
# -----------+ - - - - - + - - - - - + - - - - - +
# medium | give | improve | aerial |
# | up | aim | |
# -----------+ - - - - - + - - - - - + - - - - - +
# soon on | improve | slow | small |
# ground | aim | curve | jump |
# -----------+ - - - - - + - - - - - + - - - - - +
# on ground | improve | fast | fast |
# | aim?? | curve | straight |
# -----------+ - - - - - + - - - - - + - - - - - +
# FIXME if the ball is not on the ground we treat it as 'soon on ground' in all other cases
self.controls = SimpleControllerState()
self.aim_is_ok = False
self.waits_for_fall = False
self.ball_is_flying = False
self.can_shoot = False
self.using_curve = False
self.curve_point = None
car = bot.info.my_car
ball_soon = ball_predict(bot, time)
car_to_ball_soon = ball_soon.pos - car.pos
dot_facing_score = dot(normalize(car_to_ball_soon), normalize(car.forward))
dot_facing_score_2d = dot(normalize(xy(car_to_ball_soon)), normalize(xy(car.forward)))
vel_towards_ball_soon = proj_onto_size(car.vel, car_to_ball_soon)
is_facing = 0.1 < dot_facing_score
is_facing_2d = 0.3 < dot_facing_score
self.ball_when_hit = ball_soon
if ball_soon.pos.z < 110:
# The ball is on the ground
if 110 < ball_soon.pos.z: # and ball_soon.vel.z <= 0:
# The ball is slightly in the air, lets wait just a bit more
self.waits_for_fall = True
ball_landing = next_ball_landing(bot, ball_soon, size=100)
time = time + ball_landing.time
ball_soon = ball_predict(bot, time)
car_to_ball_soon = ball_soon.pos - car.pos
self.ball_when_hit = ball_soon
# The ball is on the ground, are we in position for a shot?
if aim_cone.contains_direction(car_to_ball_soon) and is_facing:
# Straight shot
self.aim_is_ok = True
self.can_shoot = True
if norm(car_to_ball_soon) < 400 + Ball.RADIUS and aim_cone.contains_direction(car_to_ball_soon)\
and vel_towards_ball_soon > 300:
bot.drive.start_dodge(bot, towards_ball=True)
offset_point = xy(ball_soon.pos) - 50 * aim_cone.get_center_dir()
speed = self._determine_speed(norm(car_to_ball_soon), time)
self.controls = bot.drive.towards_point(bot, offset_point, target_vel=speed, slide=True, boost_min=0, can_keep_speed=False)
return self.controls
elif aim_cone.contains_direction(car_to_ball_soon, math.pi / 5):
# Curve shot
self.aim_is_ok = True
self.using_curve = True
self.can_shoot = True
offset_point = xy(ball_soon.pos) - 50 * aim_cone.get_center_dir()
closest_dir = aim_cone.get_closest_dir_in_cone(car_to_ball_soon)
self.curve_point = curve_from_arrival_dir(car.pos, offset_point, closest_dir)
self.curve_point.x = clip(self.curve_point.x, -Field.WIDTH / 2, Field.WIDTH / 2)
self.curve_point.y = clip(self.curve_point.y, -Field.LENGTH / 2, Field.LENGTH / 2)
if dodge_hit and norm(car_to_ball_soon) < 400 + Ball.RADIUS and angle_between(car.forward, car_to_ball_soon) < 0.5\
and aim_cone.contains_direction(car_to_ball_soon) and vel_towards_ball_soon > 300:
bot.drive.start_dodge(bot, towards_ball=True)
speed = self._determine_speed(norm(car_to_ball_soon), time)
self.controls = bot.drive.towards_point(bot, self.curve_point, target_vel=speed, slide=True, boost_min=0, can_keep_speed=False)
return self.controls
else:
# We are NOT in position!
return None
elif ball_soon.pos.z < 600 and ball_soon.vel.z <= 0:
# Ball is on ground soon. Is it worth waiting? TODO if aim is bad, do a slow curve - or delete case?
pass
# ---------------------------------------
# Ball is in the air, or going in the air
if 200 < ball_soon.pos.z < 1400 and aim_cone.contains_direction(car_to_ball_soon) and is_facing_2d:
# Can we hit it if we make jump shot or aerial shot?
vel_f = proj_onto_size(car.vel, xy(car_to_ball_soon))
aerial = ball_soon.pos.z > 750
if vel_f > 400: # Some forward momentum is required
flat_dist = norm(xy(car_to_ball_soon))
# This range should be good https://www.desmos.com/calculator/bx9imtiqi5
good_height = 0.3 * ball_soon.pos.z < flat_dist < 4 * ball_soon.pos.z
if good_height:
# Alternative ball positions
alternatives = [
(ball_predict(bot, time * 0.8), time * 0.8),
(ball_predict(bot, time * 0.9), time * 0.9),
(ball_soon, time),
(ball_predict(bot, time * 1.1), time * 1.1),
(ball_predict(bot, time * 1.2), time * 1.2)
]
for alt_ball, alt_time in alternatives:
potential_small_jump_shot = JumpShotManeuver(bot, alt_ball.pos, bot.info.time + alt_time, do_second_jump=aerial)
jump_shot_viable = potential_small_jump_shot.is_viable(car, bot.info.time)
if jump_shot_viable:
self.can_shoot = True
self.aim_is_ok = True
bot.maneuver = potential_small_jump_shot
return bot.maneuver.exec(bot)
self.ball_is_flying = True
return self.controls
def intersects_normal(src: Vec3, dest: Vec3, plane_normal: Vec3) -> bool:
# Also, if one of the points are on the plane, true is returned
return dot(src, plane_normal) * dot(dest, plane_normal) <= 0
def project_onto_normal(pos: Vec3, normal: Vec3) -> Vec3:
dist = dot(pos, normal)
antidote = -dist * normal
return pos + antidote
def run(self, bot) -> SimpleControllerState:
car = bot.info.my_car
ball = bot.info.ball
my_hit_time = predict.time_till_reach_ball(car, ball)
reachable_ball = predict.ball_predict(bot, predict.time_till_reach_ball(car, ball))
ball_to_goal_right = bot.info.opp_goal.right_post - reachable_ball.pos
ball_to_goal_left = bot.info.opp_goal.left_post - reachable_ball.pos
aim_cone = AimCone(ball_to_goal_right, ball_to_goal_left)
shoot_controls = bot.shoot.with_aiming(bot, aim_cone, my_hit_time)
hit_pos = bot.shoot.ball_when_hit.pos
dist = norm(car.pos - hit_pos)
closest_enemy, enemy_dist = bot.info.closest_enemy(0.5 * (hit_pos + ball.pos))
if not bot.shoot.can_shoot and is_closer_to_goal_than(car.pos, hit_pos, bot.info.team):
# Can't shoot but or at least on the right side: Chase
goal_to_ball = normalize(hit_pos - bot.info.opp_goal.pos)
offset_ball = hit_pos + goal_to_ball * Ball.RADIUS * 0.9
enemy_hit_time = predict.time_till_reach_ball(closest_enemy, ball)
enemy_hit_pos = predict.ball_predict(bot, enemy_hit_time).pos
if enemy_hit_time < 1.5 * my_hit_time:
if bot.do_rendering:
bot.renderer.draw_line_3d(closest_enemy.pos, enemy_hit_pos, bot.renderer.red())
return bot.drive.home(bot)
if bot.do_rendering:
bot.renderer.draw_line_3d(car.pos, offset_ball, bot.renderer.yellow())
return bot.drive.towards_point(bot, offset_ball, target_vel=2200, slide=False, boost_min=0)
elif len(bot.info.teammates) == 0 and not bot.shoot.aim_is_ok and hit_pos.y * -bot.info.team_sign > 4250 and abs(hit_pos.x) > 900 and not dist < 420:
# hit_pos is an enemy corner and we are not close: Avoid enemy corners in 1s and just wait
enemy_to_ball = normalize(hit_pos - closest_enemy.pos)
wait_point = hit_pos + enemy_to_ball * enemy_dist # a point 50% closer to the center of the field
wait_point = lerp(wait_point, ball.pos + Vec3(0, bot.info.team_sign * 3000, 0), 0.5)
if bot.do_rendering:
bot.renderer.draw_line_3d(car.pos, wait_point, bot.renderer.yellow())
return bot.drive.towards_point(bot, wait_point, norm(car.pos - wait_point), slide=False, can_keep_speed=True, can_dodge=False)
elif bot.shoot.can_shoot:
# Shoot !
if bot.do_rendering:
aim_cone.draw(bot, bot.shoot.ball_when_hit.pos, r=0, b=0)
if bot.shoot.using_curve:
rendering.draw_bezier(bot, [car.pos, bot.shoot.curve_point, hit_pos])
return shoot_controls
else:
# We can't shoot at goal reliably
# How about a shot to the corners then?
corners = [
Vec3(-Field.WIDTH2, -bot.info.team_sign * Field.LENGTH2, 0),
Vec3(Field.WIDTH2, -bot.info.team_sign * Field.LENGTH2, 0),
]
for corner in corners:
ctrls = bot.shoot.towards(bot, corner, bot.info.my_car.reach_ball_time)
if bot.shoot.can_shoot:
aim_cone.draw(bot, bot.shoot.ball_when_hit.pos, b=0)
if bot.shoot.using_curve:
rendering.draw_bezier(bot, [car.pos, bot.shoot.curve_point, hit_pos])
return ctrls
enemy_to_ball = normalize(xy(ball.pos - closest_enemy.pos))
ball_to_my_goal = normalize(xy(bot.info.own_goal.pos - ball.pos))
dot_threat = dot(enemy_to_ball, ball_to_my_goal) # 1 = enemy is in position, -1 = enemy is NOT in position
if car.boost <= 10 and ball.pos.y * bot.info.team_sign < 0 and dot_threat < 0.15:
collect_center = ball.pos.y * bot.info.team_sign <= 0
collect_small = closest_enemy.pos.y * bot.info.team_sign <= 0 or enemy_dist < 900
pads = filter_pads(bot, bot.info.big_boost_pads, big_only=not collect_small, enemy_side=False,
center=collect_center)
bot.maneuver = CollectClosestBoostManeuver(bot, pads)
# return home-ish
return bot.drive.stay_at(bot, lerp(bot.info.own_goal.pos, ball.pos, 0.2), ball.pos)
def dist_to_plane(pos: Vec3, plane: Plane) -> float:
return abs(dot(pos - plane.offset, plane.normal))
