Mutliprocessing und Gewinner-Bugfix

tictactoe.py

 from enum import Enum
 import numpy as np
+from concurrent.futures import ProcessPoolExecutor,  as_completed
+import copy
 
 class Player(Enum):
     undefined = 0
@@ -198,20 +200,53 @@ class TicTacToe():
                     if score > best_score:
                         best_score = score
                         move = (i, j)
+                        # Early termination for winning move
+                        if score == 1:
+                            return move
+        return move
+
+    def _evaluate_move(self, i, j, grid, current_player):
+        """Evaluate a single move in isolation for parallel processing"""
+        grid_copy = copy.deepcopy(grid)
+        grid_copy[i, j] = current_player
+        return self._evaluate_recursively(grid_copy, get_opponent(current_player)), (i, j)
+
+    def get_best_move_parallel(self, player: Player | int) -> tuple[int, int]:
+        """Parallel version of get_best_move using ProcessPoolExecutor"""
+        self.active_player = self._get_player_from_int(player)
+        self.opponent = get_opponent(self.active_player)
+
+        possible_moves = [(i, j) for i in range(3) for j in range(3) if self.grid[i, j] == Player.undefined]
+
+        with ProcessPoolExecutor() as executor:
+            futures = []
+            for i, j in possible_moves:
+                futures.append(executor.submit( self._evaluate_move, i, j, copy.deepcopy(self.grid), self.active_player))
+
+            best_score = -np.inf
+            move = (-1, -1)
+            for future in as_completed(futures):
+                score, move = future.result()
+                if score > best_score:
+                    best_score = score
+                    move = move
+                    # Early termination for winning move
+                    if best_score == 1:
+                        for f in futures:
+                            f.cancel()
+                        break
         return move
 
 if __name__ == "__main__":
     ttt = TicTacToe()
-    ttt.add(1, 1, 1)
-    ttt.print_grid()
-    ttt.add(2, 1, 2)
     ttt.print_grid()
     current_player = Player.one
     while ttt.check_winner() == Player.undefined:
-        move = ttt.get_best_move(current_player)
+        move = ttt.get_best_move_parallel(current_player)
         ttt.add(move[0], move[1], current_player)
         if current_player == Player.one:
             current_player = Player.two
         else:
             current_player = Player.one
         ttt.print_grid()
+