Ensure only the latest packet is processed

Author: VirxEC

rlbot/interface.py

@@ -250,43 +250,46 @@ def run(self, *, background_thread: bool = False):
         else:
             self._running = True
             while self._running and self.is_connected:
-                self._running = self.handle_incoming_messages(blocking=True)
+                self._running, _ = self.handle_incoming_messages(blocking=True)
             self._running = False
 
-    def handle_incoming_messages(self, blocking: bool = False) -> bool:
+    def handle_incoming_messages(self, blocking: bool = False) -> tuple[bool, bool]:
         """
         Empties queue of incoming messages (should be called regularly, see `run`).
         Optionally blocking, ensuring that at least one message will be handled.
-        Returns true message handling should continue running, and
+
+        First boolean returns true message handling should continue running, and
         false if RLBotServer has asked us to shut down or an error happened.
+
+        Second boolean returns true if there might be more messages to handle without a delay.
         """
         assert self.is_connected, "Connection has not been established"
         try:
             self.socket.setblocking(blocking)
             incoming_message = self.read_message()
             try:
-                return self.handle_incoming_message(incoming_message)
+                return self.handle_incoming_message(incoming_message), True
             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),
                     e,
                 )
-                return False
+                return False, False
             except Exception as e:
                 self.logger.error(
                     "Unexpected error while handling message of type %s: %s",
                     incoming_message.type.name,
                     e,
                 )
-                return False
+                return False, False
         except BlockingIOError:
             # No incoming messages and blocking==False
-            return True
+            return True, False
         except:
             self.logger.error("SocketRelay disconnected unexpectedly!")
-            return False
+            return False, False
 
     def handle_incoming_message(self, incoming_message: SocketMessage):
         """

rlbot/managers/bot.py

@@ -151,6 +151,26 @@ def _packet_processor(self, packet: flat.GamePacket):
         player_input = flat.PlayerInput(self.index, controller)
         self._game_interface.send_player_input(player_input)
 
+    def _run(self):
+        running = True
+        has_more_messages = True
+
+        while running:
+            # If there might be more messages,
+            # check for another one with blocking=False
+            # if there are no more messages, this immediately returns with has_more_messages=False
+            # after there are no more messages and we've processed the latest packet,
+            # wait for the next one with blocking=True
+            running, has_more_messages = self._game_interface.handle_incoming_messages(
+                blocking=not has_more_messages
+            )
+
+            # if there might be more messages, handle them first
+            # this ensures that only the latest packet is processed
+            if self._latest_packet is not None and running and not has_more_messages:
+                self._packet_processor(self._latest_packet)
+                self._latest_packet = None
+
     def run(
         self,
         *,
@@ -172,16 +192,7 @@ def run(
                 rlbot_server_port=rlbot_server_port,
             )
 
-            running = True
-            while running:
-                # Whenever we receive one or more game packets,
-                # we want to process the latest one.
-                running = self._game_interface.handle_incoming_messages(
-                    blocking=self._latest_packet is None
-                )
-                if self._latest_packet is not None and running:
-                    self._packet_processor(self._latest_packet)
-                    self._latest_packet = None
+            self._run()
         except Exception as e:
             self.logger.error("Unexpected error: %s", e)
         finally:

rlbot/managers/hivemind.py

@@ -163,6 +163,26 @@ def _packet_processor(self, packet: flat.GamePacket):
             player_input = flat.PlayerInput(index, controller)
             self._game_interface.send_player_input(player_input)
 
+    def _run(self):
+        running = True
+        has_more_messages = True
+
+        while running:
+            # If there might be more messages,
+            # check for another one with blocking=False
+            # if there are no more messages, this immediately returns with has_more_messages=False
+            # after there are no more messages and we've processed the latest packet,
+            # wait for the next one with blocking=True
+            running, has_more_messages = self._game_interface.handle_incoming_messages(
+                blocking=not has_more_messages
+            )
+
+            # if there might be more messages, handle them first
+            # this ensures that only the latest packet is processed
+            if self._latest_packet is not None and running and not has_more_messages:
+                self._packet_processor(self._latest_packet)
+                self._latest_packet = None
+
     def run(
         self,
         *,
@@ -184,16 +204,7 @@ def run(
                 rlbot_server_port=rlbot_server_port,
             )
 
-            running = True
-            while running:
-                # Whenever we receive one or more game packets,
-                # we want to process the latest one.
-                running = self._game_interface.handle_incoming_messages(
-                    blocking=self._latest_packet is None
-                )
-                if self._latest_packet is not None and running:
-                    self._packet_processor(self._latest_packet)
-                    self._latest_packet = None
+            self._run()
         finally:
             self.retire()
             del self._game_interface

rlbot/managers/script.py

@@ -120,6 +120,26 @@ def _packet_processor(self, packet: flat.GamePacket):
             )
             print_exc()
 
+    def _run(self):
+        running = True
+        has_more_messages = True
+
+        while running:
+            # If there might be more messages,
+            # check for another one with blocking=False
+            # if there are no more messages, this immediately returns with has_more_messages=False
+            # after there are no more messages and we've processed the latest packet,
+            # wait for the next one with blocking=True
+            running, has_more_messages = self._game_interface.handle_incoming_messages(
+                blocking=not has_more_messages
+            )
+
+            # if there might be more messages, handle them first
+            # this ensures that only the latest packet is processed
+            if self._latest_packet is not None and running and not has_more_messages:
+                self._packet_processor(self._latest_packet)
+                self._latest_packet = None
+
     def run(
         self,
         *,
@@ -141,16 +161,7 @@ def run(
                 rlbot_server_port=rlbot_server_port,
             )
 
-            running = True
-            while running:
-                # Whenever we receive one or more game packets,
-                # we want to process the latest one.
-                running = self._game_interface.handle_incoming_messages(
-                    blocking=self._latest_packet is None
-                )
-                if self._latest_packet is not None and running:
-                    self._packet_processor(self._latest_packet)
-                    self._latest_packet = None
+            self._run()
         finally:
             self.retire()
             del self._game_interface