Smooth steering, better spike threshold, documentation.

Author: tarehart

rlbot.cfg

@@ -6,12 +6,13 @@
 
 [Match Configuration]
 # Number of bots/players which will be spawned.  We support up to max 64.
-num_participants = 2
+num_participants = 1
 game_mode = Soccer
 game_map = Mannfield
 
 [Mutator Configuration]
 # Visit https://github.com/RLBot/RLBot/wiki/Config-File-Documentation to see what you can put here.
+Rumble = Spike Rush
 
 [Participant Configuration]
 # Put the name of your bot config file here.  Only num_participants config files will be read!

src/bot.py

@@ -22,6 +22,10 @@ def initialize_agent(self):
         self.spike_watcher = SpikeWatcher()
 
     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.
+        """
 
         if self.active_sequence and not self.active_sequence.done:
             return self.active_sequence.tick(packet)
@@ -61,7 +65,7 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
                 return SimpleControllerState(use_item=True)
 
         # The rest of this code just ball chases.
-        # Find the direction of our car using the Orientation class
+        # Find the direction of your car using the Orientation class
         car_orientation = Orientation(my_car.physics.rotation)
         car_direction = car_orientation.forward
 
@@ -70,15 +74,32 @@ def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
         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
+
+        # 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_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.
+    """
+    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)
@@ -97,6 +118,11 @@ def find_correction(current: Vec3, ideal: Vec3) -> float:
 
 
 def draw_debug(renderer, text_lines: List[str]):
+    """
+    This will draw the lines of text in the upper left corner.
+    This function will automatically put appropriate spacing between each line
+    so they don't overlap.
+    """
     renderer.begin_rendering()
     y = 250
     for line in text_lines:

src/util/spikes.py

@@ -2,6 +2,13 @@
 
 from util.vec import Vec3
 
+# When the ball is attached to a car's spikes, the distance will vary a bit depending on whether the ball is
+# on the front bumper, the roof, etc. It tends to be most far away when the ball is on one of the front corners
+# and that distance is a little under 200. We want to be sure that it's never over 200, otherwise bots will
+# suffer from bad bugs when they don't think the ball is spiked to them but it actually is; they'll probably
+# drive in circles. The opposite problem, where they think it's spiked before it really is, is not so bad because
+# they usually spike it for real a split second later.
+MAX_DISTANCE_WHEN_SPIKED = 200
 
 class SpikeWatcher:
     def __init__(self):
@@ -17,7 +24,7 @@ def read_packet(self, packet: GameTickPacket):
             car = packet.game_cars[i]
             car_location = Vec3(car.physics.location)
             distance = car_location.dist(ball_location)
-            if distance < 195:
+            if distance < MAX_DISTANCE_WHEN_SPIKED:
                 if distance < closest_distance:
                     closest_candidate = car
                     closest_distance = distance
@@ -27,4 +34,3 @@ def read_packet(self, packet: GameTickPacket):
         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)