Initial update for upcoming core v0.7

Author: VirxEC

pyproject.toml

@@ -8,7 +8,7 @@ description = "A high performance Python interface for communicating with RLBot
 dynamic = ["version"]
 requires-python = ">= 3.11"
 dependencies = [
-    "rlbot_flatbuffers~=0.16.0",
+    "rlbot_flatbuffers~=0.17.0",
     "psutil==7.*",
 ]
 readme = "README.md"

rlbot/interface.py

@@ -1,7 +1,6 @@
 import logging
 import time
 from collections.abc import Callable
-from dataclasses import dataclass
 from enum import IntEnum
 from pathlib import Path
 from socket import IPPROTO_TCP, TCP_NODELAY, socket
@@ -18,36 +17,6 @@
 RLBOT_SERVER_PORT = 23234
 
 
-class SocketDataType(IntEnum):
-    """
-    See https://github.com/RLBot/core/blob/master/RLBotCS/Types/DataType.cs
-    and https://wiki.rlbot.org/framework/sockets-specification/#data-types
-    """
-
-    NONE = 0
-    GAME_PACKET = 1
-    FIELD_INFO = 2
-    START_COMMAND = 3
-    MATCH_CONFIGURATION = 4
-    PLAYER_INPUT = 5
-    DESIRED_GAME_STATE = 6
-    RENDER_GROUP = 7
-    REMOVE_RENDER_GROUP = 8
-    MATCH_COMMUNICATION = 9
-    BALL_PREDICTION = 10
-    CONNECTION_SETTINGS = 11
-    STOP_COMMAND = 12
-    SET_LOADOUT = 13
-    INIT_COMPLETE = 14
-    CONTROLLABLE_TEAM_INFO = 15
-
-
-@dataclass(repr=False, eq=False, frozen=True, match_args=False, slots=True)
-class SocketMessage:
-    type: SocketDataType
-    data: bytes
-
-
 class MsgHandlingResult(IntEnum):
     TERMINATED = 0
     NO_INCOMING_MSGS = 1
@@ -66,7 +35,6 @@ class SocketRelay:
     is_connected = False
     _running = False
     """Indicates whether a messages are being handled by the `run` loop (potentially in a background thread)"""
-    _ball_pred = flat.BallPrediction()
 
     on_connect_handlers: list[Callable[[], None]] = []
     packet_handlers: list[Callable[[flat.GamePacket], None]] = []
@@ -77,7 +45,7 @@ class SocketRelay:
     controllable_team_info_handlers: list[
         Callable[[flat.ControllableTeamInfo], None]
     ] = []
