Update code

Author: Francisco114492

agents/ai_agent.py

@@ -24,11 +24,21 @@ def __init__(self, model_path):
             )
 
     async def deliberate(self, board, valid_actions):
-        obs = torch.FloatTensor(np.array(board)).to(self.device)
+
+        # Add a tiny delay so humans can watch the game unfold
+        await asyncio.sleep(0.5)
+        obs = np.array(board)
+        if self.player_id == 1:
+            # Inverter: onde é 1 vira 2, onde é 2 vira 1
+            obs = np.where(obs == 1, 1, np.where(obs == 2, -1, 0))
+        else:
+            obs = np.where(obs == 2, 1, np.where(obs == 1, -1, 0))
+
+        obs_tensor = torch.FloatTensor(obs).to(self.device)
 
         with torch.no_grad():
             # A rede dá uma pontuação (Q-value) para cada uma das 64 casas
-            q_values = self.model(obs)
+            q_values = self.model(obs_tensor)
 
             # Criar uma máscara para ignorar jogadas inválidas
             mask = torch.zeros(64).to(self.device)

agents/classical_agent.py

@@ -1,46 +1,67 @@
 import asyncio
 import argparse
+import time
 from typing import List, Optional, Tuple, Dict
 from agents.base_agent import BaseOthelloAgent
 from agents.utils import OthelloLogic
 
-
 class ClassicalAgent(BaseOthelloAgent):
     """
-    Agente Clássico que utiliza o algoritmo Minimax com poda Alpha-Beta.
-    Suporta múltiplos níveis de dificuldade e otimização por tabelas de transposição.
+    Classical Othello Agent using the Minimax algorithm with Alpha-Beta Pruning.
+    
+    This agent supports three difficulty levels:
+    - Normal: Standard search depth.
+    - Hard: Deeper search with mobility heuristics.
+    - Very Hard: Deepest search with transposition tables (cache) and endgame solving.
     """
 
     def __init__(self, difficulty: str = "normal"):
         super().__init__()
-        self.difficulty = difficulty
+        self.set_difficulty(difficulty)
+        # Cache to store evaluated board states and avoid redundant calculations
         self.transposition_table: Dict[Tuple, Tuple[float, Optional[List[int]]]] = {}
 
-        if difficulty == "normal":
+    def set_difficulty(self, difficulty: str):
+        self.difficulty = difficulty
+        if difficulty in ["normal", "n"]:
             self.depth = 4
             self.use_mobility = False
-        elif difficulty == "hard":
+        elif difficulty in ["hard", "h"]:
             self.depth = 6
             self.use_mobility = True
-        elif difficulty == "very_hard":
+        elif difficulty in ["very_hard", "vh"]:
+            # Note: Depth 8 may cause timeouts in the early/mid game due to Python's execution speed
             self.depth = 8
             self.use_mobility = True
 
     async def deliberate(
         self, board: List[List[int]], valid_actions: List[List[int]]
     ) -> Tuple[int, int]:
-        """Calcula a melhor jogada baseada na dificuldade configurada."""
+        """
+        Decision-making entry point. Selects the best move using Minimax.
+
+        Args:
+            board: Current 8x8 board state (0: empty, 1: black, 2: white).
+            valid_actions: List of available [x, y] move coordinates.
+
+        Returns:
+            A tuple (x, y) representing the chosen move.
+        """
+        # Add a tiny delay so humans can watch the game unfold
+        await asyncio.sleep(0.5)
+
         empty_cells = sum(row.count(0) for row in board)
         current_depth = self.depth
 
-        # Solucionador de Fim de Jogo
-        if self.difficulty == "very_hard" and empty_cells <= 12:
+        # Endgame Solver: If few moves remain, search until the end of the game
+        if self.difficulty in ["very_hard", "vh"] and empty_cells <= 12:
             current_depth = empty_cells
-            print(f"[Endgame] Resolvendo {empty_cells} casas restantes.")
+            print(f"[Endgame] Solving the last {empty_cells} positions.")
 
-        self.transposition_table = {}  # Limpar cache para nova jogada
+        self.transposition_table = {}  # Clear cache for each new move to stay current
+        start_t = time.time()
 
