Merge pull request #1 from VirxEC/beta0

Beta 1

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.6.0",
+    "rlbot_flatbuffers~=0.8.1",
     "psutil==6.*",
 ]
 readme = "README.md"

rlbot/interface.py

@@ -1,7 +1,7 @@
 import logging
 from enum import IntEnum
 from pathlib import Path
-from socket import socket, timeout
+from socket import IPPROTO_TCP, TCP_NODELAY, socket, timeout
 from threading import Thread
 from time import sleep
 from typing import Callable, Optional
@@ -29,8 +29,10 @@ class SocketDataType(IntEnum):
     REMOVE_RENDER_GROUP = 8
     MATCH_COMMUNICATION = 9
     BALL_PREDICTION = 10
-    READY_MESSAGE = 11
+    CONNECTION_SETTINGS = 11
     STOP_COMMAND = 12
+    SET_LOADOUT = 13
+    INIT_COMPLETE = 14
 
 
 MAX_SIZE_2_BYTES = 2**16 - 1
@@ -76,6 +78,7 @@ def __init__(
         self.logger = get_logger("interface") if logger is None else logger
 
         self.socket = socket()
+        self.socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
 
     def __del__(self):
         self.socket.close()
@@ -91,6 +94,12 @@ def send_bytes(self, data: bytes, data_type: SocketDataType):
         message = int_to_bytes(data_type) + int_to_bytes(size) + data
         self.socket.sendall(message)
 
+    def send_init_complete(self, init_complete: flat.InitComplete):
+        self.send_bytes(init_complete.pack(), 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)
 
@@ -180,12 +189,12 @@ def connect_and_run(
         for handler in self.on_connect_handlers:
             handler()
 
-        flatbuffer = flat.ReadyMessage(
+        flatbuffer = flat.ConnectionSettings(
             wants_ball_predictions,
             wants_match_communcations,
             close_after_match,
         ).pack()
-        self.send_bytes(flatbuffer, SocketDataType.READY_MESSAGE)
+        self.send_bytes(flatbuffer, SocketDataType.CONNECTION_SETTINGS)
 
         incoming_message = read_from_socket(self.socket)
         self.handle_incoming_message(incoming_message)

rlbot/managers/bot.py

@@ -41,7 +41,7 @@ def __init__(self):
         self._game_interface.match_settings_handlers.append(self._handle_match_settings)
         self._game_interface.field_info_handlers.append(self._handle_field_info)
         self._game_interface.match_communication_handlers.append(
-            self._handle_match_communication
+            self.handle_match_communication
         )
         self._game_interface.ball_prediction_handlers.append(
             self._handle_ball_prediction
@@ -61,6 +61,7 @@ def _initialize_agent(self):
             exit()
 
         self._initialized_bot = True
+        self._game_interface.send_init_complete(flat.InitComplete(self.spawn_id))
 
     def _handle_match_settings(self, match_settings: flat.MatchSettings):
         self.match_settings = match_settings
@@ -84,19 +85,10 @@ def _handle_field_info(self, field_info: flat.FieldInfo):
         if not self._initialized_bot and self._has_match_settings:
             self._initialize_agent()
 
-    def _handle_match_communication(self, match_comm: flat.MatchComm):
-        if match_comm.team_only and self.team != match_comm.team:
-            return
-
-        self.handle_match_communication(match_comm)
-
     def _handle_ball_prediction(self, ball_prediction: flat.BallPrediction):
         self.ball_prediction = ball_prediction
 
     def _handle_packet(self, packet: flat.GameTickPacket):
-        if not self._initialized_bot:
-            return
-
         if (
             self.index == -1
             or len(packet.players) <= self.index
@@ -184,6 +176,15 @@ def set_game_state(self, game_state: flat.DesiredGameState):
         """
         self._game_interface.send_game_state(game_state)
 
+    def set_loadout(self, loadout: flat.PlayerLoadout, spawn_id: int):
+        """
+        Sets the loadout of a bot.
+
+        For use as a loadout generator, call inside of `initialize_agent`.
+        Will be ignored if called outside of `initialize_agent` when state setting is disabled.
+        """
+        self._game_interface.send_set_loadout(flat.SetLoadout(spawn_id, loadout))
+
     def initialize_agent(self):
         """
         Called for all heaver initialization that needs to happen.
@@ -195,7 +196,7 @@ def initialize_agent(self):
     def retire(self):
         """Called after the game ends"""
 
-    def get_output(self, game_tick_packet: flat.GameTickPacket) -> flat.ControllerState:
+    def get_output(self, packet: flat.GameTickPacket) -> flat.ControllerState:
         """
         Where all the logic of your bot gets its input and returns its output.
         """

rlbot/managers/hivemind.py

@@ -42,7 +42,7 @@ def __init__(self):
         self._game_interface.match_settings_handlers.append(self._handle_match_settings)
         self._game_interface.field_info_handlers.append(self._handle_field_info)
         self._game_interface.match_communication_handlers.append(
-            self._handle_match_communication
+            self.handle_match_communication
         )
         self._game_interface.ball_prediction_handlers.append(
             self._handle_ball_prediction
@@ -51,6 +51,21 @@ def __init__(self):
 
         self.renderer = Renderer(self._game_interface)
 
+    def _initialize_agent(self):
+        try:
+            self.initialize_agent()
+        except Exception as e:
+            self._logger.critical(
+                "Hivemind %s failed to initialize due the following error: %s",
+                "Unknown" if len(self.names) == 0 else self.names[0],
+                e,
+            )
+            print_exc()
+            exit()
+
+        self._initialized_bot = True
+        self._game_interface.send_init_complete(flat.InitComplete(self.spawn_ids[0]))
+
     def _handle_match_settings(self, match_settings: flat.MatchSettings):
         self.match_settings = match_settings
         self._has_match_settings = True
@@ -64,30 +79,19 @@ def _handle_match_settings(self, match_settings: flat.MatchSettings):
                 break
 
         if not self._initialized_bot and self._has_field_info:
-            self.initialize_agent()
-            self._initialized_bot = True
+            self._initialize_agent()
 
     def _handle_field_info(self, field_info: flat.FieldInfo):
         self.field_info = field_info
         self._has_field_info = True
 
         if not self._initialized_bot and self._has_match_settings:
-            self.initialize_agent()
-            self._initialized_bot = True
-
-    def _handle_match_communication(self, match_comm: flat.MatchComm):
-        if match_comm.team_only and self.team != match_comm.team:
-            return
-
-        self.handle_match_communication(match_comm)
+            self._initialize_agent()
 
     def _handle_ball_prediction(self, ball_prediction: flat.BallPrediction):
         self.ball_prediction = ball_prediction
 
     def _handle_packet(self, packet: flat.GameTickPacket):
-        if not self._initialized_bot:
-            return
-
         if len(self.indicies) != len(self.spawn_ids) or any(
             packet.players[i].spawn_id not in self.spawn_ids for i in self.indicies
         ):
@@ -178,6 +182,15 @@ def set_game_state(self, game_state: flat.DesiredGameState):
         """
         self._game_interface.send_game_state(game_state)
 
+    def set_loadout(self, loadout: flat.PlayerLoadout, spawn_id: int):
+        """
+        Sets the loadout of a bot.
+
+        For use as a loadout generator, call inside of `initialize_agent`.
+        Will be ignored if called outside of `initialize_agent` when state setting is disabled.
+        """
+        self._game_interface.send_set_loadout(flat.SetLoadout(spawn_id, loadout))
+
     def initialize_agent(self):
         """
         Called for all heaver initialization that needs to happen.
@@ -190,7 +203,7 @@ def retire(self):
         """Called after the game ends"""
 
     def get_outputs(
-        self, game_tick_packet: flat.GameTickPacket
+        self, packet: flat.GameTickPacket
     ) -> dict[int, flat.ControllerState]:
         """
         Where all the logic of your bot gets its input and returns its output.

rlbot/managers/match.py

@@ -72,7 +72,13 @@ def get_player_config(
     if CURRENT_OS == OS.LINUX and "run_command_linux" in settings:
         run_command = settings["run_command_linux"]
 
-    loadout_path = settings.get("looks_config", None)
+    loadout_path = settings.get("loadout_config", None)
+
+    if loadout_path is None:
+        loadout_path = settings.get("looks_config", None)
+        if loadout_path is not None:
+            DEFAULT_LOGGER.error("looks_config is deprecated, use loadout_config.")
+
     if loadout_path is not None:
         loadout_path = parent / loadout_path
 
@@ -97,9 +103,9 @@ def get_player_config(
 class MatchManager:
     logger = DEFAULT_LOGGER
     packet: Optional[flat.GameTickPacket] = None
-    game_state = flat.GameStateType.Inactive
     rlbot_server_process: Optional[psutil.Process] = None
     rlbot_server_port = RLBOT_SERVER_PORT
+    initialized = False
 
     def __init__(
         self,
@@ -143,10 +149,9 @@ def ensure_server_started(self, print_version_info: bool = True):
 
     def _packet_reporter(self, packet: flat.GameTickPacket):
         self.packet = packet
-        self.game_state = packet.game_info.game_state_type
 
     def wait_for_valid_packet(self):
-        while self.game_state in {
+        while self.packet is not None and self.packet.game_info.game_state_type in {
             flat.GameStateType.Inactive,
             flat.GameStateType.Ended,
         }:
@@ -158,21 +163,31 @@ def start_match(
         self.logger.info("Python attempting to start match.")
         self.rlbot_interface.start_match(match_config, self.rlbot_server_port)
 
+        if not self.initialized:
+            self.rlbot_interface.send_init_complete(flat.InitComplete())
+            self.initialized = True
+
         if wait_for_start:
             self.wait_for_valid_packet()
             self.logger.info("Match has started.")
 
     def disconnect(self):
         self.rlbot_interface.disconnect()
 
+    def stop_match(self):
+        self.rlbot_interface.stop_match()
+
+    def set_game_state(self, game_state: flat.DesiredGameState):
+        self.rlbot_interface.send_game_state(game_state)
+
     def shut_down(self, ensure_shutdown=True):
         self.logger.info("Shutting down RLBot...")
 
         # in theory this is all we need for the server to cleanly shut itself down
         try:
             self.rlbot_interface.stop_match(shutdown_server=True)
         except BrokenPipeError:
-            match gateway.find_server_process(self.main_executable_name):
+            match gateway.find_server_process(self.main_executable_name)[0]:
                 case psutil.Process() as proc:
                     self.logger.warning(
                         "Can't communicate with RLBotServer, ensuring shutdown."