Merge pull request #9 from vnthanhdng/aj/gui

Add GUI to play agents, and set up agent-vs-agent play

Author: vnthanhdng

README.md

@@ -44,6 +44,32 @@ During play you can use these commands:
 - `help` — show command help
 - `quit` — exit the game
 
+## Run the GUI
+
+Play chess with a visual board interface:
+
+```bash
+# Play against an AI (default: human vs alphabeta)
+python play_gui.py
+
+# Watch two AIs play against each other
+python play_gui.py --mode watch --white-agent alphabeta --black-agent minimax --depth 3 --delay 1.0
+
+# Play as white against a specific AI
+python play_gui.py --white-agent human --black-agent expectimax --depth 4
+
+# Customize agents and settings
+python play_gui.py --mode watch --white-agent minimax --black-agent alphabeta --depth 3 --delay 0.5
+```
+
+The GUI provides:
+- Visual chess board with Unicode piece symbols
+- Click-to-move or text input for moves
+- Move history display
+- Position evaluation display
+- Auto-play mode for watching AI vs AI games
+- Undo/reset functionality
+
 ## Running tests
 
 There are lightweight unit tests in `tests/` to validate agents and evaluation. Run them with pytest (recommended):
@@ -62,12 +88,14 @@ python test_evaluation.py
 ## Project layout (key files)
 
 - `main.py` — CLI entrypoint and interactive loop
+- `play_gui.py` — GUI entrypoint for visual chess games
 - `engine.py` (legacy) — reference search implementations and helpers
 - `evaluation.py` (legacy) — standalone evaluation function and piece-square tables
 - `utils.py` — general helpers used by CLI and tests
 - `src/agents/` — agent implementations (human, search-based agents, and learning agents)
 - `src/search/` — search algorithm implementations (minimax, alphabeta, expectimax)
 - `src/evaluation/` — modular evaluators and piece-square tables
+- `src/gui/` — tkinter-based GUI for chess visualization
 - `tests/` — unit tests for agents, search, and evaluation
 
 ## License

agent_tournament.py

@@ -0,0 +1,132 @@
+import argparse
+import chess
+import time
+from src.agents.base_agent import BaseAgent
+from src.agents import MinimaxAgent, AlphaBetaAgent, ExpectimaxAgent
+from evaluation import evaluate
+
+
+def play_single_game(white_agent: BaseAgent, black_agent: BaseAgent, timeout_seconds: int = 120):
+    """
+    Play one game between agents with a hard timeout and move-time tracking.
+    Returns:
+        result (str): "white", "black", "draw", or "timeout"
+        white_avg (float)
+        black_avg (float)
+    """
+    board = chess.Board()
+
+    white_times = []
+    black_times = []
+
+    start_game_time = time.time()
+
+    while not board.is_game_over():
+        # Hard 2 minute timeout
+        if time.time() - start_game_time > timeout_seconds:
+            print("Game terminated due to timeout.")
+            return "timeout", 0, 0
+
+        current_agent = white_agent if board.turn == chess.WHITE else black_agent
+
+        move_start = time.time()
+        print(f"{current_agent}")
+        move = current_agent.choose_move(board)
+        move_end = time.time()
+
+        if move is None:
+            print("Error: Agent returned None move.")
+            return "error", 0, 0
+
+        # Track move time
+        if board.turn == chess.WHITE:
+            white_times.append(move_end - move_start)
+        else:
+            black_times.append(move_end - move_start)
+
+        board.push(move)
+
+    # Compute averages
+    white_avg = sum(white_times) / len(white_times) if white_times else 0
+    black_avg = sum(black_times) / len(black_times) if black_times else 0
+
+    # Determine outcome
+    if board.is_checkmate():
+        winner = "white" if board.turn == chess.BLACK else "black"
+    else:
+        winner = "draw"
+
+    return winner, white_avg, black_avg
+
+
+def make_agents_play(white_agent: BaseAgent, black_agent: BaseAgent, iterations: int):
+    """
+    Run `iterations` number of games and report average move times.
+    """
+    white_avg_list = []
+    black_avg_list = []
+
+    for game_idx in range(1, iterations + 1):
+        print(f"\n=== Starting Game {game_idx}/{iterations} ===")
+        result, w_avg, b_avg = play_single_game(white_agent, black_agent)
+
+        print(f"Game {game_idx} result: {result}")
+        print(f"  White ({white_agent.name}) avg move time: {w_avg:.4f} sec")
+        print(f"  Black({black_agent.name}) avg move time: {b_avg:.4f} sec")
+
+        white_avg_list.append(w_avg)
+        black_avg_list.append(b_avg)
+
+    print("\n===== FINAL RESULTS ACROSS ALL GAMES =====")
+    print(f"{white_agent.name} mean move time: {sum(white_avg_list)/iterations:.4f} sec")
+    print(f"{black_agent.name} mean move time: {sum(black_avg_list)/iterations:.4f} sec")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Play chess with agents")
+    parser.add_argument(
+        "--white-agent",
+        choices=["minimax", "alphabeta", "expectimax"],
+        default="minimax",
+    )
+    parser.add_argument(
+        "--black-agent",
+        choices=["minimax", "alphabeta", "expectimax"],
+        default="alphabeta",
+    )
+    parser.add_argument(
+        "--depth",
+        type=int,
+        default=3,
+        choices=[2, 3, 4, 5],
+        help="Search depth for AI agents (default: 3)",
+    )
+    parser.add_argument(
+        "--num-games",
+        type=int,
+        default=1,
+        help="Number of games to run (default: 1)"
+    )
+    args = parser.parse_args()
+
+    def create_agent(agent_type, color):
+        if agent_type == "minimax":
+            return MinimaxAgent(evaluate, depth=args.depth, name="Minimax", color=color)
+        elif agent_type == "alphabeta":
+            return AlphaBetaAgent(evaluate, depth=args.depth, name="AlphaBeta", color=color)
+        elif agent_type == "expectimax":
+            return ExpectimaxAgent(evaluate, depth=args.depth, name="Expectimax", color=color)
+        raise RuntimeError("Invalid agent type")
+
+    white_agent = create_agent(args.white_agent, chess.WHITE)
+    black_agent = create_agent(args.black_agent, chess.BLACK)
+
+    print(f"Running {args.num_games} games:")
+    print(f"  White = {white_agent.name}")
+    print(f"  Black = {black_agent.name}")
+
+    make_agents_play(white_agent, black_agent, iterations=args.num_games)
+
+
+if __name__ == "__main__":
+    main()

