Merge branch 'master' into config_inconsistencies

Author: NicEastvillage

rlbot/config.py

@@ -7,16 +7,62 @@
 from rlbot.utils.os_detector import CURRENT_OS, OS
 
 
-def __parse_enum(table: dict, key: str, enum: Any, default: int = 0) -> Any:
+class ConfigParsingException(Exception):
+    pass
+
+
+def __enum(table: dict, key: str, enum: Any, default: int = 0) -> Any:
     if key not in table:
-        return enum(0)
+        return enum(default)
     try:
         for i in range(100000):
             if str(enum(i)).split('.')[-1].lower() == table[key].lower():
                 return enum(i)
     except ValueError:
-        logger.warning(f"Unknown value '{table[key]}' for key '{key}' using default ({enum(default)})")
-        return enum(default)
+        raise ConfigParsingException(f"Invalid value {repr(table[key])} for key '{key}'.")
+
+
+def __str(table: dict, key: str, default: str = "") -> str:
+    v = table.get(key, default)
+    if isinstance(v, str):
+        return v
+    raise ConfigParsingException(f"'{key}' has value {repr(v)}. Expected a string.")
+
+
+def __bool(table: dict, key: str, default: bool = False) -> bool:
+    v = table.get(key, default)
+    if isinstance(v, bool):
+        return v
+    raise ConfigParsingException(f"'{key}' has value {repr(v)}. Expected a bool.")
+
+
+def __int(table: dict, key: str, default: int = 0) -> int:
+    v = table.get(key, default)
+    if isinstance(v, int):
+        return v
+    raise ConfigParsingException(f"'{key}' has value {repr(v)}. Expected an int.")
+
+
+def __table(table: dict, key: str) -> dict:
+    v = table.get(key, dict())
+    if isinstance(v, dict):
+        return v
+    raise ConfigParsingException(f"'{key}' has value {repr(v)}. Expected a table.")
+
+
+def __team(table: dict) -> int:
+    if 'team' not in table:
+        return 0
+    v = table['team']
+    if isinstance(v, str):
+        if v.lower() == "blue":
+            return 0
+        if v.lower() == "orange":
+            return 1
+    if isinstance(v, int):
+        if 0 <= v <= 1:
+            return v
+    raise ConfigParsingException(f"'team' has value {repr(v)}. Expected a 0, 1, \"blue\", or \"orange\".")
 
 
 def load_match_config(config_path: Path | str) -> flat.MatchConfiguration:
@@ -27,90 +73,85 @@ def load_match_config(config_path: Path | str) -> flat.MatchConfiguration:
     with open(config_path, "rb") as f:
         config = tomllib.load(f)
 
-    rlbot_table = config.get("rlbot", dict())
-    match_table = config.get("match", dict())
-    mutator_table = config.get("mutators", dict())
+    rlbot_table = __table(config, "rlbot")
+    match_table = __table(config, "match")
+    mutator_table = __table(config, "mutators")
 
     players = []
     for car_table in config.get("cars", []):
-        car_config = car_table.get("config_file")
-        name = car_table.get("name", "")
-        team = car_table.get("team", 0)
-        try:
-            team = int(team)
-        except ValueError:
-            team = {"blue": 0, "orange": 1}.get(team.lower())
-        if team is None or team not in [0, 1]:
-            logger.warning(f"Unknown team '{car_table.get("team")}' for player {len(players)}, using default team 0")
-
-        loadout_file = car_table.get("loadout_file")
-        variant = car_table.get("type", "rlbot")
-        skill = __parse_enum(car_table, "skill", flat.PsyonixSkill, int(flat.PsyonixSkill.AllStar))
+        car_config = __str(car_table, "config_file")
+        name = __str(car_table, "name")
+        team = __team(car_table)
+        loadout_file = __str(car_table, "loadout_file") or None
+        skill = __enum(car_table, "skill", flat.PsyonixSkill, int(flat.PsyonixSkill.AllStar))
+        variant = __str(car_table, "type", "rlbot").lower()
+
         match variant:
             case "rlbot":
-                if car_config is None:
-                    loadout = load_player_loadout(loadout_file, team) if loadout_file else None
-                    players.append(flat.PlayerConfiguration(flat.CustomBot(), name, team, loadout=loadout))
-                else:
-                    abs_config_path = (config_path.parent / car_config).resolve()
-                    players.append(load_player_config(abs_config_path, flat.CustomBot(), team, name, loadout_file))
+                variety, use_config = flat.CustomBot(), True
             case "psyonix":
