Add window refresher to avoid "game is not responding" on Linux when the algo is running for too long before picking a move

Author: MartinBraquet

squadro/agents/alphabeta_agent.py

@@ -4,6 +4,7 @@
 from squadro.agents.agent import Agent
 from squadro.algorithms import minimax
 from squadro.state.state import State, get_next_state
+from squadro.tools.animation import PygameRefresher
 from squadro.tools.constants import DefaultParams
 from squadro.tools.evaluation import evaluate_advancement
 from squadro.tools.logs import alpha_beta_logger as logger
@@ -120,7 +121,7 @@ class AlphaBetaRelativeAdvancementAgent(AdvancementAgent):
     (best move so far).
     """
 
-    def __init__(self, max_depth=15, **kwargs):
+    def __init__(self, max_depth=20, **kwargs):
         # use fixed time for now
         kwargs.setdefault('max_time_per_move', DefaultParams.max_time_per_move)
         super().__init__(**kwargs)
@@ -140,6 +141,8 @@ def get_action(self, state, last_action=None, time_left=None):
         self.depth = 0
         self.start_time = time()
 
+        pygame_refresher = PygameRefresher()
+
         # if self.total_time is None:
         #     self.total_time = time_left
         # if time_left / self.total_time > 0.2:
@@ -153,6 +156,7 @@ def get_action(self, state, last_action=None, time_left=None):
             minimax_action = minimax.search(state, self)
             if minimax_action is None:
                 raise ValueError('No best move found, check cutoff function')
+            pygame_refresher.refresh()
             if time() - self.start_time < self.max_time_per_move:
                 # Only keep the minimax action computed for the deepest depth if it got time to
                 # explore all the leaf nodes at that depth

squadro/agents/montecarlo_agent.py

@@ -23,6 +23,7 @@
 from squadro.state.evaluators.rl import QLearningEvaluator, DeepQLearningEvaluator
 from squadro.state.evaluators.rollout import RolloutEvaluator
 from squadro.state.state import State, get_next_state
+from squadro.tools.animation import PygameRefresher
 from squadro.tools.constants import DefaultParams, inf, EPS
 from squadro.tools.evaluation import evaluate_advancement
 from squadro.tools.logs import monte_carlo_logger as logger
@@ -266,13 +267,15 @@ def simulate(self) -> None:
     def get_action(self):
         Debug.clear(self.root)
         start_time = time()
+        pygame_refresher = PygameRefresher()
         n = 0
 
         # Needs at least two simulations to give backfill value to one root edge
         while (time() - start_time < self.max_time or n <= 1) and n < self.max_steps:
             logger.debug(f'\nSIMULATION {n}')
             self.simulate()
             n += 1
+            pygame_refresher.refresh()
 
         logger.info(f'{n} simulations performed.\n'
                     f'Root edges:\n{self.root.get_edge_stats(to_string=True)}')

squadro/tools/animation.py

@@ -0,0 +1,20 @@
+from time import time
+
+import pygame
+
+from squadro.tools.constants import PYGAME_REFRESH_SECONDS
+
+
+def refresh_pygame_window():
+    pygame.event.pump()
+
+
+class PygameRefresher:
+    def __init__(self):
+        self.pygame_refresh_time = time()
+        self.is_pygame_init = pygame.get_init()
+
+    def refresh(self):
+        if self.is_pygame_init and time() - self.pygame_refresh_time > PYGAME_REFRESH_SECONDS:
+            refresh_pygame_window()
+            self.pygame_refresh_time = time()

squadro/tools/constants.py

@@ -58,3 +58,4 @@ def update(cls, **kwargs):
 DQL_PATH = DATA_PATH / "deep_q_learning"
 MAX_INT = sys.maxsize
 inf = float("inf")
+PYGAME_REFRESH_SECONDS = 3