def exec(self, bot) -> SimpleControllerState:
ct = time.time() - self._start_time
controls = SimpleControllerState()
controls.throttle = 1
car = bot.data.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) -> SimpleControllerState:
man_ct = bot.info.time - self.maneuver_start_time
controls = SimpleControllerState()
car = bot.info.my_car
vel_f = proj_onto_size(car.vel, car.forward)
# Reverse a bit
if vel_f > -50 and man_ct < 0.3:
controls.throttle = -1
self.halfflip_start_time = bot.info.time
return controls
ct = bot.info.time - self.halfflip_start_time
# States of jump
if ct >= self._t_finishing:
self._almost_finished = True
controls.throttle = 1
controls.boost = self.boost
if car.on_ground:
self.done = True
else:
bot.maneuver = RecoveryManeuver()
self.done = True
elif ct >= self._t_roll_begin:
controls.pitch = -1
controls.roll = 1
elif ct >= self._t_second_jump_end:
controls.pitch = -1
elif ct >= self._t_second_jump_begin:
controls.jump = 1
controls.pitch = 1
elif ct >= self._t_first_jump_end:
controls.pitch = 1
else:
controls.jump = 1
controls.throttle = -1
controls.pitch = 1
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(bot)
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 < 50\
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 bot.do_rendering:
tr_center_world = car.pos + dot(car.rot, tr_center_local)
tr_center_world_2 = car.pos + dot(car.rot, -1 * tr_center_local)
rendering.draw_circle(bot, tr_center_world, car.up, tr, 22)
rendering.draw_circle(bot, tr_center_world_2, car.up, tr, 22)
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 exec(self, bot):
ct = bot.info.time - self.start_time
# 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
# Get car and reset controls
car = bot.info.my_car
self.controls.throttle = 1
self.controls.yaw = 0
self.controls.pitch = 0
self.controls.jump = False
# 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)
self.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_done = True
if car.on_ground:
self.done = True
else:
bot.plan = RecoveryManeuver(bot)
self.done = True
return self.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:
self.controls.jump = 1
# Direction, yaw, pitch, roll
if self.target is None:
self.controls.roll = 0
self.controls.pitch = -1
self.controls.yaw = 0
else:
target_local = dot(car_to_target, car.rot)
target_local.z = 0
direction = normalize(target_local)
self.controls.roll = 0
self.controls.pitch = -direction.x
self.controls.yaw = sign(car.rot.get(2, 2)) * direction.y
# Pitch slightly upwards before starting the dodge
elif ct >= self._t_aim_prepare:
self.controls.pitch = 1
# Stop pressing jump
elif ct >= self._t_first_unjump:
pass
# First jump
else:
self.controls.jump = 1
return self.controls