-                if car_config is None:
-                    loadout = load_player_loadout(loadout_file, team) if loadout_file else None
-                    players.append(flat.PlayerConfiguration(flat.Psyonix(skill), name, team, loadout=loadout))
-                else:
-                    abs_config_path = (config_path.parent / car_config).resolve()
-                    players.append(load_player_config(abs_config_path, flat.Psyonix(skill), team, name, loadout_file))
+                variety, use_config = flat.Psyonix(skill), True
             case "human":
-                loadout = load_player_loadout(loadout_file, team) if loadout_file else None
-                players.append(flat.PlayerConfiguration(flat.Human(), name, team, loadout=loadout))
+                variety, use_config = flat.Human(), False
+            case "partymember":
+                logger.warning("PartyMember player type is not supported yet.")
+                variety, use_config = flat.PartyMember, False
+            case t:
+                raise ConfigParsingException(f"Invalid player type {repr(t)} for player {len(players)}.")
+
+        if use_config and car_config:
+            abs_config_path = (config_path.parent / car_config).resolve()
+            players.append(load_player_config(abs_config_path, variety, team, name, loadout_file))
+        else:
+            loadout = load_player_loadout(loadout_file, team) if loadout_file else None
+            players.append(flat.PlayerConfiguration(variety, name, team, loadout=loadout))
 
     scripts = []
     for script_table in config.get("scripts", []):
