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 ShadowDefense(Maneuver):
def __init__(self, car: Car, info: GameInfo, target: vec3, distance_from_target: float):
super().__init__(car)
self.info = info
self.target = target
ball = info.ball
dist = min(distance_from_target, ground_distance(target, self.info.my_goal.center) - 50)
target_pos = ground(target) + ground_direction(target, self.info.my_goal.center) * dist
side_shift = distance_from_target / 4 if ground_distance(car, info.my_goal.center) > 2500 else 400
points = [target_pos + vec3(side_shift, 0, 0), target_pos - vec3(side_shift, 0, 0)]
target_pos = nearest_point(car.pos, points)
self.target = Arena.clamp(target_pos, 700)
self.travel = Travel(car, self.target)
self.drive = Drive(car)
self.start_time = car.time
self.wait = Stop(car)
def step(self, dt):
ball = self.info.ball
if (
distance(self.car, ball) < 1000
and align(self.car.pos, ball, self.info.my_goal.center) > 0.2
):
shift = normalize(cross(direction(ball, self.car), vec3(0, 0, 1))) * 1000
self.travel.target = nearest_point(self.car.pos, [ball.pos + shift, ball.pos - shift])
else:
self.travel.target = self.target
self.travel.step(dt)
self.controls = self.travel.controls
if self.travel.finished:
if angle_to(self.car, self.target) > 0.2 and norm(self.car.vel) < 600:
self.drive.target_pos = self.target
self.drive.step(dt)
self.drive.target_speed = 500
self.drive.controls.handbrake = False
self.controls = self.drive.controls
else:
self.wait.step(dt)
self.controls = self.wait.controls
self.finished = self.travel._driving and self.car.time > self.start_time + 0.5
def render(self, draw: DrawingTool):
self.travel.render(draw)
class ShadowDefense(Maneuver):
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 furthest_point(
face_target, points)
self.target = Arena.clamp(target_pos, 500)
self.travel = Travel(car, self.target)
self.travel.finish_distance = 800 if near_goal else 1500
self.drive = Drive(car)
self.start_time = car.time
self.wait = Stop(car)
def step(self, dt):
ball = self.info.ball
# if (
# distance(self.car, ball) < 1000
# and align(self.car.position, ball, self.info.my_goal.center) > 0.2
# ):
# shift = normalize(cross(direction(ball, self.car), vec3(0, 0, 1))) * 1000
# self.travel.target = nearest_point(self.car.position, [ball.position + shift, ball.position - shift])
# else:
# self.travel.target = self.target
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.drive.target_speed = 700
self.drive.controls.handbrake = False
self.controls = self.drive.controls
else:
self.wait.step(dt)
self.controls = self.wait.controls
self.finished = self.travel.driving and self.car.time > self.start_time + 0.5
def render(self, draw: DrawingTool):
self.travel.render(draw)
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)