Rework sim status update to not need a thread.

Rather than polling at 60Hz (which may be faster than the tick rate,
wasting cycles; and also makes synchronization annoying), collect events
during the tick and emit them after (rate limited, pooling events until
it is time for another event to send).

This can be improved by paying attention to the aircraft update list,
which would allow us to avoid updating aircraft that don't have a status
change. To do that we need to be able to quickly lookup a FlightJs
matching a Flight through, and Flight isn't hashable.

We should also be removing dead events and de-duplicating. Currently
each flight has an update for every tick, but only the latest one
matters. Combat update events also don't matter if the same combat is
new in the update.

https://github.com/dcs-liberation/dcs_liberation/issues/1680

game/sim/gameloop.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 
 from .gamelooptimer import GameLoopTimer
 from .gameupdatecallbacks import GameUpdateCallbacks
+from .gameupdateevents import GameUpdateEvents
 from .missionsimulation import MissionSimulation, SimulationAlreadyCompletedError
 from .simspeedsetting import SimSpeedSetting
 
@@ -20,7 +21,9 @@ class GameLoop:
         self.game = game
         self.callbacks = callbacks
         self.timer = GameLoopTimer(self.tick)
-        self.sim = MissionSimulation(self.game, self.callbacks)
+        self.sim = MissionSimulation(self.game)
+        self.events = GameUpdateEvents()
+        self.last_update_time = datetime.now()
         self.started = False
         self.completed = False
 
@@ -53,7 +56,7 @@ class GameLoop:
         self.pause()
         logging.info("Running sim to first contact")
         while not self.completed:
-            self.tick()
+            self.tick(suppress_events=True)
 
     def pause_and_generate_miz(self, output: Path) -> None:
         self.pause()
@@ -68,13 +71,25 @@ class GameLoop:
         self.sim.process_results(debriefing)
         self.completed = True
 
-    def tick(self) -> None:
+    def send_update(self, rate_limit: bool) -> None:
+        now = datetime.now()
+        time_since_update = now - self.last_update_time
+        if not rate_limit or time_since_update >= timedelta(seconds=1 / 60):
+            self.callbacks.on_update(self.events)
+            self.events = GameUpdateEvents()
+            self.last_update_time = now
+
+    def tick(self, suppress_events: bool = False) -> None:
         if not self.started:
             raise RuntimeError("Attempted to tick game loop before initialization")
         try:
-            self.completed = self.sim.tick()
+            self.sim.tick(self.events)
+            self.completed = self.events.simulation_complete
+            if not suppress_events:
+                self.send_update(rate_limit=True)
             if self.completed:
                 self.pause()
+                self.send_update(rate_limit=False)
                 logging.info(f"Simulation completed at {self.sim.time}")
                 self.callbacks.on_simulation_complete()
         except SimulationAlreadyCompletedError: