Boost pad tracker, improved sequence, relying on framework to begin and end rendering.

tarehart · tarehart · commit ce1db1916758 · 2020-06-08T09:31:33.000-07:00
diff --git a/src/bot.py b/src/bot.py
@@ -3,6 +3,7 @@
 from rlbot.utils.structures.game_data_struct import GameTickPacket
 
 from util.ball_prediction_analysis import find_slice_at_time
+from util.boost_pad_tracker import BoostPadTracker
 from util.drive import steer_toward_target
 from util.sequence import Sequence, ControlStep
 from util.vec import Vec3
@@ -13,38 +14,47 @@ class MyBot(BaseAgent):
     def __init__(self, name, team, index):
         super().__init__(name, team, index)
         self.active_sequence: Sequence = None
+        self.boost_pad_tracker = BoostPadTracker()
+
+    def initialize_agent(self):
+        # Set up information about the boost pads now that the game is active and the info is available
+        self.boost_pad_tracker.initialize_boosts(self.get_field_info())
 
     def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
         """
         This function will be called by the framework many times per second. This is where you can
         see the motion of the ball, etc. and return controls to drive your car.
         """
 
-        # Start the renderer. Make sure you call end_rendering at the end of this function.
-        self.renderer.begin_rendering()
+        # Keep our boost pad info updated with which pads are currently active
+        self.boost_pad_tracker.update_boost_status(packet)
 
         # 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)
+            controls = self.active_sequence.tick(packet)
+            if controls is not None:
+                return controls
 
         # Gather some information about our car and the ball
         my_car = packet.game_cars[self.index]
         car_location = Vec3(my_car.physics.location)
         car_velocity = Vec3(my_car.physics.velocity)
         ball_location = Vec3(packet.game_ball.physics.location)
 
-        if car_location.dist(ball_location) > 1000:
+        if car_location.dist(ball_location) > 1500:
             # We're far away from the ball, let's try to lead it a little bit
             ball_prediction = self.get_ball_prediction_struct()  # This can predict bounces, etc
             ball_in_future = find_slice_at_time(ball_prediction, packet.game_info.seconds_elapsed + 2)
             target_location = Vec3(ball_in_future.physics.location)
+            self.renderer.draw_line_3d(ball_location, target_location, self.renderer.cyan())
         else:
             target_location = ball_location
 
         # Draw some things to help understand what the bot is thinking
         self.renderer.draw_line_3d(car_location, target_location, self.renderer.white())
         self.renderer.draw_string_3d(car_location, 1, 1, f'Speed: {car_velocity.length():.1f}', self.renderer.white())
+        self.renderer.draw_rect_3d(target_location, 8, 8, True, self.renderer.cyan(), centered=True)
 
         if 750 < car_velocity.length() < 800:
             # We'll do a front flip if the car is moving at a certain speed.
@@ -55,8 +65,6 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
         controls.throttle = 1.0
         # You can set more controls if you want, like controls.boost.
 
-        # Send any drawing we may have done
-        self.renderer.end_rendering()
         return controls
 
     def begin_front_flip(self, packet):
diff --git a/src/util/ball_prediction_analysis.py b/src/util/ball_prediction_analysis.py
@@ -8,10 +8,14 @@
 # We will jump this number of frames when looking for a moment where the ball is inside the goal.
 # Big number for efficiency, but not so big that the ball could go in and then back out during that
 # time span. Unit is the number of frames in the ball prediction, and the prediction is at 60 frames per second.
-COARSE_SEARCH_INCREMENT = 20
+GOAL_SEARCH_INCREMENT = 20
 
 
 def find_slice_at_time(ball_prediction: BallPrediction, game_time: float):
+    """
+    This will find the future position of the ball at the specified time. The returned
+    Slice object will also include the ball's velocity, etc.
+    """
     start_time = ball_prediction.slices[0].game_seconds
     approx_index = int((game_time - start_time) * 60)  # We know that there are 60 slices per second.
     if 0 <= approx_index < ball_prediction.num_slices:
@@ -20,13 +24,24 @@ def find_slice_at_time(ball_prediction: BallPrediction, game_time: float):
 
 
 def predict_future_goal(ball_prediction: BallPrediction):
