class ShadowDefense(Maneuver):
DURATION = 0.5
def __init__(self, car: Car, info: GameInfo, face_target: vec3, distance_from_target: float):
super().__init__(car)
self.info = info
self.face_target = face_target
dist = min(distance_from_target, ground_distance(face_target, self.info.my_goal.center) - 50)
target_pos = ground(face_target) + ground_direction(face_target, self.info.my_goal.center) * dist
near_goal = ground_distance(car, info.my_goal.center) < 3000
side_shift = 400 if near_goal else 2000
points = [target_pos + vec3(side_shift, 0, 0), target_pos - vec3(side_shift, 0, 0)]
target_pos = nearest_point(face_target, points) if near_goal else farthest_point(face_target, points)
target_pos = Arena.clamp(target_pos, 500)
self.travel = Travel(car, target_pos)
self.travel.finish_distance = 800 if near_goal else 1500
self.drive = Drive(car)
self.drive.target_speed = 1000
self.stop = Stop(car)
self.start_time = car.time
def interruptible(self) -> bool:
return self.travel.interruptible()
def step(self, dt):
self.travel.step(dt)
self.controls = self.travel.controls
if ground_distance(self.car, self.travel.target) < 3000:
self.controls.boost = False
if self.travel.finished:
if angle_to(self.car, self.face_target) > 0.3:
self.drive.target_pos = self.face_target
self.drive.step(dt)
self.controls = self.drive.controls
self.controls.handbrake = False
else:
self.stop.step(dt)
self.controls = self.stop.controls
self.controls.boost = False
self.finished = self.travel.driving and self.car.time > self.start_time + self.DURATION
def render(self, draw: DrawingTool):
self.travel.render(draw)
class PickupBoostPad(Maneuver):
"""Pickup a boostpad. Abort when picked up by someone else."""
def __init__(self, car: Car, pad: BoostPad):
super().__init__(car)
self.pad = pad
self.pad_was_active = self.pad.state == BoostPadState.Available
self.travel = Travel(car, self.pad.position, waste_boost=True)
def interruptible(self) -> bool:
return self.travel.interruptible()
def step(self, dt):
# slow down when we're about to pick up the boost, so we can turn faster afterwards
if distance(self.car, self.pad) < norm(self.car.velocity) * 0.2:
self.travel.drive.target_speed = 1400
self.travel.step(dt)
self.controls = self.travel.controls
# finish when someone picks up the pad
if self.pad_was_active and self.pad.state == BoostPadState.Unavailable:
self.finished = True
self.pad_was_active = self.pad.state == BoostPadState.Available
# finish when we picked the boost up but the previous condition somehow wasn't true
if self.car.boost > 99 or distance(self.car, self.pad) < 100:
self.finished = True
def render(self, draw: DrawingTool):
self.travel.render(draw)
# draw timer if boost isn't available yet
if self.pad and not self.pad.state == BoostPadState.Available:
draw.color(draw.yellow)
draw.string(self.pad.position + vec3(0, 0, 100),
f"spawns in: {self.pad.timer:.1f}s")
class Refuel(Maneuver):
"""
Choose a large boost pad and go pick it up.
"""
def __init__(self,
car: Car,
info: GameInfo,
target: vec3,
forbidden_pads: Set[Pad] = set()):
super().__init__(car)
self.info = info
pos = (target + car.position * 2 +
info.my_goal.center * 2) / 5 # TODO: make this better
pads = set(info.large_boost_pads) - forbidden_pads
self.pad = self.best_boostpad_to_pickup(car, pads, pos)
self.pad_was_active = self.pad and self.pad.is_active
self.travel = Travel(
car,
self.pad.position if self.pad else info.my_goal.center,
waste_boost=True)
@staticmethod
def best_boostpad_to_pickup(car: Car, pads: Set[Pad],
pos: vec3) -> Optional[Pad]:
best_pad = None
best_dist = math.inf
for pad in pads:
dist = distance(pos, pad.position)
time_estimate = estimate_time(car, pad.position,
estimate_max_car_speed(car))
if dist < best_dist and (pad.is_active
or pad.timer < time_estimate):
best_pad = pad
best_dist = dist
return best_pad
def interruptible(self) -> bool:
return self.travel.interruptible()
def step(self, dt):
if self.pad is None:
self.finished = True
return
# slow down when we're about to pick up the boost, so we can turn faster afterwards
if distance(self.car, self.pad) < norm(self.car.velocity) * 0.2:
self.travel.drive.target_speed = 1400
self.travel.step(dt)
self.controls = self.travel.controls
# finish when someone picks up the pad
if not self.pad.is_active and self.pad_was_active:
self.finished = True
self.pad_was_active = self.pad.is_active
# finish when we picked the boost up but the previous condition somehow wasn't true
if self.car.boost > 99 or distance(self.car, self.pad) < 100:
self.finished = True
def render(self, draw: DrawingTool):
self.travel.render(draw)
if self.pad and not self.pad.is_active:
draw.color(draw.yellow)
draw.string(self.pad.position + vec3(0, 0, 100),
int(self.pad.timer * 100) / 100)
class GeneralDefense(Maneuver):
"""
First, attempt to rotate on the far side, and when far away enough from the target (usually the ball),
turn around to face it. If already far enough and facing the target, just stop and wait.
Also try to pickup boost pads along the way.
This state expires after a short amount of time, so we can look if there's something better to do. If not,
it can be simply instantiated again.
"""
DURATION = 0.5
BOOST_LOOK_RADIUS = 1200
BOOST_LOOK_ANGLE = 0.5
def __init__(self, car: Car, info: GameInfo, face_target: vec3,
distance_from_target: float):
super().__init__(car)
self.info = info
self.face_target = face_target
dist = min(distance_from_target,
ground_distance(face_target, self.info.my_goal.center) - 50)
target_pos = ground(face_target) + ground_direction(
face_target, self.info.my_goal.center) * dist
near_goal = ground_distance(car, info.my_goal.center) < 3000
side_shift = 400 if near_goal else 2500
points = [
target_pos + vec3(side_shift, 0, 0),
target_pos - vec3(side_shift, 0, 0)
]
target_pos = nearest_point(face_target,
points) if near_goal else farthest_point(
face_target, points)
target_pos = Arena.clamp(target_pos, 500)
self.travel = Travel(car, target_pos)
self.travel.finish_distance = 800 if near_goal else 1500
self.drive = Drive(car)
self.stop = Stop(car)
self.start_time = car.time
self.pad = None
def interruptible(self) -> bool:
return self.travel.interruptible()
def step(self, dt):
# update finished state even if we are not using the controls
self.travel.step(dt)
if self.travel.finished:
# turn around to face the target direction
if angle_to(self.car, self.face_target) > 0.3:
self.drive.target_pos = self.face_target
self.drive.target_speed = 1000
self.drive.step(dt)
self.controls = self.drive.controls
self.controls.handbrake = False
else:
self.stop.step(dt)
self.controls = self.stop.controls
else:
self.pad = None
# collect boost pads on the way (greedy algorithm, assumes first found is best)
if self.car.boost < 90 and self.travel.interruptible():
to_target = ground_direction(self.car, self.travel.target)
for pad in self.info.large_boost_pads + self.info.small_boost_pads:
to_pad = ground_direction(self.car, pad)
if (pad.is_active and
distance(self.car, pad) < self.BOOST_LOOK_RADIUS
and angle_between(to_target,
to_pad) < self.BOOST_LOOK_ANGLE):
self.pad = pad
self.drive.target_pos = pad.position
self.drive.target_speed = 2200
self.drive.step(dt)
self.controls = self.drive.controls
break
# go to the actual target
if self.pad is None:
self.controls = self.travel.controls
# don't waste boost during downtime
self.controls.boost = False
self.finished = self.travel.driving and self.car.time > self.start_time + self.DURATION
def render(self, draw: DrawingTool):
self.travel.render(draw)
# render target pad
if self.pad:
draw.color(draw.blue)
draw.circle(self.pad.position, 50)