Adding easy aerials, and extracting a steering function.

Author: tarehart

.gitignore

@@ -108,4 +108,6 @@ ENV/
 /build
 
 # Gradle files
-/.gradle
+/.gradle
+
+.vscode/

requirements.txt

@@ -2,6 +2,7 @@
 # You will automatically get updates for all versions starting with "1.".
 rlbot==1.*
 rlbottraining
+RLUtilities
 
 # This will cause pip to auto-upgrade and stop scaring people with warning messages
 pip

run.py

@@ -13,7 +13,8 @@
             logger.log(logging_utils.logging_level,
                        'Skipping upgrade check for now since it looks like you have no internet')
         elif public_utils.is_safe_to_upgrade():
-            subprocess.call([sys.executable, "-m", "pip", "install", '-r', 'requirements.txt', '--upgrade', '--upgrade-strategy=eager'])
+            subprocess.call([sys.executable, "-m", "pip", "install", '-r', 'requirements.txt'])
+            subprocess.call([sys.executable, "-m", "pip", "install", 'rlbot', '--upgrade'])
 
             # https://stackoverflow.com/a/44401013
             rlbots = [module for module in sys.modules if module.startswith('rlbot')]

src/bot.py

@@ -1,16 +1,17 @@
-import math
 from typing import List
 
 from rlbot.agents.base_agent import BaseAgent, SimpleControllerState
 from rlbot.utils.structures.game_data_struct import GameTickPacket
 from rlbot.utils.structures.quick_chats import QuickChats
 
+from util.aerial import AerialStep, LineUpForAerialStep
+from util.drive import steer_toward_target
 from util.goal_detector import find_future_goal
-from util.orientation import Orientation
 from util.sequence import Sequence, ControlStep
 from util.spikes import SpikeWatcher
 from util.vec import Vec3
 
+
 # Would you like to use numpy utilities? Check out the np_util folder!
 
 class MyBot(BaseAgent):
