Update app.py

app.py

@@ -2,8 +2,6 @@ import gradio as gr
 from PIL import Image, ImageDraw
 import numpy as np
 import math
-from io import BytesIO
-import base64
 
 # Constants
 BOARD_SIZE = 9
@@ -13,7 +11,7 @@ EMPTY = 0
 WHITE_SOLDIER = 1
 BLACK_SOLDIER = 2
 KING = 3
-CASTLE = (4, 4)  # Center of the 9x9 board (0-based indices)
+CASTLE = (4, 4)
 CAMPS = [
     (0,3), (0,4), (0,5), (1,4),  # Top camp
     (8,3), (8,4), (8,5), (7,4),  # Bottom camp
@@ -22,14 +20,14 @@ CAMPS = [
 ]
 ESCAPES = [(i,j) for i in [0,8] for j in range(BOARD_SIZE)] + [(i,j) for j in [0,8] for i in range(BOARD_SIZE) if (i,j) not in CAMPS]
 COLORS = {
-    'empty': '#FFFFFF',  # White for regular empty cells
-    'castle': '#808080',  # Gray for castle
-    'camp': '#A0522D',    # Brown for camps
-    'escape': '#00FF00',  # Green for escape tiles
-    'white': '#FFFFFF',   # White for white soldiers
-    'black': '#000000',   # Black for black soldiers
-    'king': '#FFD700',    # Gold for king
-    'highlight': '#FFFF00' # Yellow for selected cell
+    'empty': (255, 255, 255),    # White
+    'castle': (128, 128, 128),   # Gray
+    'camp': (139, 69, 19),       # Brown
+    'escape': (0, 255, 0),       # Green
+    'white': (255, 255, 255),    # White
+    'black': (0, 0, 0),          # Black
+    'king': (255, 215, 0),       # Gold
+    'highlight': (255, 255, 0)   # Yellow
 }
 
 # Game state class
@@ -37,9 +35,9 @@ class TablutState:
     def __init__(self):
         self.board = np.zeros((BOARD_SIZE, BOARD_SIZE), dtype=int)
         self.turn = 'WHITE'
-        self.black_in_camps = set(CAMPS)  # Track black pieces in camps
+        self.black_in_camps = set(CAMPS)
         self.setup_initial_position()
-        self.move_history = []  # To detect draws
+        self.move_history = []
 
     def setup_initial_position(self):
         self.board[4, 4] = KING
@@ -59,16 +57,9 @@ class TablutState:
 
 # Utility functions
 def pos_to_coord(pos):
-    """Convert (row, col) to board coordinate (e.g., (4,4) -> 'E5')."""
     row, col = pos
     return f"{chr(ord('A') + col)}{row + 1}"
 
-def coord_to_pos(coord):
-    """Convert board coordinate (e.g., 'E5') to (row, col)."""
-    col = ord(coord[0].upper()) - ord('A')
-    row = int(coord[1]) - 1
-    return (row, col)
-
 def is_adjacent_to_castle(pos):
     x, y = pos
     cx, cy = CASTLE
@@ -95,7 +86,6 @@ def is_valid_move(state, from_pos, to_pos):
     to_row, to_col = to_pos
     if from_row != to_row and from_col != to_col:
         return False
-    # Path must be clear
     if from_row == to_row:
         step = 1 if to_col > from_col else -1
         for col in range(from_col + step, to_col, step):
@@ -106,10 +96,8 @@ def is_valid_move(state, from_pos, to_pos):
         for row in range(from_row + step, to_row, step):
             if state.board[row, from_col] != EMPTY:
                 return False
-    # Castle is only for the king
     if to_pos == CASTLE and piece != KING:
         return False
-    # Camp restrictions
     if to_pos in CAMPS:
         if state.turn == 'WHITE' or (state.turn == 'BLACK' and from_pos not in state.black_in_camps):
             return False
@@ -137,14 +125,12 @@ def get_legal_moves(state, from_pos):
 def is_soldier_captured(state, pos, friendly):
     x, y = pos
     friendly_pieces = get_friendly_pieces(friendly)
-    # Standard capture
     if y > 0 and y < BOARD_SIZE - 1:
         if state.board[x, y-1] in friendly_pieces and state.board[x, y+1] in friendly_pieces:
             return True
     if x > 0 and x < BOARD_SIZE - 1:
         if state.board[x-1, y] in friendly_pieces and state.board[x+1, y] in friendly_pieces:
             return True
-    # Capture against castle or camp
     if is_adjacent_to_castle(pos):
         cx, cy = CASTLE
         if x == cx:
@@ -158,16 +144,17 @@ def is_soldier_captured(state, pos, friendly):
             elif x > cx and x < BOARD_SIZE - 1 and state.board[x+1, y] in friendly_pieces:
                 return True
     if pos in CAMPS:
-        return False  # Cannot capture pieces in camps
+        return False
     for camp in CAMPS:
-        if pos == (camp[0] + 1, camp[1]) and state.board[camp] in friendly_pieces + [EMPTY]:
-            return False
-        elif pos == (camp[0] - 1, camp[1]) and state.board[camp] in friendly_pieces + [EMPTY]:
-            return False
-        elif pos == (camp[0], camp[1] + 1) and state.board[camp] in friendly_pieces + [EMPTY]:
-            return False
-        elif pos == (camp[0], camp[1] - 1) and state.board[camp] in friendly_pieces + [EMPTY]:
-            return False
+        cx, cy = camp
+        if (x, y) == (cx + 1, cy) and 0 <= cx < BOARD_SIZE and state.board[cx, cy] in friendly_pieces + [EMPTY]:
+            return True
+        elif (x, y) == (cx - 1, cy) and 0 <= cx < BOARD_SIZE and state.board[cx, cy] in friendly_pieces + [EMPTY]:
+            return True
+        elif (x, y) == (cx, cy + 1) and 0 <= cy < BOARD_SIZE and state.board[cx, cy] in friendly_pieces + [EMPTY]:
+            return True
+        elif (x, y) == (cx, cy - 1) and 0 <= cy < BOARD_SIZE and state.board[cx, cy] in friendly_pieces + [EMPTY]:
+            return True
     return False
 
 def is_king_captured(state, pos):
@@ -192,7 +179,6 @@ def apply_move(state, from_pos, to_pos):
     new_state.board[from_pos] = EMPTY
     if new_state.turn == 'BLACK' and from_pos in new_state.black_in_camps and to_pos not in CAMPS:
         new_state.black_in_camps.discard(from_pos)
-    # Apply captures
     captures = []
     opponent = 'BLACK' if new_state.turn == 'WHITE' else 'WHITE'
     for x in range(BOARD_SIZE):
@@ -207,7 +193,6 @@ def apply_move(state, from_pos, to_pos):
     for pos in captures:
         new_state.board[pos] = EMPTY
     new_state.turn = 'BLACK' if new_state.turn == 'WHITE' else 'WHITE'
-    # Update move history for draw detection
     board_tuple = tuple(new_state.board.flatten())
     new_state.move_history.append(board_tuple)
     return new_state
@@ -225,23 +210,13 @@ def check_game_status(state):
         return "BLACK WINS"
     if king_pos in ESCAPES:
         return "WHITE WINS"
-    # Check for no legal moves
-    pieces = []
-    for x in range(BOARD_SIZE):
-        for y in range(BOARD_SIZE):
-            if (state.turn == 'WHITE' and state.board[x, y] in [WHITE_SOLDIER, KING]) or \
-               (state.turn == 'BLACK' and state.board[x, y] == BLACK_SOLDIER):
-                pieces.append((x, y))
-    has_moves = False
-    for pos in pieces:
-        if get_legal_moves(state, pos):
-            has_moves = True
-            break
+    pieces = [(x, y) for x in range(BOARD_SIZE) for y in range(BOARD_SIZE) if
+              (state.turn == 'WHITE' and state.board[x, y] in [WHITE_SOLDIER, KING]) or
+              (state.turn == 'BLACK' and state.board[x, y] == BLACK_SOLDIER)]
+    has_moves = any(get_legal_moves(state, pos) for pos in pieces)
     if not has_moves:
         return "BLACK WINS" if state.turn == 'WHITE' else "WHITE WINS"
-    # Check for draw (same state twice)
-    board_tuple = tuple(state.board.flatten())
-    if state.move_history.count(board_tuple) >= 2:
+    if state.move_history.count(tuple(state.board.flatten())) >= 2:
         return "DRAW"
     return "CONTINUE"
 
@@ -257,11 +232,9 @@ def evaluate_state(state):
     king_pos = find_king_position(state)
     if not king_pos:
         return -1000
-    # Heuristic: distance from king to nearest escape
     min_escape_dist = min(manhattan_distance(king_pos, e) for e in ESCAPES)
     white_pieces = sum(1 for x in range(BOARD_SIZE) for y in range(BOARD_SIZE) if state.board[x, y] == WHITE_SOLDIER)
     black_pieces = sum(1 for x in range(BOARD_SIZE) for y in range(BOARD_SIZE) if state.board[x, y] == BLACK_SOLDIER)
-    # Encourage Black to surround king, White to escape
     if state.turn == 'WHITE':
         return -min_escape_dist * 10 + white_pieces * 5 - black_pieces * 3
     else:
@@ -303,21 +276,22 @@ def minimax(state, depth, alpha, beta, maximizing_player):
 
 def ai_move(state):
     if state.turn != 'BLACK':
-        return state, "Not AI's turn", None
-    depth = 3  # Adjustable for performance
+        return state, "Not AI's turn"
+    depth = 3
     _, move = minimax(state, depth, -math.inf, math.inf, True)
     if move:
         from_pos, to_pos = move
         new_state = apply_move(state, from_pos, to_pos)
-        return new_state, f"AI moved from {pos_to_coord(from_pos)} to {pos_to_coord(to_pos)}", None
-    return state, "AI has no moves", None
+        return new_state, f"AI moved from {pos_to_coord(from_pos)} to {pos_to_coord(to_pos)}"
+    return state, "AI has no moves"
 
-# SVG board generation
-def generate_board_svg(state, selected_pos=None):
-    width = BOARD_SIZE * CELL_SIZE
-    height = BOARD_SIZE * CELL_SIZE
-    svg = [f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">']
-    # Draw cells
+# Board visualization
+def generate_board_image(state, selected_pos=None):
+    img = Image.new('RGB', (BOARD_SIZE * CELL_SIZE, BOARD_SIZE * CELL_SIZE), color=COLORS['empty'])
+    draw = ImageDraw.Draw(img)
+    for i in range(BOARD_SIZE + 1):
+        draw.line([(i * CELL_SIZE, 0), (i * CELL_SIZE, BOARD_SIZE * CELL_SIZE)], fill=(0,0,0), width=1)
+        draw.line([(0, i * CELL_SIZE), (BOARD_SIZE * CELL_SIZE, i * CELL_SIZE)], fill=(0,0,0), width=1)
     for x in range(BOARD_SIZE):
         for y in range(BOARD_SIZE):
             pos = (x, y)
@@ -330,70 +304,58 @@ def generate_board_svg(state, selected_pos=None):
                 fill = COLORS['escape']
             if pos == selected_pos:
                 fill = COLORS['highlight']
-            svg.append(f'<rect x="{y * CELL_SIZE}" y="{x * CELL_SIZE}" width="{CELL_SIZE}" height="{CELL_SIZE}" fill="{fill}" stroke="black" stroke-width="1"/>')
-    # Draw pieces
+            draw.rectangle([(y * CELL_SIZE, x * CELL_SIZE), ((y + 1) * CELL_SIZE, (x + 1) * CELL_SIZE)], fill=fill)
     for x in range(BOARD_SIZE):
         for y in range(BOARD_SIZE):
             piece = state.board[x, y]
             if piece != EMPTY:
-                cx = y * CELL_SIZE + CELL_SIZE // 2
-                cy = x * CELL_SIZE + CELL_SIZE // 2
+                center = (y * CELL_SIZE + CELL_SIZE // 2, x * CELL_SIZE + CELL_SIZE // 2)
                 color = COLORS['white'] if piece == WHITE_SOLDIER else COLORS['black'] if piece == BLACK_SOLDIER else COLORS['king']
-                svg.append(f'<circle cx="{cx}" cy="{cy}" r="{PIECE_RADIUS}" fill="{color}" stroke="black" stroke-width="1"/>')
-    # Draw grid labels
+                draw.ellipse([(center[0] - PIECE_RADIUS, center[1] - PIECE_RADIUS),
+                              (center[0] + PIECE_RADIUS, center[1] + PIECE_RADIUS)], fill=color, outline=(0,0,0))
     for i in range(BOARD_SIZE):
-        svg.append(f'<text x="5" y="{i * CELL_SIZE + CELL_SIZE // 2 + 5}" fill="black">{BOARD_SIZE - i}</text>')
-        svg.append(f'<text x="{i * CELL_SIZE + CELL_SIZE // 2 - 5}" y="{height - 10}" fill="black">{chr(ord("A") + i)}</text>')
-    svg.append('</svg>')
-    return ''.join(svg)
-
-def svg_to_image(svg_content):
-    img = Image.new('RGB', (BOARD_SIZE * CELL_SIZE, BOARD_SIZE * CELL_SIZE), color='white')
-    # For Gradio, we encode SVG as base64 to display in HTML
-    svg_bytes = svg_content.encode('utf-8')
-    svg_base64 = base64.b64encode(svg_bytes).decode('utf-8')
-    return svg_base64
+        draw.text((5, i * CELL_SIZE + CELL_SIZE // 2 - 5), str(BOARD_SIZE - i), fill=(0,0,0))
+        draw.text((i * CELL_SIZE + CELL_SIZE // 2 - 5, BOARD_SIZE * CELL_SIZE - 15), chr(ord('A') + i), fill=(0,0,0))
+    return img
 
 # Gradio interface functions
 def click_board(state, selected_pos, evt: gr.SelectData):
     if state.turn != 'WHITE':
-        return state, "It's the AI's turn", None, selected_pos
-    x = evt.index[1] // CELL_SIZE
+        return state, "It's the AI's turn", generate_board_image(state), selected_pos
+    x = evt.index[1] // CELL_SIZE  # Image coordinates are (x, y), board is (row, col)
     y = evt.index[0] // CELL_SIZE
     pos = (x, y)
     if selected_pos is None:
-        # Select a piece
         if state.board[pos] in [WHITE_SOLDIER, KING]:
-            return state, f"Selected {pos_to_coord(pos)}", None, pos
+            return state, f"Selected {pos_to_coord(pos)}", generate_board_image(state, pos), pos
         else:
-            return state, "Select a White piece or King", None, None
+            return state, "Select a White piece or King", generate_board_image(state), None
     else:
-        # Try to move
         if is_valid_move(state, selected_pos, pos):
             new_state = apply_move(state, selected_pos, pos)
             status = check_game_status(new_state)
             if status != "CONTINUE":
-                return new_state, status, None, None
-            # Trigger AI move
-            ai_state, ai_message, _ = ai_move(new_state)
+                return new_state, status, generate_board_image(new_state), None
+            ai_state, ai_message = ai_move(new_state)
             final_status = check_game_status(ai_state)
-            return ai_state, f"Your move to {pos_to_coord(pos)}. {ai_message}. {final_status if final_status != 'CONTINUE' else ''}", None, None
+            message = f"Your move to {pos_to_coord(pos)}. {ai_message}. {final_status if final_status != 'CONTINUE' else ''}"
+            return ai_state, message, generate_board_image(ai_state), None
         else:
-            return state, "Invalid move", None, None
+            return state, "Invalid move", generate_board_image(state), None
 
 def new_game():
     state = TablutState()
-    return state, "New game started. Your turn (White).", generate_board_svg(state), None
+    return state, "New game started. Your turn (White).", generate_board_image(state), None
 
 # Gradio interface
 with gr.Blocks(title="Tablut Game") as demo:
     state = gr.State()
     selected_pos = gr.State(value=None)
-    board_html = gr.HTML(label="Board")
+    board_image = gr.Image(label="Board", type="pil")
     message_label = gr.Label(label="Message")
     new_game_button = gr.Button("New Game")
-    board_html.select(fn=click_board, inputs=[state, selected_pos], outputs=[state, message_label, board_html, selected_pos])
-    new_game_button.click(fn=new_game, outputs=[state, message_label, board_html, selected_pos])
-    demo.load(fn=new_game, outputs=[state, message_label, board_html, selected_pos])
+    board_image.select(fn=click_board, inputs=[state, selected_pos], outputs=[state, message_label, board_image, selected_pos])
+    new_game_button.click(fn=new_game, outputs=[state, message_label, board_image, selected_pos])
+    demo.load(fn=new_game, outputs=[state, message_label, board_image, selected_pos])
 
 # Note: demo.launch() is not needed for HF Spaces