-        if script_config := script_table.get("config_file"):
+        if script_config := __str(script_table, "config_file"):
             abs_config_path = (config_path.parent / script_config).resolve()
             scripts.append(load_script_config(abs_config_path))
         else:
             scripts.append(flat.ScriptConfiguration())
 
     mutators = flat.MutatorSettings(
-        match_length=__parse_enum(mutator_table, "match_length", flat.MatchLengthMutator),
-        max_score=__parse_enum(mutator_table, "max_score", flat.MaxScoreMutator),
-        multi_ball=__parse_enum(mutator_table, "multi_ball", flat.MultiBallMutator),
-        overtime=__parse_enum(mutator_table, "overtime", flat.OvertimeMutator),
-        series_length=__parse_enum(mutator_table, "series_length", flat.SeriesLengthMutator),
-        game_speed=__parse_enum(mutator_table, "game_speed", flat.GameSpeedMutator),
-        ball_max_speed=__parse_enum(mutator_table, "ball_max_speed", flat.BallMaxSpeedMutator),
-        ball_type=__parse_enum(mutator_table, "ball_type", flat.BallTypeMutator),
-        ball_weight=__parse_enum(mutator_table, "ball_weight", flat.BallWeightMutator),
-        ball_size=__parse_enum(mutator_table, "ball_size", flat.BallSizeMutator),
-        ball_bounciness=__parse_enum(mutator_table, "ball_bounciness", flat.BallBouncinessMutator),
-        boost_amount=__parse_enum(mutator_table, "boost_amount", flat.BoostMutator),
-        rumble=__parse_enum(mutator_table, "rumble", flat.RumbleMutator),
-        boost_strength=__parse_enum(mutator_table, "boost_strength", flat.BoostStrengthMutator),
-        gravity=__parse_enum(mutator_table, "gravity", flat.GravityMutator),
-        demolish=__parse_enum(mutator_table, "demolish", flat.DemolishMutator),
-        respawn_time=__parse_enum(mutator_table, "respawn_time", flat.RespawnTimeMutator),
-        max_time=__parse_enum(mutator_table, "max_time", flat.MaxTimeMutator),
-        game_event=__parse_enum(mutator_table, "game_event", flat.GameEventMutator),
-        audio=__parse_enum(mutator_table, "audio", flat.AudioMutator),
+        match_length=__enum(mutator_table, "match_length", flat.MatchLengthMutator),
+        max_score=__enum(mutator_table, "max_score", flat.MaxScoreMutator),
+        multi_ball=__enum(mutator_table, "multi_ball", flat.MultiBallMutator),
+        overtime=__enum(mutator_table, "overtime", flat.OvertimeMutator),
+        series_length=__enum(mutator_table, "series_length", flat.SeriesLengthMutator),
+        game_speed=__enum(mutator_table, "game_speed", flat.GameSpeedMutator),
+        ball_max_speed=__enum(mutator_table, "ball_max_speed", flat.BallMaxSpeedMutator),
+        ball_type=__enum(mutator_table, "ball_type", flat.BallTypeMutator),
+        ball_weight=__enum(mutator_table, "ball_weight", flat.BallWeightMutator),
+        ball_size=__enum(mutator_table, "ball_size", flat.BallSizeMutator),
+        ball_bounciness=__enum(mutator_table, "ball_bounciness", flat.BallBouncinessMutator),
+        boost_amount=__enum(mutator_table, "boost_amount", flat.BoostAmountMutator),
+        rumble=__enum(mutator_table, "rumble", flat.RumbleMutator),
+        boost_strength=__enum(mutator_table, "boost_strength", flat.BoostStrengthMutator),
+        gravity=__enum(mutator_table, "gravity", flat.GravityMutator),
+        demolish=__enum(mutator_table, "demolish", flat.DemolishMutator),
+        respawn_time=__enum(mutator_table, "respawn_time", flat.RespawnTimeMutator),
+        max_time=__enum(mutator_table, "max_time", flat.MaxTimeMutator),
+        game_event=__enum(mutator_table, "game_event", flat.GameEventMutator),
+        audio=__enum(mutator_table, "audio", flat.AudioMutator),
     )
 
     return flat.MatchConfiguration(
-        launcher=__parse_enum(rlbot_table, "launcher", flat.Launcher),
-        launcher_arg=rlbot_table.get("launcher_arg", ""),
-        auto_start_bots=rlbot_table.get("auto_start_bots", True),
-        game_map_upk=match_table.get("game_map_upk", ""),
+        launcher=__enum(rlbot_table, "launcher", flat.Launcher),
+        launcher_arg=__str(rlbot_table, "launcher_arg"),
+        auto_start_bots=__bool(rlbot_table, "auto_start_bots", True),
+        game_map_upk=__str(match_table, "game_map_upk"),
         player_configurations=players,
         script_configurations=scripts,
-        game_mode=__parse_enum(match_table, "game_mode", flat.GameMode),
-        skip_replays=match_table.get("skip_replays", False),
-        instant_start=match_table.get("instant_start", False),
+        game_mode=__enum(match_table, "game_mode", flat.GameMode),
+        skip_replays=__bool(match_table, "skip_replays"),
+        instant_start=__bool(match_table, "instant_start"),
         mutators=mutators,
-        existing_match_behavior=__parse_enum(match_table, "existing_match_behavior", flat.ExistingMatchBehavior),
-        enable_rendering=match_table.get("enable_rendering", False),
-        enable_state_setting=match_table.get("enable_state_setting", False),
-        freeplay=match_table.get("freeplay", False),
+        existing_match_behavior=__enum(match_table, "existing_match_behavior", flat.ExistingMatchBehavior),
+        enable_rendering=__bool(match_table, "enable_rendering"),
+        enable_state_setting=__bool(match_table, "enable_state_setting"),
+        freeplay=__bool(match_table, "freeplay"),
     )
 
 
@@ -121,34 +162,35 @@ def load_player_loadout(path: Path | str, team: int) -> flat.PlayerLoadout:
     with open(path, "rb") as f:
         config = tomllib.load(f)
 
-    loadout = config["blue_loadout"] if team == 0 else config["orange_loadout"]
+    table_name = "blue_loadout" if team == 0 else "orange_loadout"
+    loadout = __table(config, table_name)
     paint = None