-    raw_handlers: list[Callable[[SocketMessage], None]] = []
+    raw_handlers: list[Callable[[flat.CoreMessage], None]] = []
 
     def __init__(
         self,
@@ -116,68 +84,61 @@ def _read_exact(self, n: int) -> bytes:
             pos += cr
         return bytes(buff)
 
-    def read_message(self) -> SocketMessage:
-        type_int = self._read_int()
+    def read_message(self) -> bytes:
         size = self._read_int()
-        data = self._read_exact(size)
-        return SocketMessage(SocketDataType(type_int), data)
+        return self._read_exact(size)
 
-    def send_bytes(self, data: bytes, data_type: SocketDataType):
+    def send_bytes(self, data: bytes):
         assert self.is_connected, "Connection has not been established"
 
         size = len(data)
         if size > MAX_SIZE_2_BYTES:
-            self.logger.error(
-                "Couldn't send %s message because it was too big!", data_type.name
-            )
+            self.logger.error("Couldn't send message because it was too big!")
             return
 
-        message = self._int_to_bytes(data_type) + self._int_to_bytes(size) + data
+        message = self._int_to_bytes(size) + data
         self.socket.sendall(message)
 
-    def send_init_complete(self):
-        self.send_bytes(bytes(), SocketDataType.INIT_COMPLETE)
-
-    def send_set_loadout(self, set_loadout: flat.SetLoadout):
-        self.send_bytes(set_loadout.pack(), SocketDataType.SET_LOADOUT)
-
-    def send_match_comm(self, match_comm: flat.MatchComm):
-        self.send_bytes(match_comm.pack(), SocketDataType.MATCH_COMMUNICATION)
-
-    def send_player_input(self, player_input: flat.PlayerInput):
-        self.send_bytes(player_input.pack(), SocketDataType.PLAYER_INPUT)
-
-    def send_game_state(self, game_state: flat.DesiredGameState):
-        self.send_bytes(game_state.pack(), SocketDataType.DESIRED_GAME_STATE)
-
-    def send_render_group(self, render_group: flat.RenderGroup):
-        self.send_bytes(render_group.pack(), SocketDataType.RENDER_GROUP)
+    def send_msg(
+        self,
+        msg: (
+            flat.DisconnectSignal
+            | flat.StartCommand
+            | flat.MatchConfiguration
+            | flat.PlayerInput
+            | flat.DesiredGameState
+            | flat.RenderGroup
+            | flat.RemoveRenderGroup
+            | flat.MatchComm
+            | flat.ConnectionSettings
+            | flat.StopCommand
+            | flat.SetLoadout
+            | flat.InitComplete
+        ),
+    ):
+        self.send_bytes(flat.InterfacePacket(msg).pack())
 
     def remove_render_group(self, group_id: int):
-        flatbuffer = flat.RemoveRenderGroup(group_id).pack()
-        self.send_bytes(flatbuffer, SocketDataType.REMOVE_RENDER_GROUP)
+        self.send_msg(flat.RemoveRenderGroup(group_id))
 
     def stop_match(self, shutdown_server: bool = False):
-        flatbuffer = flat.StopCommand(shutdown_server).pack()
-        self.send_bytes(flatbuffer, SocketDataType.STOP_COMMAND)
+        self.send_msg(flat.StopCommand(shutdown_server))
 
     def start_match(self, match_config: Path | flat.MatchConfiguration):
         self.logger.info("Python interface is attempting to start match...")
 
         match match_config:
             case Path() as path:
                 string_path = str(path.absolute().resolve())
-                flatbuffer = flat.StartCommand(string_path).pack()
-                flat_type = SocketDataType.START_COMMAND
+                flatbuffer = flat.StartCommand(string_path)
             case flat.MatchConfiguration() as settings:
-                flatbuffer = settings.pack()
-                flat_type = SocketDataType.MATCH_CONFIGURATION
+                flatbuffer = settings
             case _:
                 raise ValueError(
                     "Expected MatchSettings or path to match settings toml file"
                 )
 
-        self.send_bytes(flatbuffer, flat_type)
+        self.send_msg(flatbuffer)
 
     def connect(
         self,
@@ -242,13 +203,14 @@ def connect(
         for handler in self.on_connect_handlers:
             handler()
 
-        flatbuffer = flat.ConnectionSettings(
-            agent_id=self.agent_id,
-            wants_ball_predictions=wants_ball_predictions,
-            wants_comms=wants_match_communications,
-            close_between_matches=close_between_matches,
-        ).pack()
-        self.send_bytes(flatbuffer, SocketDataType.CONNECTION_SETTINGS)
+        self.send_msg(
+            flat.ConnectionSettings(
+                agent_id=self.agent_id,
+                wants_ball_predictions=wants_ball_predictions,
+                wants_comms=wants_match_communications,
+                close_between_matches=close_between_matches,
+            )
+        )
 
     def run(self, *, background_thread: bool = False):
         """
@@ -286,16 +248,14 @@ def handle_incoming_messages(self, blocking: bool = False) -> MsgHandlingResult:
                 return self.handle_incoming_message(incoming_message)
             except flat.InvalidFlatbuffer as e:
                 self.logger.error(
-                    "Error while unpacking message of type %s (%s bytes): %s",
-                    incoming_message.type.name,
-                    len(incoming_message.data),
+                    "Error while unpacking message (%s bytes): %s",
+                    len(incoming_message),
                     e,
                 )
                 return MsgHandlingResult.TERMINATED
             except Exception as e:
                 self.logger.error(
-                    "Unexpected error while handling message of type %s: %s",
-                    incoming_message.type.name,
+                    "Unexpected error while handling message of type: %s",
                     e,
                 )
                 return MsgHandlingResult.TERMINATED
@@ -306,56 +266,43 @@ def handle_incoming_messages(self, blocking: bool = False) -> MsgHandlingResult:
             self.logger.error("SocketRelay disconnected unexpectedly!")
             return MsgHandlingResult.TERMINATED
 
-    def handle_incoming_message(
-        self, incoming_message: SocketMessage
-    ) -> MsgHandlingResult:
+    def handle_incoming_message(self, incoming_message: bytes) -> MsgHandlingResult:
         """
         Handles a messages by passing it to the relevant handlers.
         Returns True if the message was NOT a shutdown request (i.e. NONE).
         """
 
+        flatbuffer = flat.CorePacket.unpack(incoming_message).message
+
         for raw_handler in self.raw_handlers:
-            raw_handler(incoming_message)
+            raw_handler(flatbuffer)
 
-        match incoming_message.type:
-            case SocketDataType.NONE:
+        match flatbuffer.item:
+            case flat.DisconnectSignal():
                 return MsgHandlingResult.TERMINATED
-            case SocketDataType.GAME_PACKET:
-                if len(self.packet_handlers) > 0:
-                    packet = flat.GamePacket.unpack(incoming_message.data)
-                    for handler in self.packet_handlers:
-                        handler(packet)
-            case SocketDataType.FIELD_INFO:
-                if len(self.field_info_handlers) > 0:
-                    field_info = flat.FieldInfo.unpack(incoming_message.data)
-                    for handler in self.field_info_handlers:
-                        handler(field_info)
-            case SocketDataType.MATCH_CONFIGURATION:
-                if len(self.match_config_handlers) > 0:
-                    match_settings = flat.MatchConfiguration.unpack(
-                        incoming_message.data
-                    )
-                    for handler in self.match_config_handlers:
-                        handler(match_settings)
-            case SocketDataType.MATCH_COMMUNICATION:
-                if len(self.match_comm_handlers) > 0:
-                    match_comm = flat.MatchComm.unpack(incoming_message.data)
-                    for handler in self.match_comm_handlers:
-                        handler(match_comm)
-            case SocketDataType.BALL_PREDICTION:
-                if len(self.ball_prediction_handlers) > 0:
-                    self._ball_pred.unpack_with(incoming_message.data)
-                    for handler in self.ball_prediction_handlers:
-                        handler(self._ball_pred)
-            case SocketDataType.CONTROLLABLE_TEAM_INFO:
-                if len(self.controllable_team_info_handlers) > 0:
-                    player_mappings = flat.ControllableTeamInfo.unpack(
-                        incoming_message.data
-                    )
-                    for handler in self.controllable_team_info_handlers:
-                        handler(player_mappings)
+            case flat.GamePacket() as packet:
+                for handler in self.packet_handlers:
+                    handler(packet)
+            case flat.FieldInfo() as field_info:
+                for handler in self.field_info_handlers:
+                    handler(field_info)
+            case flat.MatchConfiguration() as match_config:
+                for handler in self.match_config_handlers:
+                    handler(match_config)
+            case flat.MatchComm() as match_comm:
+                for handler in self.match_comm_handlers:
+                    handler(match_comm)
+            case flat.BallPrediction() as ball_prediction:
+                for handler in self.ball_prediction_handlers:
+                    handler(ball_prediction)
+            case flat.ControllableTeamInfo() as controllable_team_info:
+                for handler in self.controllable_team_info_handlers:
+                    handler(controllable_team_info)
             case _:
-                pass
+                self.logger.warning(
+                    "Received unknown message type: %s",
+                    type(flatbuffer.item).__name__,
+                )
 
         return MsgHandlingResult.MORE_MSGS_QUEUED
 
@@ -364,7 +311,7 @@ def disconnect(self):
             self.logger.warning("Asked to disconnect but was already disconnected.")
             return
 
-        self.send_bytes(bytes([1]), SocketDataType.NONE)
+        self.send_msg(flat.DisconnectSignal())
         timeout = 5.0
         while self._running and timeout > 0:
             time.sleep(0.1)

rlbot/managers/bot.py

@@ -107,7 +107,7 @@ def _try_initialize(self):
             exit()
 
         self._initialized_bot = True
-        self._game_interface.send_init_complete()
+        self._game_interface.send_msg(flat.InitComplete())
 
     def _handle_match_config(self, match_config: flat.MatchConfiguration):
         self.match_config = match_config
@@ -154,7 +154,7 @@ def _packet_processor(self, packet: flat.GamePacket):
             return
 
         player_input = flat.PlayerInput(self.index, controller)
-        self._game_interface.send_player_input(player_input)
+        self._game_interface.send_msg(player_input)
 
     def _run(self):
         running = True
@@ -237,7 +237,7 @@ def send_match_comm(
         - `display`: The message to be displayed in the game in "quick chat", or `None` to display nothing.
         - `team_only`: If True, only your team will receive the message.
         """
-        self._game_interface.send_match_comm(
+        self._game_interface.send_msg(
             flat.MatchComm(
                 self.index,
                 self.team,
@@ -261,7 +261,7 @@ def set_game_state(
         """
 
         game_state = fill_desired_game_state(balls, cars, match_info, commands)
-        self._game_interface.send_game_state(game_state)
+        self._game_interface.send_msg(game_state)
 
     def set_loadout(self, loadout: flat.PlayerLoadout, index: Optional[int] = None):
         """
@@ -270,9 +270,7 @@ def set_loadout(self, loadout: flat.PlayerLoadout, index: Optional[int] = None):
         Does nothing if called outside `initialize` unless state setting is enabled in which case it
         respawns the car with the new loadout.
         """
-        self._game_interface.send_set_loadout(
-            flat.SetLoadout(index or self.index, loadout)
-        )
+        self._game_interface.send_msg(flat.SetLoadout(index or self.index, loadout))
 
     def initialize(self):
         """

rlbot/managers/hivemind.py

@@ -111,7 +111,7 @@ def _try_initialize(self):
             exit()
 
         self._initialized_bot = True
-        self._game_interface.send_init_complete()
+        self._game_interface.send_msg(flat.InitComplete())
 
     def _handle_match_config(self, match_config: flat.MatchConfiguration):
         self.match_config = match_config
@@ -166,7 +166,7 @@ def _packet_processor(self, packet: flat.GamePacket):
                     ", ".join(map(str, self.indices)),
                 )
             player_input = flat.PlayerInput(index, controller)
-            self._game_interface.send_player_input(player_input)
+            self._game_interface.send_msg(player_input)
 
     def _run(self):
         running = True
@@ -251,7 +251,7 @@ def send_match_comm(
         - `display`: The message to be displayed in the game in "quick chat", or `None` to display nothing.
         - `team_only`: If True, only your team will receive the message.
         """
-        self._game_interface.send_match_comm(
+        self._game_interface.send_msg(
             flat.MatchComm(
                 index,
                 self.team,
@@ -275,7 +275,7 @@ def set_game_state(
         """
 
         game_state = fill_desired_game_state(balls, cars, match_info, commands)
-        self._game_interface.send_game_state(game_state)
+        self._game_interface.send_msg(game_state)
 
     def set_loadout(self, loadout: flat.PlayerLoadout, index: int):
         """
@@ -284,7 +284,7 @@ def set_loadout(self, loadout: flat.PlayerLoadout, index: int):
         Does nothing if called outside `initialize` unless state setting is enabled in which case it
         respawns the car with the new loadout.
         """
-        self._game_interface.send_set_loadout(flat.SetLoadout(index, loadout))
+        self._game_interface.send_msg(flat.SetLoadout(index, loadout))
 
     def initialize(self):
         """