Adding a spike watcher utility so bots know who has spiked the ball.

Author: tarehart

src/bot.cfg

@@ -6,7 +6,7 @@ looks_config = ./appearance.cfg
 python_file = ./bot.py
 
 # Name of the bot in-game
-name = PythonExampleBot
+name = SpikeRushExampleBot
 
 # The maximum number of ticks per second that your bot wishes to receive.
 maximum_tick_rate_preference = 120

src/bot.py

@@ -2,8 +2,10 @@
 
 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.orientation import Orientation
+from util.spikes import SpikeWatcher
 from util.vec import Vec3
 from util.sequence import Sequence, ControlStep
 
@@ -14,17 +16,22 @@ def initialize_agent(self):
         # This runs once before the bot starts up
         self.controller_state = SimpleControllerState()
         self.active_sequence: Sequence = None
+        self.spike_watcher = SpikeWatcher()
 
     def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
 
         if self.active_sequence and not self.active_sequence.done:
             return self.active_sequence.tick(packet)
 
+        self.spike_watcher.read_packet(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)
 
+        # Example of using a sequence
+        # This will do a front flip if the car's velocity is between 550 and 600
         if 550 < car_velocity.length() < 600:
             self.active_sequence = Sequence([
                 ControlStep(0.05, SimpleControllerState(jump=True)),
@@ -34,13 +41,23 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
             ])
             return self.active_sequence.tick(packet)
 
-        car_to_ball = ball_location - car_location
+        # 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.
+        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:
+                return SimpleControllerState(use_item=True)
 
+        # The rest of this code just ball chases.
         # Find the direction of our car using the Orientation class
         car_orientation = Orientation(my_car.physics.rotation)
         car_direction = car_orientation.forward
 
-        steer_correction_radians = find_correction(car_direction, car_to_ball)
+        target = ball_location
+        car_to_target = target - car_location
+        steer_correction_radians = find_correction(car_direction, car_to_target)
 
         self.controller_state.throttle = 1.0
         self.controller_state.steer = -1 if steer_correction_radians > 0 else 1.0

src/util/spikes.py

@@ -0,0 +1,30 @@
+from rlbot.utils.structures.game_data_struct import PlayerInfo, GameTickPacket
+
+from util.vec import Vec3
+
+
+class SpikeWatcher:
+    def __init__(self):
+        self.carrying_car: PlayerInfo = None
+        self.spike_moment = 0
+        self.carry_duration = 0
+
+    def read_packet(self, packet: GameTickPacket):
+        ball_location = Vec3(packet.game_ball.physics.location)
+        closest_candidate: PlayerInfo = None
+        closest_distance = 999999
+        for i in range(packet.num_cars):
+            car = packet.game_cars[i]
+            car_location = Vec3(car.physics.location)
+            distance = car_location.dist(ball_location)
+            if distance < 190:
+                if distance < closest_distance:
+                    closest_candidate = car
+                    closest_distance = distance
+        if closest_candidate != self.carrying_car and closest_candidate is not None:
+            self.spike_moment = packet.game_info.seconds_elapsed
+
+        self.carrying_car = closest_candidate
+        if self.carrying_car is not None:
+            self.carry_duration = packet.game_info.seconds_elapsed - self.spike_moment
+            print(closest_distance)