-    if paint_table := loadout.get("paint", None):
+    if paint_table := __table(loadout, "paint"):
         paint = flat.LoadoutPaint(
-            car_paint_id=paint_table.get("car_paint_id", 0),
-            decal_paint_id=paint_table.get("decal_paint_id", 0),
-            wheels_paint_id=paint_table.get("wheels_paint_id", 0),
-            boost_paint_id=paint_table.get("boost_paint_id", 0),
-            antenna_paint_id=paint_table.get("antenna_paint_id", 0),
-            hat_paint_id=paint_table.get("hat_paint_id", 0),
-            trails_paint_id=paint_table.get("trails_paint_id", 0),
-            goal_explosion_paint_id=paint_table.get("goal_explosion_paint_id", 0),
+            car_paint_id=__int(paint_table, "car_paint_id"),
+            decal_paint_id=__int(paint_table, "decal_paint_id"),
+            wheels_paint_id=__int(paint_table, "wheels_paint_id"),
+            boost_paint_id=__int(paint_table, "boost_paint_id"),
+            antenna_paint_id=__int(paint_table, "antenna_paint_id"),
+            hat_paint_id=__int(paint_table, "hat_paint_id"),
+            trails_paint_id=__int(paint_table, "trails_paint_id"),
+            goal_explosion_paint_id=__int(paint_table, "goal_explosion_paint_id"),
         )
 
     return flat.PlayerLoadout(
-        team_color_id=loadout.get("team_color_id", 0),
-        custom_color_id=loadout.get("custom_color_id", 0),
-        car_id=loadout.get("car_id", 0),
-        decal_id=loadout.get("decal_id", 0),
-        wheels_id=loadout.get("wheels_id", 0),
-        boost_id=loadout.get("boost_id", 0),
-        antenna_id=loadout.get("antenna_id", 0),
-        hat_id=loadout.get("hat_id", 0),
-        paint_finish_id=loadout.get("paint_finish_id", 0),
-        custom_finish_id=loadout.get("custom_finish_id", 0),
-        engine_audio_id=loadout.get("engine_audio_id", 0),
-        trails_id=loadout.get("trails_id", 0),
-        goal_explosion_id=loadout.get("goal_explosion_id", 0),
+        team_color_id=__int(loadout, "team_color_id"),
+        custom_color_id=__int(loadout, "custom_color_id"),
+        car_id=__int(loadout, "car_id"),
+        decal_id=__int(loadout, "decal_id"),
+        wheels_id=__int(loadout, "wheels_id"),
+        boost_id=__int(loadout, "boost_id"),
+        antenna_id=__int(loadout, "antenna_id"),
+        hat_id=__int(loadout, "hat_id"),
+        paint_finish_id=__int(loadout, "paint_finish_id"),
+        custom_finish_id=__int(loadout, "custom_finish_id"),
+        engine_audio_id=__int(loadout, "engine_audio_id"),
+        trails_id=__int(loadout, "trails_id"),
+        goal_explosion_id=__int(loadout, "goal_explosion_id"),
         loadout_paint=paint,
     )
 
