def turn_circles(self):
"""renders turning circles in cyan"""
speed = norm(self.info.my_car.vel)
r = -6.901E-11 * speed**4 + 2.1815E-07 * speed**3 - 5.4437E-06 * speed**2 + 0.12496671 * speed + 157
k = self.turn_c_quality
circleR = []
centreR = vec3(0, r, 0)
for i in range(k):
theta = (2 / k) * math.pi * i
point = centreR + vec3(r * math.sin(theta), -r * math.cos(theta), 0)
point = self.info.my_car.pos + dot(self.info.my_car.theta, point)
circleR.append(point)
circleL = []
centreL = vec3(0, -r, 0)
for i in range(k):
theta = (2 / k) * math.pi * i
point = centreL + vec3(r * math.sin(theta), r * math.cos(theta), 0)
point = self.info.my_car.pos + dot(self.info.my_car.theta, point)
circleL.append(point)
self.renderer.begin_rendering("turn circles")
self.renderer.draw_polyline_3d(circleR, self.renderer.cyan())
self.renderer.draw_polyline_3d(circleL, self.renderer.cyan())
self.renderer.end_rendering()
def align(pos: vec3, ball: Ball, goal: vec3):
return max(
dot(ground_direction(pos, ball), ground_direction(ball, goal)),
dot(ground_direction(pos, ball),
ground_direction(ball, goal + vec3(800, 0, 0))),
dot(ground_direction(pos, ball),
ground_direction(ball, goal - vec3(800, 0, 0))))
def step(self, dt):
max_throttle_speed = 1410
max_boost_speed = 2300
# get the local coordinates of where the ball is, relative to the car
# delta_local[0]: how far in front
# delta_local[1]: how far to the left
# delta_local[2]: how far above
delta_local = dot(self.target_pos - self.car.pos, self.car.theta)
# angle between car's forward direction and target position
phi = math.atan2(delta_local[1], delta_local[0])
if phi < -math.radians(10):
# If the target is more than 10 degrees right from the centre, steer left
self.controls.steer = -1
elif phi > math.radians(10):
# If the target is more than 10 degrees left from the centre, steer right
self.controls.steer = 1
else:
# If the target is less than 10 degrees from the centre, steer straight
self.controls.steer = phi / math.radians(10)
if abs(phi) < math.radians(3) and not self.car.supersonic:
self.controls.boost = True
else:
self.controls.boost = False
if abs(phi) > 1.75:
self.controls.handbrake = 1
else:
self.controls.handbrake = 0
# forward velocity
vf = dot(self.car.vel, self.car.forward())
if vf < self.target_speed:
self.controls.throttle = 1.0
if self.target_speed > max_throttle_speed:
self.controls.boost = 1
else:
self.controls.boost = 0
else:
self.controls.throttle = -1
self.controls.boost = 0
if norm(delta_local) < 20:
self.controls.throttle = -norm(delta_local) / 20
if norm(delta_local) < 10:
self.controls.throttle = -norm(delta_local) / 10
if self.car.supersonic:
self.controls.boost = False
if norm(self.car.pos - self.target_pos) < 100:
self.finished = True
def step(self, car: Car, target: vec3) -> SimpleControllerState:
self.car = car
self.target = target
local_pos = dot(self.target, self.car.theta)
local_pos_spherical = spherical(local_pos)
local_omega = dot(self.car.omega, self.car.theta)
theta_error = math.sqrt(local_pos_spherical[1]**2 +
local_pos_spherical[2]**2)
omega_error = math.sqrt(local_omega[1]**2 + local_omega[2]**2)
if omega_error < 0.1 and theta_error < 0.1:
self.finished = True
else:
self.finished = False
def next_ball_hit(self, ball):
""" Returns if and when the given ball will hit this wall. """
dot_vel = dot(ball.vel, self.normal)
if dot_vel == 0:
return UncertainEvent(False, 1e300)
dist = ball.pos - self.offset_anchor
time = (self.normal[0] * dist[0] + self.normal[1] * dist[1]) / -dot_vel
return UncertainEvent(0 < time, time)
def get_speed(agent, location):
car = agent.info.my_car
local = dot(location - car.pos, car.theta)
angle = cap(math.atan2(local[1], local[0]), -3, 3)
distance = distance_2d(car.pos, location)
if distance > 2.5 * velocity_2d(car.vel):
return 2250
else:
return 2250 - (400 * (angle ** 2))
def shooting_target(agent):
ball = agent.info.ball
car = agent.info.my_car
car_to_ball = ball.pos - car.pos
backline_intersect = line_backline_intersect(
agent.info.their_goal.center[1], vec2(car.pos), vec2(car_to_ball))
if -500 < backline_intersect < 500:
goal_to_ball = normalize(car.pos - ball.pos)
error = cap(distance_2d(ball.pos, car.pos) / 1000, 0, 1)
else:
# Right of the ball
if -500 > backline_intersect:
target = agent.info.their_goal.corners[3] + vec3(400, 0, 0)
# Left of the ball
elif 500 < backline_intersect:
target = agent.info.their_goal.corners[2] - vec3(400, 0, 0)
goal_to_ball = normalize(ball.pos - target)
goal_to_car = normalize(car.pos - target)
difference = goal_to_ball - goal_to_car
error = cap(abs(difference[0]) + abs(difference[1]), 1, 10)
goal_to_ball_2d = vec2(goal_to_ball[0], goal_to_ball[1])
test_vector_2d = dot(rotation(0.5 * math.pi), goal_to_ball_2d)
test_vector = vec3(test_vector_2d[0], test_vector_2d[1], 0)
distance = cap((40 + distance_2d(ball.pos, car.pos) * (error**2)) / 1.8, 0,
4000)
location = ball.pos + vec3(
(goal_to_ball[0] * distance), goal_to_ball[1] * distance, 0)
# this adjusts the target based on the ball velocity perpendicular to the direction we're trying to hit it
multiplier = cap(distance_2d(car.pos, location) / 1500, 0, 2)
distance_modifier = cap(
dot(test_vector, ball.vel) * multiplier, -1000, 1000)
modified_vector = vec3(test_vector[0] * distance_modifier,
test_vector[1] * distance_modifier, 0)
location += modified_vector
# another target adjustment that applies if the ball is close to the wall
extra = 3850 - abs(location[0])
if extra < 0:
location[0] = cap(location[0], -3850, 3850)
location[1] = location[1] + (-sign(agent.team) * cap(extra, -800, 800))
return location
def can_dodge(agent, target):
bot_to_target = target - agent.info.my_car.pos
local_bot_to_target = dot(bot_to_target, agent.info.my_car.theta)
angle_front_to_target = math.atan2(local_bot_to_target[1], local_bot_to_target[0])
distance_bot_to_target = norm(vec2(bot_to_target))
good_angle = math.radians(-10) < angle_front_to_target < math.radians(10)
on_ground = agent.info.my_car.on_ground and agent.info.my_car.pos[2] < 100
going_fast = velocity_2d(agent.info.my_car.vel) > 1250
target_not_in_goal = not agent.info.my_goal.inside(target)
return good_angle and distance_bot_to_target > 2000 and on_ground and going_fast and target_not_in_goal
def estimate_time(car: Car, target, speed, dd=1) -> float:
dist = distance(car, target)
if dist < 100:
return 0
travel = dist / speed
turning = angle_between(car.forward() * dd, direction(
car, target)) / math.pi * 2
if turning < 1:
turning **= 2
acceleration = (speed * dd - dot(car.vel, car.forward())) / 2100 * 0.6 * dd
return travel + acceleration + turning * 0.7
def get_output(self, info: GameInfo) -> SimpleControllerState:
ball = info.ball
car = info.my_car
local_coords = dot(ball.pos - car.pos, car.theta)
self.controls.steer = math.copysign(1.0, local_coords[1])
# just set the throttle to 1 so the car is always moving forward
self.controls.throttle = 1.0
return self.controls
def should_dodge(agent):
car = agent.info.my_car
their_goal = agent.info.their_goal
close_to_goal = distance_2d(car.pos, their_goal.center) < 4000
aiming_for_goal = abs(
line_backline_intersect(their_goal.center[1], vec2(car.pos),
vec2(car.forward()))) < 850
bot_to_target = agent.info.ball.pos - car.pos
local_bot_to_target = dot(bot_to_target, agent.info.my_car.theta)
angle_front_to_target = math.atan2(local_bot_to_target[1],
local_bot_to_target[0])
close_to_ball = norm(vec2(bot_to_target)) < 850
good_angle = math.radians(-10) < angle_front_to_target < math.radians(10)
return close_to_ball and close_to_goal and aiming_for_goal and good_angle
def solid_angle(self, p):
Omega = 0.0
a = self.corners[0] - p
b = self.corners[1] - p
c = self.corners[2] - p
numerator = abs(dot(a, cross(b, c)))
denominator = norm(a) * norm(b) * norm(c) + \
dot(a, b) * norm(c) + \
dot(b, c) * norm(a) + \
dot(c, a) * norm(b)
angle = 2 * math.atan(numerator / denominator)
if angle < 0:
angle += 2 * math.pi
Omega += angle
a = self.corners[2] - p
b = self.corners[3] - p
c = self.corners[0] - p
numerator = abs(dot(a, cross(b, c)))
denominator = norm(a) * norm(b) * norm(c) + \
dot(a, b) * norm(c) + \
dot(b, c) * norm(a) + \
dot(c, a) * norm(b)
angle = 2 * math.atan(numerator / denominator)
if angle < 0:
angle += 2 * math.pi
Omega += angle
return Omega
def bounce_off(self, normal):
# See https://samuelpmish.github.io/notes/RocketLeague/ball_bouncing/
# For dropshot the slip velocity becomes zero after the first bounce, so chips model is slightly tweaked
MU = 0.285
CR = 0.605
v_perp = normal * dot(self.vel, normal)
v_para = self.vel - v_perp
v_spin = cross(normal, self.omega) * DropshotBall.RADIUS
s = v_para - v_spin
delta_v_para = vec3(0, 0, 0)
if norm(s) != 0:
delta_v_para = -MU * s
delta_v_perp = v_perp * -(1.0 + CR)
self.vel += delta_v_perp + delta_v_para
self.omega = cross(self.vel, normal) * (1. / DropshotBall.RADIUS)
return self
def world(car, pos) -> vec3:
return car.pos + dot(car.theta, loc(pos))
def local(car, pos) -> vec3:
return dot(loc(pos) - car.pos, car.theta)
def debug(self):
"""prints debug info"""
self.renderer.begin_rendering("debug")
if self.RLwindow == [0] * 4:
self.renderer.draw_string_2d(20, 10, 2, 2, str(self.state),
self.renderer.red())
self.renderer.draw_string_2d(10, 40, 1, 1,
"car pos: " + str(self.info.my_car.pos),
self.renderer.black())
self.renderer.draw_string_2d(10, 55, 1, 1, "timer: " + str(self.timer),
self.renderer.black())
self.renderer.draw_string_2d(10, 70, 1, 1,
"target speed: " + str(self.target_speed),
self.renderer.black())
self.renderer.draw_string_2d(10, 85, 1, 1, "drift: " + str(self.drift),
self.renderer.black())
self.renderer.draw_string_2d(
10, 100, 1, 1, "handbrake: " + str(self.controls.handbrake),
self.renderer.black())
if not self.target == None:
forward_target = dot(self.target - self.info.my_car.pos,
self.info.my_car.theta)[0]
right_target = dot(self.target - self.info.my_car.pos,
self.info.my_car.theta)[1]
angle_to_target = math.atan2(right_target, forward_target)
self.renderer.draw_string_2d(
10, 115, 1, 1, "angle to target: " + str(angle_to_target),
self.renderer.black())
self.renderer.draw_string_2d(
10, 130, 1, 1, "forwd to target: " + str(forward_target),
self.renderer.black())
self.renderer.draw_string_2d(
10, 145, 1, 1, "right to target: " + str(right_target),
self.renderer.black())
else:
self.renderer.draw_string_2d(self.RLwindow[2] * 0.7, 10, 2, 2,
str(self.state), self.renderer.red())
self.renderer.draw_string_2d(self.RLwindow[2] * 0.65, 40, 1, 1,
"car pos: " + str(self.info.my_car.pos),
self.renderer.black())
self.renderer.draw_string_2d(self.RLwindow[2] * 0.65, 55, 1, 1,
"timer: " + str(self.timer),
self.renderer.black())
self.renderer.draw_string_2d(self.RLwindow[2] * 0.65, 70, 1, 1,
"target speed: " + str(self.target_speed),
self.renderer.black())
self.renderer.draw_string_2d(self.RLwindow[2] * 0.65, 85, 1, 1,
"drift: " + str(self.drift),
self.renderer.black())
self.renderer.draw_string_2d(
self.RLwindow[2] * 0.65, 100, 1,
1, "handbrake: " + str(self.controls.handbrake),
self.renderer.black())
if not self.target == None:
forward_target = dot(self.target - self.info.my_car.pos,
self.info.my_car.theta)[0]
right_target = dot(self.target - self.info.my_car.pos,
self.info.my_car.theta)[1]
angle_to_target = math.atan2(right_target, forward_target)
self.renderer.draw_string_2d(
self.RLwindow[2] * 0.65, 115, 1, 1,
"angle to target: " + str(angle_to_target),
self.renderer.black())
self.renderer.draw_string_2d(
self.RLwindow[2] * 0.65, 130, 1,
1, "forwd to target: " + str(forward_target),
self.renderer.black())
self.renderer.draw_string_2d(
self.RLwindow[2] * 0.65, 145, 1, 1,
"right to target: " + str(right_target), self.renderer.black())
self.renderer.end_rendering()
def wavedash(car, target):
controller = SimpleControllerState()
controller.jump = False
face = direction(target - car.pos)
vel = car.vel
pos = car.pos
walls = [4096, 5120, 2044]
dists = []
for i in range(2):
if vel[i] < 0:
d = pos[i] + walls[i]
elif vel[i] > 0:
d = pos[i] - walls[i]
else:
d = 10000
dists.append(d)
times = [abs(dists[0]/vel[0]), abs(dists[1]/vel[1])]
dist_ciel = walls[2] - pos[2]
dist_floor = -pos[2]
accel = -650
v2 = vel[2]**2
dists.append(dist_ciel)
rt = v2 + 2 * accel * dist_ciel
if rt < 0:
rt = v2 + 2*accel*dist_floor
dists[2] = dist_floor
if rt < 0:
print("I'm confused")
times.append(max([(-vel[2] + rt**0.5)/accel, (-vel[2] - rt**0.5)/accel]))
print(times)
id = times.index(min(times))
ups = [vec3(-1, 0, 0), vec3(0, -1, 0), vec3(0, 0, -1)]
up = ups[id] * sign(vel[id])
if id == 2:
up = ups[id] * sign(dist_floor - dist_ciel)
face = direction(face + up)
pitch, roll, yaw = aerial_face(car, face, up)
controller.pitch = pitch
controller.roll = roll
controller.yaw = yaw
flip_dir = car.up() * -1.0
flip_dir[2] = 0
flip_dir = direction(dot(flip_dir, car.theta))
if dists[id] < 100 and times[id] < 0.2:
controller.jump = True
controller.pitch = -flip_dir[0]
controller.roll = 0
controller.yaw = flip_dir[1]
return controller, face
def step(self, dt):
# direction of ball relative to center of car (where should we aim)
# direction of ball relative to yaw of car (where should we aim verse where we are aiming)
local_bot_to_ball = dot(self.ball.pos - self.car.pos, self.car.theta)
angle_front_to_ball = math.atan2(local_bot_to_ball[1], local_bot_to_ball[0])
# distance between bot and ball
distance = distance_2d(self.car.pos, self.ball.pos)
# direction of ball velocity relative to yaw of car (which way the ball is moving verse which way we are moving)
if velocity_2d(self.ball.vel) < 1e-10:
angle_car_forward_to_ball_vel = 0
else:
angle_car_forward_to_ball_vel = angle_between(z0(self.car.forward()), z0(self.ball.vel))
# magnitude of ball_bot_angle (squared)
ball_bot_diff = (self.ball.vel[0] ** 2 + self.ball.vel[1] ** 2) - (self.car.vel[0] ** 2 + self.car.vel[1] ** 2)
# p is the distance between ball and car
# i is the magnitude of the ball's velocity (squared) the i term would normally
# be the integral of p over time, but the ball's velocity is essentially that number
# d is the relative speed between ball and car
# note that bouncing a ball is distinctly different than balancing something that doesnt bounce
# p_s is the x component of the distance to the ball
# d_s is the one frame change of p_s, that's why p_s has to be global
# we modify distance and ball_bot_diff so that only the component along the car's path is counted
# if the ball is too far to the left, we don't want the bot to think it has to drive forward
# to catch it
distance_y = math.fabs(distance * math.cos(angle_front_to_ball))
distance_x = math.fabs(distance * math.sin(angle_front_to_ball))
# ball moving forward WRT car yaw?
forward = False
if math.fabs(angle_car_forward_to_ball_vel) < math.radians(90):
forward = True
# first we give the distance values signs
if forward:
d = ball_bot_diff
i = (self.ball.vel[0] ** 2 + self.ball.vel[1] ** 2)
else:
d = -ball_bot_diff
i = -(self.ball.vel[0] ** 2 + self.ball.vel[1] ** 2)
if math.fabs(math.degrees(angle_front_to_ball)) < 90:
p = distance_y
else:
p = -1 * distance_y
# this is the PID correction. all of the callibration goes on right here
# there is literature about how to set the variables but it doesn't work quite the same
# because the car is only touching the ball (and interacting with the system) on bounces
# we run the PID formula through tanh to give a value between -1 and 1 for steering input
# if the ball is lower we have no velocity bias
bias_v = 600000 # 600000
# just the basic PID if the ball is too low
if self.ball.pos[2] < 120:
correction = np.tanh((20 * p + .0015 * i + .006 * d) / 500)
# if the ball is on top of the car we use our bias (the bias is in velocity units squared)
else:
correction = np.tanh((20 * p + .0015 * (i - bias_v) + .006 * d) / 500)
# makes sure we don't get value over .99 so we dont exceed maximum thrust
self.controls.throttle = correction * .99
# anything over .9 is boost
if correction > .99:
self.controls.boost = True
else:
self.controls.boost = False
# this is the PID steering section
# p_s is the x component of the distance to the ball (relative to the cars direction)
# d_s is the on frame change in p_s
# we use absolute value and then set the sign later
d_s = math.fabs(self.p_s) - math.fabs(distance_x)
self.p_s = math.fabs(distance_x)
# give the values the correct sign
if angle_front_to_ball < 0:
self.p_s = -self.p_s
d_s = -d_s
# d_s is actually -d_s ...whoops
d_s = -d_s
max_bias = 35
backline_intersect = line_backline_intersect(self.goal.center[1], vec2(self.car.pos),
vec2(self.car.forward()))
if abs(backline_intersect) < 1000 or self.ball.pos[2] > 200:
bias = 0
# Right of the ball
elif -850 > backline_intersect:
bias = max_bias
# Left of the ball
elif 850 < backline_intersect:
bias = -max_bias
# the correction settings can be altered to change performance
correction = np.tanh((100 * (self.p_s + bias) + 1500 * d_s) / 8000)
# apply the correction
self.controls.steer = correction
def get_output(self, packet):
self.info.read_packet(packet)
#additional processing not done by RLU
self.kickoff_pause = packet.game_info.is_kickoff_pause
self.round_active = packet.game_info.is_round_active
self.dt = self.info.time - self.last_time
self.last_time = self.info.time
self.last_touch = packet.game_ball.latest_touch.player_name
#trashtalk
if packet.game_cars[self.index].score_info.goals == self.goals + 1:
self.send_quick_chat(QuickChats.CHAT_EVERYONE, QuickChats.Reactions_Calculated)
self.goals = packet.game_cars[self.index].score_info.goals
#resets controls each tick
self.controls = SimpleControllerState()
#choose state
if not self.round_active:
self.state = None
elif not self.state == "kickoff":
if self.kickoff_pause:
self.kickoff_pos = None
self.action = None
self.timer = 0.0
self.state = "kickoff"
elif not self.info.my_car.on_ground and not isinstance(self.action, AirDodge):
self.state = "recovery"
self.action = self.action = AerialTurn(self.info.my_car)
elif norm(self.info.my_goal.center - self.info.my_car.pos) > norm(self.info.my_goal.center - self.info.ball.pos) + self.def_extra_dist:
self.action = None
self.target_speed = 2300
self.state = "defence"
if self.team == 0:
sign = -1
else:
sign = 1
#temporary 2v2 for Cow
if len(self.info.teammates) > 0:
if self.info.ball.pos[1] > 0:
self.target = vec3(3000,sign*4000,0)
else:
self.target = vec3(-3000,sign*4000,0)
else:
self.target = vec3(0,sign*4000,0)
elif self.info.my_car.pos[1] > 5120 or self.info.my_car.pos[1] < -5120:
self.target = vec3(0,5000,0) if self.info.my_car.pos[1] > 5120 else vec3(0,-5000,0)
self.action = self.action = Drive(self.info.my_car,self.target,1000)
self.state = "goal escape"
elif self.state == None:
self.action = None
self.target = None
self.target_speed = 2300
self.state = "offence"
#kickoff state
if self.state == "kickoff":
Kickoff.kickoff(self)
#exit kickoff state
if self.timer >= 2.6 or self.last_touch != '':
self.state = None
self.action = None
#recovery state
elif self.state == "recovery":
self.action.step(self.dt)
self.controls = self.action.controls
self.controls.throttle = 1.0
#exit recovery state
if self.info.my_car.on_ground == True:
self.state = None
self.action = None
#defence state and offence state
elif self.state == "defence" or self.state == "offence":
#select target
if self.target == None:
#large boost
if self.info.my_car.boost <= self.low_boost and norm(self.info.my_car.pos - self.info.ball.pos) > self.max_ball_dist:
active_pads = []
for pad in self.info.boost_pads:
if pad.is_active:
active_pads.append(pad)
if len(active_pads) != 0:
closest_pad = active_pads[0]
for pad in active_pads:
if norm(pad.pos - self.info.ball.pos) < norm(closest_pad.pos - self.info.ball.pos):
closest_pad = pad
self.target = closest_pad.pos
else:
self.target = self.info.ball.pos
#ball
else:
self.target = self.info.ball.pos
forward_target = dot(self.target - self.info.my_car.pos, self.info.my_car.theta)[0]
right_target = dot(self.target - self.info.my_car.pos, self.info.my_car.theta)[1]
angle_to_target = math.atan2(right_target, forward_target)
forward_goal = dot(self.info.their_goal.center - self.info.my_car.pos, self.info.my_car.theta)[0]
right_goal = dot(self.info.their_goal.center - self.info.my_car.pos, self.info.my_car.theta)[1]
angle_to_goal = math.atan2(right_goal, forward_goal)
#select maneuver
if not isinstance(self.action, AirDodge):
#shooting
if norm(self.info.ball.pos - self.info.my_car.pos) < self.dodge_dist and (angle_to_target - (math.pi/10.0) <= angle_to_goal <= angle_to_target + (math.pi/10.0)):
self.action = AirDodge(self.info.my_car,0.2,self.info.their_goal.center)
self.timer = 0.0
#dodging
elif (-math.pi/24.0) <= angle_to_target <= (math.pi/24.0) and norm(self.info.my_car.vel) > 700 and norm(self.info.ball.pos - self.info.my_car.pos) > 1000 and not self.state == "defence":
self.action = AirDodge(self.info.my_car,0.2,self.target)
self.timer = 0.0
#Drive
else:
self.action = Drive(self.info.my_car,self.target,self.target_speed)
#exit AirDodge
else:
self.timer += self.dt
if self.timer >= 0.5:
self.action = None
#Drive
if isinstance(self.action, Drive):
speed = norm(self.info.my_car.vel)
r = -6.901E-11 * speed**4 + 2.1815E-07 * speed**3 - 5.4437E-06 * speed**2 + 0.12496671 * speed + 157
#handbrake
self.drift = False
if (math.pi/2.0) <= angle_to_target or angle_to_target <= (-math.pi/2.0):
self.drift = True
#target speed
elif (norm(self.target - (self.info.my_car.pos + dot(self.info.my_car.theta,vec3(0,r,0)))) < r or norm(self.target - (self.info.my_car.pos + dot(self.info.my_car.theta,vec3(0,-r,0)))) < r) and not self.target_speed < self.min_target_s:
self.target_speed += -50
self.action = Drive(self.info.my_car,self.target,self.target_speed)
elif self.target_speed < 1800:
self.target_speed += 50
self.action = Drive(self.info.my_car,self.target,self.target_speed)
#maneuver tick
if self.action != None:
self.action.step(self.dt)
self.controls = self.action.controls
self.controls.handbrake = self.drift
#exit either state
if (self.state == "defence" and norm(self.info.my_goal.center - self.info.my_car.pos) < norm(self.info.my_goal.center - self.info.ball.pos)) or (norm(self.target - self.info.my_car.pos) < self.target_range):
self.state = None
#goal escape state
if self.state == "goal escape":
self.action.step(self.dt)
self.controls = self.action.controls
#exit goal escape state
if not (self.info.my_car.pos[1] > 5120 or self.info.my_car.pos[1] < -5120):
self.state = None
self.action = None
if 'win32gui' in sys.modules:
#finding the size of the Rocket League window
def callback(hwnd, win_rect):
if "Rocket League" in win32gui.GetWindowText(hwnd):
rect = win32gui.GetWindowRect(hwnd)
win_rect[0] = rect[0]
win_rect[1] = rect[1]
win_rect[2] = rect[2] - rect[0]
win_rect[3] = rect[3] - rect[1]
self.RLwindow = [0] * 4
win32gui.EnumWindows(callback, self.RLwindow)
#Rendering
Render.debug(self)
Render.turn_circles(self)
if not self.target == None:
Render.target(self)
return self.controls
def powerslide(agent):
target_local = dot(agent.drive.target_pos - agent.info.my_car.pos, agent.info.my_car.theta)
phi = math.atan2(target_local[1], target_local[0])
if abs(phi) > 1.7:
agent.controls.handbrake = 1
agent.controls.boost = 0
def get_controls(self):
if self.step == "Steer" or self.step == "Dodge2":
self.step = "Catching"
if self.step == "Catching":
target = get_bounce(self)
if target is None:
self.step = "Defending"
else:
self.catching.target_pos = target[0]
self.catching.target_speed = (distance_2d(
self.info.my_car.pos, target[0]) + 50) / target[1]
self.catching.step(self.FPS)
self.controls = self.catching.controls
ball = self.info.ball
car = self.info.my_car
if distance_2d(ball.pos,
car.pos) < 150 and 65 < abs(ball.pos[2] -
car.pos[2]) < 127:
self.step = "Dribbling"
self.dribble = Dribbling(self.info.my_car, self.info.ball,
self.info.their_goal)
if self.defending:
self.step = "Defending"
if not self.info.my_car.on_ground:
self.step = "Recovery"
ball = self.info.ball
if abs(ball.vel[2]) < 100 and sign(
self.team) * ball.vel[1] < 0 and sign(
self.team) * ball.pos[1] < 0:
self.step = "Shooting"
elif self.step == "Dribbling":
self.dribble.step(self.FPS)
self.controls = self.dribble.controls
ball = self.info.ball
car = self.info.my_car
bot_to_opponent = self.info.opponents[0].pos - self.info.my_car.pos
local_bot_to_target = dot(bot_to_opponent, self.info.my_car.theta)
angle_front_to_target = math.atan2(local_bot_to_target[1],
local_bot_to_target[0])
opponent_is_near = norm(vec2(bot_to_opponent)) < 2000
opponent_is_in_the_way = math.radians(
-10) < angle_front_to_target < math.radians(10)
if not (distance_2d(ball.pos, car.pos) < 150
and 65 < abs(ball.pos[2] - car.pos[2]) < 127):
self.step = "Catching"
if self.defending:
self.step = "Defending"
if opponent_is_near and opponent_is_in_the_way:
self.step = "Dodge"
self.dodge = AirDodge(self.info.my_car, 0.25,
self.info.their_goal.center)
if not self.info.my_car.on_ground:
self.step = "Recovery"
elif self.step == "Defending":
defending(self)
elif self.step == "Dodge":
self.dodge.step(self.FPS)
self.controls = self.dodge.controls
self.controls.boost = 0
if self.dodge.finished and self.info.my_car.on_ground:
self.step = "Catching"
elif self.step == "Recovery":
self.recovery.step(self.FPS)
self.controls = self.recovery.controls
if self.info.my_car.on_ground:
self.step = "Catching"
elif self.step == "Shooting":
shooting(self)
def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
self.info.read_packet(packet)
ball = self.info.ball
car = self.info.my_car
# the vector from the car to the ball in local coordinates:
# delta_local[0]: how far in front of my car
# delta_local[1]: how far to the left of my car
# delta_local[2]: how far above my car
delta_local = dot(ball.pos - car.pos, car.theta)
# the angle between the direction the car is facing
# and the in-plane local position of the ball
phi = math.atan2(delta_local[1], delta_local[0])
# a simple steering controller that is proportional to phi
self.controls.steer = clip(2.5 * phi, -1.0, 1.0)
# just set the throttle to 1 so the car is always moving forward
self.controls.throttle = 1.0
# draw some of the lines showing the angle phi (purple)
# and the local coordinates:
# delta_local[0]: red
# delta_local[1]: green
# delta_local[2]: blue
self.renderer.begin_rendering()
red = self.renderer.create_color(255, 255, 30, 30)
green = self.renderer.create_color(255, 30, 255, 30)
blue = self.renderer.create_color(255, 30, 30, 255)
white = self.renderer.create_color(255, 230, 230, 230)
gray = self.renderer.create_color(255, 130, 130, 130)
purple = self.renderer.create_color(255, 230, 30, 230)
f = car.forward()
l = car.left()
u = car.up()
self.renderer.draw_line_3d(car.pos, car.pos + delta_local[0] * f, red)
self.renderer.draw_line_3d(car.pos, car.pos + delta_local[1] * l,
green)
self.renderer.draw_line_3d(car.pos, car.pos + delta_local[2] * u, blue)
self.renderer.draw_line_3d(car.pos, ball.pos, white)
self.renderer.draw_line_3d(ball.pos, ball.pos - delta_local[2] * u,
gray)
self.renderer.draw_line_3d(car.pos, ball.pos - delta_local[2] * u,
gray)
radius = 200
num_segments = 30
angle = []
for i in range(num_segments):
c = math.cos(phi * float(i) / (num_segments - 1))
s = math.sin(phi * float(i) / (num_segments - 1))
angle.append(car.pos + radius * (c * f + s * l))
self.renderer.draw_polyline_3d(angle, purple)
self.renderer.end_rendering()
if controller.L1:
self.controls = controller.get_output()
return self.controls