Adding Noob Black (#332)

* Add files via upload

* Update bot.cfg

Author: rocketeeroof

RLBotPack/Noob_Black/src/__init__.py

@@ -0,0 +1,53 @@
+# You don't have to manually edit this file!
+# RLBotGUI has an appearance editor with a nice colorpicker, database of items and more!
+# To open it up, simply click the (i) icon next to your bot's name and then click Edit Appearance
+
+[Bot Loadout]
+team_color_id = 60
+custom_color_id = 0
+car_id = 23
+decal_id = 0
+wheels_id = 1565
+boost_id = 35
+antenna_id = 0
+hat_id = 0
+paint_finish_id = 1681
+custom_finish_id = 1681
+engine_audio_id = 0
+trails_id = 3220
+goal_explosion_id = 3018
+
+[Bot Loadout Orange]
+team_color_id = 3
+custom_color_id = 0
+car_id = 23
+decal_id = 0
+wheels_id = 1565
+boost_id = 35
+antenna_id = 0
+hat_id = 0
+paint_finish_id = 1681
+custom_finish_id = 1681
+engine_audio_id = 0
+trails_id = 3220
+goal_explosion_id = 3018
+
+[Bot Paint Blue]
+car_paint_id = 12
+decal_paint_id = 0
+wheels_paint_id = 7	
+boost_paint_id = 7
+antenna_paint_id = 0
+hat_paint_id = 0
+trails_paint_id = 2
+goal_explosion_paint_id = 0
+
+[Bot Paint Orange]
+car_paint_id = 12
+decal_paint_id = 0
+wheels_paint_id = 14
+boost_paint_id = 14
+antenna_paint_id = 0
+hat_paint_id = 0
+trails_paint_id = 14
+goal_explosion_paint_id = 0

RLBotPack/Noob_Black/src/appearance.cfg

@@ -0,0 +1,33 @@
+[Locations]
+# Path to loadout config. Can use relative path from here.
+looks_config = ./appearance.cfg
+
+# Path to python file. Can use relative path from here.
+python_file = ./bot.py
+
+# Name of the bot in-game
+name = Noob Black
+
+# The maximum number of ticks per second that your bot wishes to receive.
+maximum_tick_rate_preference = 120
+
+[Details]
+# These values are optional but useful metadata for helper programs
+# Name of the bot's creator/developer
+developer = Scumclass
+
+# Short description of the bot
+description = Noob Bot V3, made with code from the black market.
+As always, mainly designed for 3s.
+
+# Fun fact about the bot
+fun_fact = The bot has a Roblox background.
+
+# Tags
+tags = teamplay
+
+# Link to github repository
+github = https://github.com/RLBot/RLBotPythonExample
+
+# Programming language
+language = python

RLBotPack/Noob_Black/src/bot.cfg

@@ -0,0 +1,48 @@
+from typing import Callable
+
+from rlbot.utils.structures.ball_prediction_struct import BallPrediction, Slice
+
+# field length(5120) + ball radius(93) = 5213 however that results in false positives
+GOAL_THRESHOLD = 5235
+
+# 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.
+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:
+        return ball_prediction.slices[approx_index]
+    return None
+
+
+def predict_future_goal(ball_prediction: BallPrediction):
+    """
+    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 - search_increment), coarse_index):
+                ball_slice = ball_prediction.slices[j]
+                if predicate(ball_slice):
+                    return ball_slice
+    return None

RLBotPack/Noob_Black/src/bot.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

RLBotPack/Noob_Black/src/logo.png

@@ -0,0 +1,25 @@
+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)

RLBotPack/Noob_Black/src/util/__init__.py

@@ -0,0 +1,47 @@
+import math
+
+from util.vec import Vec3
+
+
+# This is a helper class for calculating directions relative to your car. You can extend it or delete if you want.
+class Orientation:
+    """
+    This class describes the orientation of an object from the rotation of the object.
+    Use this to find the direction of cars: forward, right, up.
+    It can also be used to find relative locations.
+    """
+
+    def __init__(self, rotation):
+        self.yaw = float(rotation.yaw)
+        self.roll = float(rotation.roll)
+        self.pitch = float(rotation.pitch)
+
+        cr = math.cos(self.roll)
+        sr = math.sin(self.roll)
+        cp = math.cos(self.pitch)
+        sp = math.sin(self.pitch)
+        cy = math.cos(self.yaw)
+        sy = math.sin(self.yaw)
+
+        self.forward = Vec3(cp * cy, cp * sy, sp)
+        self.right = Vec3(cy*sp*sr-cr*sy, sy*sp*sr+cr*cy, -cp*sr)
+        self.up = Vec3(-cr*cy*sp-sr*sy, -cr*sy*sp+sr*cy, cp*cr)
+
+
+# Sometimes things are easier, when everything is seen from your point of view.
+# This function lets you make any location the center of the world.
+# For example, set center to your car's location and ori to your car's orientation, then the target will be
+# relative to your car!
+def relative_location(center: Vec3, ori: Orientation, target: Vec3) -> Vec3:
+    """
+    Returns target as a relative location from center's point of view, using the given orientation. The components of
+    the returned vector describes:
+
+    * x: how far in front
+    * y: how far right
+    * z: how far above
+    """
+    x = (target - center).dot(ori.forward)
+    y = (target - center).dot(ori.right)
+    z = (target - center).dot(ori.up)
+    return Vec3(x, y, z)