@@ -165,29 +207,30 @@ def load_player_config(
     with open(path, "rb") as f:
         config = tomllib.load(f)
 
-    settings: dict[str, Any] = config["settings"]
+    settings = __table(config, "settings")
 
     root_dir = path.parent.absolute()
     if "root_dir" in settings:
-        root_dir /= Path(settings["root_dir"])
+        root_dir /= Path(__str(settings, "root_dir"))
 
-    run_command = settings.get("run_command", "")
+    run_command = __str(settings, "run_command")
     if CURRENT_OS == OS.LINUX and "run_command_linux" in settings:
-        run_command = settings["run_command_linux"]
+        run_command = __str(settings, "run_command_linux")
 
-    loadout_path = path.parent / Path(settings["loadout_file"]) if "loadout_file" in settings else loadout_override
+    loadout_path = path.parent / Path(__str(settings, "loadout_file")) if "loadout_file" in settings else None
+    loadout_path = loadout_override or loadout_path
     loadout = load_player_loadout(loadout_path, team) if loadout_path is not None else None
 
     return flat.PlayerConfiguration(
         type,
-        settings.get("name", name_override or "Unnamed"),
+        name_override or __str(settings, "name"),
         team,
         str(root_dir),
-        str(run_command),
+        run_command,
         loadout,
         0,
-        settings.get("agent_id", ""),
-        settings.get("hivemind", False),
+        __str(settings, "agent_id"),
+        __bool(settings, "hivemind"),
     )
 
 
@@ -203,16 +246,16 @@ def load_script_config(path: Path | str) -> flat.ScriptConfiguration:
 
     root_dir = path.parent
     if "root_dir" in settings:
-        root_dir /= Path(settings["root_dir"])
+        root_dir /= Path(__str(settings, "root_dir"))
 
-    run_command = settings.get("run_command", "")
+    run_command = __str(settings, "run_command")
     if CURRENT_OS == OS.LINUX and "run_command_linux" in settings:
-        run_command = settings["run_command_linux"]
+        run_command = __str(settings, "run_command_linux")
 
     return flat.ScriptConfiguration(
-        settings.get("name", "Unnamed"),
+        __str(settings, "name"),
         str(root_dir),
         run_command,
         0,
-        settings.get("agent_id", ""),
+        __str(settings, "agent_id"),
     )

rlbot/managers/match.py

@@ -122,7 +122,7 @@ def start_match(
 
         if wait_for_start:
             self.wait_for_first_packet()
-            self.logger.info("Match has started.")
+            self.logger.debug("First packet received")
 
     def disconnect(self):
         """

rlbot/version.py

@@ -1 +1 @@
-__version__ = "2.0.0-beta.24"
+__version__ = "2.0.0-beta.25"

tests/atba/atba.py

@@ -57,6 +57,7 @@ class Atba(Bot):
 
     last_demoed = False
     needs_render = True
+    next_teleport = 10
 
     last_send = 0
     controller = flat.ControllerState()
@@ -125,30 +126,30 @@ def get_output(self, packet: flat.GamePacket) -> flat.ControllerState:
         steer_correction_radians = car_direction.correction_to(car_to_ball)
 
         self.controller.steer = -steer_correction_radians
-        self.controller.throttle = 1
+        self.controller.throttle = 1.0
 
         return self.controller
 
     def test_state_setting(self, packet: flat.GamePacket):
-        self.set_game_state(
-            {
-                0: flat.DesiredBallState(
-                    flat.DesiredPhysics(
-                        velocity=flat.Vector3Partial(
-                            z=packet.balls[0].physics.velocity.z + 10
+        if packet.match_info.seconds_elapsed > self.next_teleport:
+            self.next_teleport = packet.match_info.seconds_elapsed + 10
+            self.set_game_state(
+                {
+                    0: flat.DesiredBallState(
+                        flat.DesiredPhysics(
+                            location=flat.Vector3Partial(0, 0, 100),
                         )
                     )
-                )
-            },
-            {
-                i: flat.DesiredCarState(
-                    flat.DesiredPhysics(
-                        velocity=flat.Vector3Partial(z=car.physics.velocity.z + 1)
+                },
+                {
+                    i: flat.DesiredCarState(
+                        flat.DesiredPhysics(
+                            rotation=flat.RotatorPartial(yaw=0)
+                        )
                     )
-                )
-                for i, car in enumerate(packet.players)
-            },
-        )
+                    for i, car in enumerate(packet.players)
+                },
+            )
 
     def test_rendering(self, packet: flat.GamePacket):
         if not self.needs_render:
@@ -163,6 +164,11 @@ def test_rendering(self, packet: flat.GamePacket):
             self.renderer.begin_rendering()
 
             text = ["Hello world!", "I hope I'm centered!"]
+            self.renderer.draw_line_3d(
+                flat.CarAnchor(self.index),
+                flat.RenderAnchor(flat.Vector3(0, 0, 150), flat.CarAnchor(self.index)),
+                self.renderer.lime,
+            )
             self.renderer.draw_string_3d(
                 "\n".join(text),
                 flat.CarAnchor(self.index),

tests/human_vs_atba.toml

@@ -5,6 +5,7 @@ auto_start_bots = true
 [match]
 game_mode = "Soccer"
 game_map_upk = "Stadium_P"
+enable_rendering = true
 
 [mutators]
 match_length = "Unlimited"

tests/render_test/render.py

@@ -95,4 +95,4 @@ def do_render(self, radius: float):
 
 
 if __name__ == "__main__":
-    RenderFun().run(wants_match_communications=False, wants_ball_predictions=False)
+    RenderFun("testing/render_test").run(wants_match_communications=False, wants_ball_predictions=False)

tests/run_match.py

@@ -6,7 +6,7 @@
 
 DIR = Path(__file__).parent
 
-MATCH_CONFIG_PATH = DIR / "render_test.toml"
+MATCH_CONFIG_PATH = DIR / "human_vs_atba.toml"
 RLBOT_SERVER_FOLDER = DIR / "../../core/RLBotCS/bin/Release/"
 
 if __name__ == "__main__":