@@ -27,6 +28,8 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
         see the motion of the ball, etc. and return controls to drive your car.
         """
 
+        # This is good to keep at the beginning of get_output. It will allow you to continue
+        # any sequences that you may have started during a previous call to get_output.
         if self.active_sequence and not self.active_sequence.done:
             return self.active_sequence.tick(packet)
 
@@ -39,9 +42,7 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
         if predicted_goal:
             goal_text = f"Goal in {predicted_goal.time - packet.game_info.seconds_elapsed:.2f}s"
 
-        ball_location = Vec3(packet.game_ball.physics.location)
         my_car = packet.game_cars[self.index]
-        car_location = Vec3(my_car.physics.location)
         car_velocity = Vec3(my_car.physics.velocity)
 
         # Example of using a sequence
@@ -57,64 +58,32 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
 
         # Example of using the spike watcher.
         # This will make the bot say I got it! when it spikes the ball,
-        # then release it 3 seconds later.
+        # then release it 2 seconds later.
         if self.spike_watcher.carrying_car == my_car:
             if self.spike_watcher.carry_duration == 0:
                 self.send_quick_chat(QuickChats.CHAT_EVERYONE, QuickChats.Information_IGotIt)
-            elif self.spike_watcher.carry_duration > 3:
+            elif self.spike_watcher.carry_duration > 2:
                 return SimpleControllerState(use_item=True)
 
-        # The rest of this code just ball chases.
-        # Find the direction of your car using the Orientation class
-        car_orientation = Orientation(my_car.physics.rotation)
-        car_direction = car_orientation.forward
-
-        target = ball_location
-        car_to_target = target - car_location
-        steer_correction_radians = find_correction(car_direction, car_to_target)
+        # Example of doing an aerial. This will cause the car to jump and fly toward the
+        # ceiling in the middle of the field.
+        if my_car.boost > 50 and my_car.has_wheel_contact:
+            self.start_aerial(Vec3(0, 0, 2000), packet.game_info.seconds_elapsed + 4)
 
+        # If nothing else interesting happened, just chase the ball!
+        ball_location = Vec3(packet.game_ball.physics.location)
+        self.controller_state.steer = steer_toward_target(my_car, ball_location)
         self.controller_state.throttle = 1.0
 
-        # Change the multiplier to influence the sharpness of steering. You'll wiggle if it's too high.
-        self.controller_state.steer = limit_to_safe_range(-steer_correction_radians * 5)
-
+        # Draw some text on the screen
         draw_debug(self.renderer, [goal_text])
 
         return self.controller_state
 
-
-def limit_to_safe_range(value: float) -> float:
-    """
-    Controls like throttle, steer, pitch, yaw, and roll need to be in the range of -1 to 1.
-    This will ensure your number is in that range. Something like 0.45 will stay as it is,
-    but a value of -5.6 would be changed to -1.
-    """
-    if value < -1:
-        return -1
-    if value > 1:
-        return 1
-    return value
-
-
-def find_correction(current: Vec3, ideal: Vec3) -> float:
-    """
-    Finds the angle from current to ideal vector in the xy-plane. Angle will be between -pi and +pi.
-    """
-
-    # The in-game axes are left handed, so use -x
-    current_in_radians = math.atan2(current.y, -current.x)
-    ideal_in_radians = math.atan2(ideal.y, -ideal.x)
-
-    diff = ideal_in_radians - current_in_radians
-
-    # Make sure that diff is between -pi and +pi.
-    if abs(diff) > math.pi:
-        if diff < 0:
-            diff += 2 * math.pi
-        else:
-            diff -= 2 * math.pi
-
-    return diff
+    def start_aerial(self, target: Vec3, arrival_time: float):
+        self.active_sequence = Sequence([
+            LineUpForAerialStep(target, arrival_time, self.index),
+            AerialStep(target, arrival_time, self.index)])
 
 
 def draw_debug(renderer, text_lines: List[str]):

src/util/aerial.py

@@ -0,0 +1,77 @@
+from RLUtilities.GameInfo import GameInfo
+from RLUtilities.LinearAlgebra import vec3
+from RLUtilities.Maneuvers import Aerial
+from rlbot.agents.base_agent import SimpleControllerState
+from rlbot.utils.structures.game_data_struct import GameTickPacket
+
+from util.drive import steer_toward_target
+from util.sequence import Step, StepResult
+from util.vec import Vec3
+
+
+MAX_SPEED_WITHOUT_BOOST = 1410
+SECONDS_PER_TICK = 0.008  # Assume a 120Hz game. It's OK if we're wrong, aerial will still go OK
+
+
+class LineUpForAerialStep(Step):
+    """
+    This will cause the car to steer toward the target until it is lined up enough and going at
+    an appropriate speed for a successful aerial.
+    """
+    def __init__(self, target: Vec3, arrival_time: float, index: int):
+        self.target = target
+        self.arrival_time = arrival_time
+        self.index = index
+
+    def tick(self, packet: GameTickPacket) -> StepResult:
+        car = packet.game_cars[self.index]
+
+        seconds_till_arrival = self.arrival_time - packet.game_info.seconds_elapsed
+        if seconds_till_arrival <= 0:
+            return StepResult(SimpleControllerState(), done=True)
+        current_speed = Vec3(car.physics.velocity).length()
+        avg_speed_needed = Vec3(car.physics.location).flat().dist(self.target.flat()) / seconds_till_arrival
+
+        steering = steer_toward_target(car, self.target)
+        controls = SimpleControllerState(
+            steer=steering,
+            throttle=1 if avg_speed_needed > current_speed else 0,
+            boost=avg_speed_needed > current_speed and avg_speed_needed > MAX_SPEED_WITHOUT_BOOST)
+
+        ready_to_jump = abs(steering) < 0.1 and current_speed / avg_speed_needed > 0.7
+
+        return StepResult(controls, done=ready_to_jump)
+
+
+class AerialStep(Step):
+    """
+    This uses the Aerial controller provided by RLUtilities. Thanks chip!
+    It will take care of jumping off the ground and flying toward the target.
+    This will only work properly if you call tick repeatedly on the same instance.
+    """
+    def __init__(self, target: Vec3, arrival_time: float, index: int):
+        self.index = index
+        self.aerial: Aerial = None
+        self.game_info: GameInfo = None
+        self.target = target
+        self.arrival_time = arrival_time
+
+    def tick(self, packet: GameTickPacket) -> StepResult:
+
+        if self.game_info is None:
+            self.game_info = GameInfo(self.index, packet.game_cars[self.index].team)
+        self.game_info.read_packet(packet)
+
+        if self.aerial is None:
+            self.aerial = Aerial(self.game_info.my_car, vec3(self.target.x, self.target.y, self.target.z),
+                                 self.arrival_time)
+
+        self.aerial.step(SECONDS_PER_TICK)
+        controls = SimpleControllerState()
+        controls.boost = self.aerial.controls.boost
+        controls.pitch = self.aerial.controls.pitch
+        controls.yaw = self.aerial.controls.yaw
+        controls.roll = self.aerial.controls.roll
+        controls.jump = self.aerial.controls.jump
+
+        return StepResult(controls, packet.game_info.seconds_elapsed > self.arrival_time)

src/util/drive.py

@@ -0,0 +1,26 @@
+import math
+
+from rlbot.utils.structures.game_data_struct import PlayerInfo
+
+from util.orientation import Orientation, relative_location
+from util.vec import Vec3
+
+
+def limit_to_safe_range(value: float) -> float:
+    """
+    Controls like throttle, steer, pitch, yaw, and roll need to be in the range of -1 to 1.
+    This will ensure your number is in that range. Something like 0.45 will stay as it is,
+    but a value of -5.6 would be changed to -1.
+    """
+    if value < -1:
+        return -1
+    if value > 1:
+        return 1
+    return value
+
+
+
+def steer_toward_target(car: PlayerInfo, target: Vec3) -> float:
+    relative = relative_location(Vec3(car.physics.location), Orientation(car.physics.rotation), target)
+    angle = math.atan2(relative.y, relative.x)
+    return limit_to_safe_range(angle * 5)