Necto: count frames for tick skip

Author: VirxEC

rlbot/managers/hivemind.py

@@ -1,3 +1,4 @@
+from logging import Logger
 import os
 from threading import Event, Thread
 from traceback import print_exc
@@ -15,7 +16,7 @@ class Hivemind:
     """
 
     _logger = DEFAULT_LOGGER
-    loggers = {}
+    loggers: list[Logger] = []
 
     team: int = -1
     indicies: list[int] = []
@@ -81,11 +82,11 @@ def _handle_match_settings(self, match_settings: flat.MatchSettings):
         self._has_match_settings = True
 
         # search match settings for our spawn ids
-        for i, player in enumerate(self.match_settings.player_configurations):
+        for player in self.match_settings.player_configurations:
             if player.spawn_id in self.spawn_ids:
                 self.team = player.team
                 self.names.append(player.name)
-                self.loggers[i] = get_logger(player.name)
+                self.loggers.append(get_logger(player.name))
 
         if not self._initialized_bot and self._has_field_info:
             self._initialize_agent()
@@ -117,7 +118,6 @@ def _packet_preprocess(self, packet: flat.GameTickPacket) -> bool:
             if len(self.indicies) != len(self.spawn_ids):
                 return False
 
-        # print([player.name for player in packet.players], self.spawn_ids, self.indicies)
         return True
 
     def _packet_processor(self):

tests/hivemind/bot.py

@@ -80,6 +80,7 @@ def get_outputs(
 
             self.controllers[i].steer = -steer_correction_radians
             self.controllers[i].throttle = 1
+            self.controllers[i].boost = True
 
         return self.controllers
 

tests/necto/agent.py

@@ -14,10 +14,12 @@ def __init__(self):
             self.actor = torch.jit.load(f)
         torch.set_num_threads(1)
 
-    def act(self, state, beta: float) -> tuple[np.ndarray, list[torch.Tensor]]:
-        state = tuple(torch.from_numpy(s).float() for s in state)
+    def act(
+        self, state: tuple[np.ndarray, np.ndarray, np.ndarray], beta: float
+    ) -> tuple[np.ndarray, list[torch.Tensor]]:
+        tensor_state = tuple(torch.from_numpy(s).float() for s in state)
         with torch.no_grad():
-            out, weights = self.actor(state)
+            out, weights = self.actor(tensor_state)
 
         max_shape = max(o.shape[-1] for o in out)
         logits = (

tests/necto/bot.py

@@ -44,7 +44,7 @@ class Necto(Bot):
     render = False
     hardcoded_kickoffs = True
 
-    prev_time = 0
+    prev_frame = 0
     controls = ControllerState()
     action = np.zeros(8)
     update_action = True
@@ -115,11 +115,10 @@ def render_attention_weights(
         self.renderer.end_rendering()
 
     def get_output(self, packet: GameTickPacket) -> ControllerState:
-        cur_time = packet.game_info.seconds_elapsed
-        delta = cur_time - self.prev_time
-        self.prev_time = cur_time
+        cur_frame = packet.game_info.frame_num
+        ticks_elapsed = cur_frame - self.prev_frame
+        self.prev_frame = cur_frame
 
-        ticks_elapsed = round(delta * 120)
         self.ticks += ticks_elapsed
 
         if len(packet.balls) == 0:

tests/necto/necto_obs.py

@@ -74,8 +74,8 @@ def _maybe_update_obs(self, state: GameState):
             if self.demo_timers[player.car_id] <= 0:
                 self.demo_timers[player.car_id] = 3
             else:
-                self.demo_timers[player.car_id] = max(
-                    self.demo_timers[player.car_id] - self.tick_skip / 120, 0  # type: ignore
+                self.demo_timers[player.car_id] = max(  # type: ignore
+                    self.demo_timers[player.car_id] - self.tick_skip / 120, 0
                 )
             qkv[0, n, 21] = self.demo_timers[player.car_id] / 10
             n += 1