-        _, move = self.minmax(
+        score, move = self.minmax(
             board,
             depth=current_depth,
             alpha=float("-inf"),
@@ -50,6 +71,9 @@ async def deliberate(
             use_mobility=self.use_mobility,
         )
 
+        elapsed = time.time() - start_t
+        print(f"Move took {elapsed:.2f}s (Depth: {current_depth}, Mobility: {self.use_mobility})")
+        
         return tuple(move) if move else tuple(valid_actions[0])
 
     def minmax(
@@ -62,9 +86,23 @@ def minmax(
         player_id: int,
         use_mobility: bool = False,
     ) -> Tuple[float, Optional[List[int]]]:
-        """Algoritmo Minimax com Poda Alpha-Beta e Move Ordering."""
-
-        # 1. Cache Check
+        """
+        Recursive Minimax algorithm with Alpha-Beta pruning and move ordering.
+
+        Args:
+            board: 8x8 matrix representing the game state.
+            depth: Current remaining depth in the search tree.
+            alpha: The best value the maximizing player can guarantee (Best for Me).
+            beta: The best value the minimizing player can guarantee (Best for Opponent).
+            maximizing_player: True if it's the agent's turn to maximize the score.
+            player_id: The ID assigned to this agent (1 or 2).
+            use_mobility: Whether to use move count difference in the evaluation function.
+        
+        Returns:
+            A tuple containing (evaluation_score, best_move_coordinates).
+        """
+        
+        # 1. Transposition Table Check (Cache)
         board_tuple = tuple(tuple(row) for row in board)
         state_key = (board_tuple, depth, maximizing_player)
         if state_key in self.transposition_table:
@@ -74,53 +112,55 @@ def minmax(
         current_p = player_id if maximizing_player else opponent
         valid_moves = OthelloLogic.get_valid_moves(board, current_p)
 
+        # Base case: reach depth limit or game over
         if depth == 0 or not valid_moves:
             return OthelloLogic.evaluate_board(board, player_id, use_mobility), None
 
-        # 2. Move Ordering (Priorizar cantos para acelerar a poda)
+        # 2. Move Ordering (Prioritize corners to trigger Alpha-Beta pruning faster)
         valid_moves.sort(key=lambda m: m[0] in [0, 7] and m[1] in [0, 7], reverse=True)
 
         best_move = None
         if maximizing_player:
             max_eval = float("-inf")
             for move in valid_moves:
-                new_board = OthelloLogic.simulate_move(
-                    board, current_p, move[0], move[1]
-                )
-                eval_score, _ = self.minmax(
-                    new_board, depth - 1, alpha, beta, False, player_id, use_mobility
-                )
+                new_board = OthelloLogic.simulate_move(board, current_p, move[0], move[1])
+                eval_score, _ = self.minmax(new_board, depth - 1, alpha, beta, False, player_id, use_mobility)
                 if eval_score > max_eval:
                     max_eval, best_move = eval_score, move
                 alpha = max(alpha, eval_score)
                 if beta <= alpha:
-                    break
+                    break # Beta cut-off
             res = (max_eval, best_move)
         else:
             min_eval = float("inf")
             for move in valid_moves:
-                new_board = OthelloLogic.simulate_move(
-                    board, current_p, move[0], move[1]
-                )
-                eval_score, _ = self.minmax(
-                    new_board, depth - 1, alpha, beta, True, player_id, use_mobility
-                )
+                new_board = OthelloLogic.simulate_move(board, current_p, move[0], move[1])
+                eval_score, _ = self.minmax(new_board, depth - 1, alpha, beta, True, player_id, use_mobility)
                 if eval_score < min_eval:
                     min_eval, best_move = eval_score, move
                 beta = min(beta, eval_score)
                 if beta <= alpha:
-                    break
+                    break # Alpha cut-off
             res = (min_eval, best_move)
 
+        # Save result to cache before returning
         self.transposition_table[state_key] = res
         return res
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Classical Agent - MinMax")
+    parser = argparse.ArgumentParser(description="Classical Othello Agent - Minimax with Alpha-Beta Pruning")
     parser.add_argument(
-        "-d", "--difficulty", choices=["normal", "hard", "very_hard"], default="normal"
+        "-d", "--difficulty", 
+        choices=["n", "normal", "h", "hard", "vh", "very_hard"], 
+        default="normal",
+        help="Difficulty level (normal/hard/very_hard)"
     )
     args = parser.parse_args()
-    agent = ClassicalAgent(difficulty=args.difficulty)
-    asyncio.run(agent.run())
+    
+    # Map shorthand arguments to full difficulty names
+    diff_map = {"n": "normal", "h": "hard", "vh": "very_hard"}
+    difficulty = diff_map.get(args.difficulty, args.difficulty)
+    
+    agent = ClassicalAgent(difficulty=difficulty)
+    asyncio.run(agent.run())

agents/utils.py

@@ -1,6 +1,16 @@
 class OthelloLogic:
     SIZE = 8
     DIRECTIONS = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
+    WEIGHTS = [
+            [100, -20, 10, 5, 5, 10, -20, 100],
+            [-20, -50, -2, -2, -2, -2, -50, -20],
+            [10, -2, 5, 1, 1, 5, -2, 10],
+            [5, -2, 1, 0, 0, 1, -2, 5],
+            [5, -2, 1, 0, 0, 1, -2, 5],
+            [10, -2, 5, 1, 1, 5, -2, 10],
+            [-20, -50, -2, -2, -2, -2, -50, -20],
+            [100, -20, 10, 5, 5, 10, -20, 100],
+        ]
 
     @staticmethod
     def get_flips(board, player_id, x, y):
@@ -52,23 +62,13 @@ def get_valid_moves(board, player_id):
     def evaluate_board(board, player_id, use_mobility=False):
         opponent = 3 - player_id
         score = 0
-        weights = [
-            [100, -20, 10, 5, 5, 10, -20, 100],
-            [-20, -50, -2, -2, -2, -2, -50, -20],
-            [10, -2, 5, 1, 1, 5, -2, 10],
-            [5, -2, 1, 0, 0, 1, -2, 5],
-            [5, -2, 1, 0, 0, 1, -2, 5],
-            [10, -2, 5, 1, 1, 5, -2, 10],
-            [-20, -50, -2, -2, -2, -2, -50, -20],
-            [100, -20, 10, 5, 5, 10, -20, 100],
-        ]
-
+        
         for y in range(8):
             for x in range(8):
                 if board[y][x] == player_id:
-                    score += weights[y][x]
+                    score += OthelloLogic.WEIGHTS[y][x]
                 elif board[y][x] == opponent:
-                    score -= weights[y][x]
+                    score -= OthelloLogic.WEIGHTS[y][x]
         if use_mobility:
             my_moves = len(OthelloLogic.get_valid_moves(board, player_id))
             opp_moves = len(OthelloLogic.get_valid_moves(board, opponent))

src/__init__.py

@@ -12,17 +12,18 @@ def reset(self):
         self.board = [[0] * 8 for _ in range(8)]
         self.board[3][3], self.board[4][4] = 2, 2  # Branco
         self.board[3][4], self.board[4][3] = 1, 1  # Preto
-        return self.get_state()
+        return self.get_state(player_id=1)
 
-    def get_state(self):
-        """Converte o tabuleiro (list) num Tensor que o PyTorch entende."""
-        # Transformamos o board numa matriz numpy
+    def get_state(self, player_id):
         state = np.array(self.board)
-        # Opcional: Normalizar para a IA ver -1 (inimigo), 0 (vazio), 1 (eu)
-        # Se a IA for o jogador 1, não muda nada. Se for o 2, invertemos.
-        return (
-            torch.FloatTensor(state).unsqueeze(0).unsqueeze(0)
-        )  # Formato (1, 1, 8, 8)
+        # Normalização: O jogador atual vê as suas peças como 1 e as do outro como -1
+        if player_id == 1:
+            norm_state = np.where(state == 1, 1, np.where(state == 2, -1, 0))
+        else:
+            norm_state = np.where(state == 2, 1, np.where(state == 1, -1, 0))
+        
+        # SUCESSO: Devolver norm_state
+        return torch.FloatTensor(norm_state).unsqueeze(0).unsqueeze(0)
 
     def step(self, action_idx, player_id):
         """
@@ -34,7 +35,7 @@ def step(self, action_idx, player_id):
 
         # 1. Punição por jogada inválida
         if [x, y] not in valid_moves:
-            return self.get_state(), -10, True  # Jogo acaba com penalização
+            return self.get_state(player_id), -10, True  # Jogo acaba com penalização
 
         # 2. Executar a jogada
         self.board = OthelloLogic.simulate_move(self.board, player_id, x, y)
@@ -58,7 +59,7 @@ def step(self, action_idx, player_id):
             if p1_count == p2_count:
                 reward = 0
 
-        return self.get_state(), reward, done
+        return self.get_state(player_id), reward, done
 
     def get_valid_mask(self, player_id):
         """Retorna um array de 64 posições com 1 onde a jogada é válida e 0 onde não é."""