Adding a sequence system to help with dodges.

Author: tarehart

src/bot.py

@@ -5,19 +5,34 @@
 
 from util.orientation import Orientation
 from util.vec import Vec3
+from util.sequence import Sequence, ControlStep
 
 
 class MyBot(BaseAgent):
 
     def initialize_agent(self):
         # This runs once before the bot starts up
         self.controller_state = SimpleControllerState()
+        self.active_sequence: Sequence = None
 
     def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
-        ball_location = Vec3(packet.game_ball.physics.location)
 
+        if self.active_sequence and not self.active_sequence.done:
+            return self.active_sequence.tick(packet)
+
+        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)
+
+        if 550 < car_velocity.length() < 600:
+            self.active_sequence = Sequence([
+                ControlStep(0.05, SimpleControllerState(jump=True)),
+                ControlStep(0.05, SimpleControllerState(jump=False)),
+                ControlStep(0.2, SimpleControllerState(jump=True, pitch=-1)),
+                ControlStep(0.8, SimpleControllerState()),
+            ])
+            return self.active_sequence.tick(packet)
 
         car_to_ball = ball_location - car_location
 
@@ -27,18 +42,8 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
 
         steer_correction_radians = find_correction(car_direction, car_to_ball)
 
-        if steer_correction_radians > 0:
-            # Positive radians in the unit circle is a turn to the left.
-            turn = -1.0  # Negative value for a turn to the left.
-            action_display = "turn left"
-        else:
-            turn = 1.0
-            action_display = "turn right"
-
         self.controller_state.throttle = 1.0
-        self.controller_state.steer = turn
-
-        draw_debug(self.renderer, my_car, packet.game_ball, action_display)
+        self.controller_state.steer = -1 if steer_correction_radians > 0 else 1.0
 
         return self.controller_state
 
@@ -60,12 +65,3 @@ def find_correction(current: Vec3, ideal: Vec3) -> float:
             diff -= 2 * math.pi
 
     return diff
-
-
-def draw_debug(renderer, car, ball, action_display):
-    renderer.begin_rendering()
-    # draw a line from the car to the ball
-    renderer.draw_line_3d(car.physics.location, ball.physics.location, renderer.white())
-    # print the action that the bot is taking
-    renderer.draw_string_3d(car.physics.location, 2, 2, action_display, renderer.white())
-    renderer.end_rendering()

src/util/sequence.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from typing import List
+
+from rlbot.agents.base_agent import SimpleControllerState
+from rlbot.utils.structures.game_data_struct import GameTickPacket
+
+
+@dataclass
+class StepResult:
+    controls: SimpleControllerState
+    done: bool
+
+
+class Step:
+    def tick(self, packet: GameTickPacket) -> StepResult:
+        raise NotImplementedError
+
+
+class ControlStep(Step):
+    def __init__(self, duration: float, controls: SimpleControllerState):
+        self.duration = duration
+        self.controls = controls
+        self.start_time: float = None
+
+    def tick(self, packet: GameTickPacket) -> StepResult:
+        if self.start_time is None:
+            self.start_time = packet.game_info.seconds_elapsed
+        elapsed_time = packet.game_info.seconds_elapsed - self.start_time
+        return StepResult(controls=self.controls, done=elapsed_time > self.duration)
+
+
+class Sequence:
+    def __init__(self, steps: List[Step]):
+        self.steps = steps
+        self.index = 0
+        self.done = False
+
+    def tick(self, packet: GameTickPacket):
+        while True:
+            if self.index >= len(self.steps):
+                self.done = True
+                return SimpleControllerState()
+            step = self.steps[self.index]
+            result = step.tick(packet)
+            if result.done:
+                self.index += 1
+                if self.index >= len(self.steps):
+                    self.done = True
+            return result.controls