-    return find_matching_slice(ball_prediction, 0, lambda s: abs(s.physics.location.y) >= GOAL_THRESHOLD)
-
-
-def find_matching_slice(ball_prediction: BallPrediction, start_index: int, predicate: Callable[[Slice], bool]):
-    for coarse_index in range(start_index, ball_prediction.num_slices, COARSE_SEARCH_INCREMENT):
+    """
+    Analyzes the ball prediction to see if the ball will enter one of the goals. Only works on standard arenas.
+    Will return the first ball slice which appears to be inside the goal, or None if it does not enter a goal.
+    """
+    return find_matching_slice(ball_prediction, 0, lambda s: abs(s.physics.location.y) >= GOAL_THRESHOLD,
+                               search_increment=20)
+
+
+def find_matching_slice(ball_prediction: BallPrediction, start_index: int, predicate: Callable[[Slice], bool],
+                        search_increment=1):
+    """
+    Tries to find the first slice in the ball prediction which satisfies the given predicate. For example,
+    you could find the first slice below a certain height. Will skip ahead through the packet by search_increment
+    for better efficiency, then backtrack to find the exact first slice.
+    """
+    for coarse_index in range(start_index, ball_prediction.num_slices, search_increment):
         if predicate(ball_prediction.slices[coarse_index]):
-            for j in range(max(start_index, coarse_index - COARSE_SEARCH_INCREMENT), coarse_index):
+            for j in range(max(start_index, coarse_index - search_increment), coarse_index):
                 ball_slice = ball_prediction.slices[j]
                 if predicate(ball_slice):
                     return ball_slice
diff --git a/src/util/boost_pad_tracker.py b/src/util/boost_pad_tracker.py
@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from typing import List
+
+from rlbot.utils.structures.game_data_struct import GameTickPacket, FieldInfoPacket
+
+from util.vec import Vec3
+
+
+@dataclass
+class BoostPad:
+    location: Vec3
+    is_full_boost: bool
+    is_active: bool  # Active means it's available to be picked up
+    timer: float  # Counts the number of seconds that the pad has been *inactive*
+
+
+class BoostPadTracker:
+    """
+    This class merges together the boost pad location info with the is_active info so you can access it
+    in one convenient list. For it to function correctly, you need to call initialize_boosts once when the
+    game has started, and then update_boost_status every frame so that it knows which pads are active.
+    """
+
+    def __init__(self):
+        self.boost_pads: List[BoostPad] = []
+        self._full_boosts_only: List[BoostPad] = []
+
+    def initialize_boosts(self, game_info: FieldInfoPacket):
+        raw_boosts = [game_info.boost_pads[i] for i in range(game_info.num_boosts)]
+        self.boost_pads: List[BoostPad] = [BoostPad(Vec3(rb.location), rb.is_full_boost, False, 0) for rb in raw_boosts]
+        # Cache the list of full boosts since they're commonly requested.
+        # They reference the same objects in the boost_pads list.
+        self._full_boosts_only: List[BoostPad] = [bp for bp in self.boost_pads if bp.is_full_boost]
+
+    def update_boost_status(self, packet: GameTickPacket):
+        for i in range(packet.num_boost):
+            our_pad = self.boost_pads[i]
+            packet_pad = packet.game_boosts[i]
+            our_pad.is_active = packet_pad.is_active
+            our_pad.timer = packet_pad.timer
+
+    def get_full_boosts(self) -> List[BoostPad]:
+        return self._full_boosts_only
diff --git a/src/util/sequence.py b/src/util/sequence.py
@@ -13,10 +13,20 @@ class StepResult:
 
 class Step:
     def tick(self, packet: GameTickPacket) -> StepResult:
+        """
+        Return appropriate controls for this step in the sequence. If the step is over, you should
+        set done to True in the result, and we'll move on to the next step during the next frame.
+        If you panic and can't return controls at all, you may return None and we will move on to
+        the next step immediately.
+        """
         raise NotImplementedError
 
 
 class ControlStep(Step):
+    """
+    This allows you to repeat the same controls every frame for some specified duration. It's useful for
+    scheduling the button presses needed for kickoffs / dodges / etc.
+    """
     def __init__(self, duration: float, controls: SimpleControllerState):
         self.duration = duration
         self.controls = controls
@@ -36,14 +46,18 @@ def __init__(self, steps: List[Step]):
         self.done = False
 
     def tick(self, packet: GameTickPacket):
-        while True:
-            if self.index >= len(self.steps):
-                self.done = True
-                return SimpleControllerState()
+        while self.index < len(self.steps):
             step = self.steps[self.index]
             result = step.tick(packet)
-            if result.done:
+            if result is None or result.controls is None or result.done:
                 self.index += 1
                 if self.index >= len(self.steps):
+                    # The bot will know not to use this sequence next frame, even though we may be giving it controls.
                     self.done = True
-            return result.controls
+            if result is not None and result.controls is not None:
+                # If the step was able to give us controls, return them to the bot.
+                return result.controls
+            # Otherwise we will loop to the next step in the sequence.
+        # If we reach here, we ran out of steps to attempt.
+        self.done = True
+        return None