play_gui.py

@@ -0,0 +1,92 @@
+"""Play chess with a GUI - human vs AI or watch two AIs play."""
+
+import argparse
+import chess
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).resolve().parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from src.gui import ChessGUI, play_game_with_gui, watch_agents_play
+from src.agents import HumanAgent, MinimaxAgent, AlphaBetaAgent, ExpectimaxAgent
+from evaluation import evaluate
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Play chess with GUI")
+    parser.add_argument(
+        "--mode",
+        choices=["human", "watch"],
+        default="human",
+        help="Game mode: 'human' to play against AI, 'watch' to watch two AIs play"
+    )
+    parser.add_argument(
+        "--white-agent",
+        choices=["human", "minimax", "alphabeta", "expectimax"],
+        default="human",
+        help="Agent for white (default: human)"
+    )
+    parser.add_argument(
+        "--black-agent",
+        choices=["human", "minimax", "alphabeta", "expectimax"],
+        default="alphabeta",
+        help="Agent for black (default: alphabeta)"
+    )
+    parser.add_argument(
+        "--depth",
+        type=int,
+        default=3,
+        choices=[2, 3, 4, 5],
+        help="Search depth for AI agents (default: 3)"
+    )
+    parser.add_argument(
+        "--delay",
+        type=float,
+        default=1.0,
+        help="Delay between moves in watch mode (seconds, default: 1.0)"
+    )
+    parser.add_argument(
+        "--no-graphics",
+        type=bool,
+        default=False,
+        help="Whether to skip rendering the GUI (default, false)"
+    )
+    
+    args = parser.parse_args()
+    # Create agents (None means human player, handled by GUI)
+    def create_agent(agent_type, color):
+        if agent_type == "human":
+            return None  # GUI handles human input
+        elif agent_type == "minimax":
+            return MinimaxAgent(evaluate, depth=args.depth, name="Minimax", color=color)
+        elif agent_type == "alphabeta":
+            return AlphaBetaAgent(evaluate, depth=args.depth, name="AlphaBeta", color=color)
+        elif agent_type == "expectimax":
+            return ExpectimaxAgent(evaluate, depth=args.depth, name="Expectimax", color=color)
+        return None
+    
+    white_agent = create_agent(args.white_agent, chess.WHITE)
+    black_agent = create_agent(args.black_agent, chess.BLACK)
+    
+    if args.mode == "watch":
+        # Watch two agents play
+        print(f"Watching {white_agent.name} (White) vs {black_agent.name} (Black)")
+        print(f"Move delay: {args.delay} seconds")
+        watch_agents_play(white_agent, black_agent, move_delay=args.delay)
+    else:
+        # Human vs AI
+        white_name = white_agent.name if white_agent else "Human"
+        black_name = black_agent.name if black_agent else "Human"
+        print(f"Playing as {white_name} (White)")
+        print(f"Against {black_name} (Black)")
+        print("\nEnter moves in the text field (e.g., 'e2e4' or 'Nf3')")
+        print("Or click on pieces and squares to make moves")
+        play_game_with_gui(white_agent, black_agent)
+
+
+if __name__ == "__main__":
+    main()
+

src/gui/__init__.py

@@ -0,0 +1,5 @@
+"""GUI module for chess visualization."""
+from .chess_gui import ChessGUI, play_game_with_gui, watch_agents_play
+
+__all__ = ['ChessGUI', 'play_game_with_gui', 'watch_agents_play']
+