Create app.py

app.py

@@ -0,0 +1,281 @@
+import gradio as gr
+from PIL import Image, ImageDraw
+import numpy as np
+
+# Constants
+BOARD_SIZE = 9
+CELL_SIZE = 50
+PIECE_RADIUS = 20
+EMPTY = 0
+WHITE_SOLDIER = 1
+BLACK_SOLDIER = 2
+KING = 3
+CASTLE = (4, 4)  # Center of the 9x9 board (0-based indices)
+ESCAPES = [(i, j) for i in range(BOARD_SIZE) for j in range(BOARD_SIZE) if i == 0 or i == BOARD_SIZE-1 or j == 0 or j == BOARD_SIZE-1]
+
+# Colors for visualization
+COLOR_EMPTY = (255, 255, 255)  # White for regular empty cells
+COLOR_CASTLE = (150, 150, 150)  # Gray for the castle
+COLOR_ESCAPE = (0, 255, 0)  # Green for escape tiles
+COLOR_WHITE = (255, 255, 255)  # White for white soldiers
+COLOR_BLACK = (0, 0, 0)  # Black for black soldiers
+COLOR_KING = (255, 215, 0)  # Gold for the king
+
+# Game state class
+class TablutState:
+    def __init__(self):
+        """Initialize the game state with an empty board and set White as the starting player."""
+        self.board = np.zeros((BOARD_SIZE, BOARD_SIZE), dtype=int)
+        self.turn = 'WHITE'
+        self.setup_initial_position()
+
+    def setup_initial_position(self):
+        """Set up the initial board configuration for Tablut."""
+        # Place the king at the center (castle)
+        self.board[4, 4] = KING
+        # Place white soldiers around the king in a cross pattern
+        white_positions = [(3,4), (4,3), (4,5), (5,4), (2,4), (4,2), (4,6), (6,4)]
+        for pos in white_positions:
+            self.board[pos] = WHITE_SOLDIER
+        # Place black soldiers in groups at the edges
+        black_positions = [(0,3), (0,4), (0,5), (1,4), (8,3), (8,4), (8,5), (7,4),
+                           (3,0), (4,0), (5,0), (4,1), (3,8), (4,8), (5,8), (4,7)]
+        for pos in black_positions:
+            self.board[pos] = BLACK_SOLDIER
+
+# Utility functions
+def parse_position(s):
+    """
+    Convert a position string (e.g., 'E5') to board coordinates (row, col).
+    A1 is top-left (0,0), I9 is bottom-right (8,8).
+    """
+    s = s.strip().upper()
+    if len(s) != 2 or not s[0].isalpha() or not s[1].isdigit():
+        raise ValueError("Position must be a letter (A-I) followed by a number (1-9)")
+    col = ord(s[0]) - ord('A')
+    row = int(s[1]) - 1
+    if not (0 <= col < BOARD_SIZE and 0 <= row < BOARD_SIZE):
+        raise ValueError("Position out of bounds")
+    return (row, col)
+
+def is_adjacent_to_castle(pos):
+    """Check if a position is orthogonally adjacent to the castle."""
+    x, y = pos
+    cx, cy = CASTLE
+    return (abs(x - cx) == 1 and y == cy) or (abs(y - cy) == 1 and x == cx)
+
+def get_friendly_pieces(friendly):
+    """Return the piece types that can capture for the current player."""
+    if friendly == 'WHITE':
+        return [WHITE_SOLDIER, KING]  # Both white soldiers and king can capture
+    else:
+        return [BLACK_SOLDIER]  # Only black soldiers can capture
+
+# Game logic functions
+def is_valid_move(state, from_pos, to_pos):
+    """Validate if a move from from_pos to to_pos is legal."""
+    if from_pos == to_pos:
+        return False
+    piece = state.board[from_pos]
+    # Check if the piece belongs to the current player
+    if state.turn == 'WHITE' and piece not in [WHITE_SOLDIER, KING]:
+        return False
+    if state.turn == 'BLACK' and piece != BLACK_SOLDIER:
+        return False
+    # Check if destination is empty
+    if state.board[to_pos] != EMPTY:
+        return False
+    # Check if move is orthogonal (like a rook)
+    from_row, from_col = from_pos
+    to_row, to_col = to_pos
+    if from_row != to_row and from_col != to_col:
+        return False
+    # Check if the path is 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):
+            if state.board[from_row, col] != EMPTY:
+                return False
+    elif from_col == to_col:
+        step = 1 if to_row > from_row else -1
+        for row in range(from_row + step, to_row, step):
+            if state.board[row, from_col] != EMPTY:
+                return False
+    # Only the king can move to the castle
+    if to_pos == CASTLE and piece != KING:
+        return False
+    return True
+
+def is_soldier_captured(state, pos, friendly):
+    """Check if a soldier at pos is captured by the friendly player."""
+    x, y = pos
+    friendly_pieces = get_friendly_pieces(friendly)
+    # Standard capture: between two friendly pieces
+    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 the castle
+    if is_adjacent_to_castle(pos):
+        cx, cy = CASTLE
+        if x == cx:  # Same row as castle
+            if y < cy and y > 0 and state.board[x, y-1] in friendly_pieces:  # Left of castle
+                return True
+            elif y > cy and y < BOARD_SIZE - 1 and state.board[x, y+1] in friendly_pieces:  # Right of castle
+                return True
+        elif y == cy:  # Same column as castle
+            if x < cx and x > 0 and state.board[x-1, y] in friendly_pieces:  # Above castle
+                return True
+            elif x > cx and x < BOARD_SIZE - 1 and state.board[x+1, y] in friendly_pieces:  # Below castle
+                return True
+    return False
+
+def is_king_captured(state, pos):
+    """Check if the king at pos is captured by Black."""
+    x, y = pos
+    if pos == CASTLE:
+        # King in castle: must be surrounded on all four sides by black soldiers
+        adjacent = [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]
+        for adj in adjacent:
+            if not (0 <= adj[0] < BOARD_SIZE and 0 <= adj[1] < BOARD_SIZE and state.board[adj] == BLACK_SOLDIER):
+                return False
+        return True
+    elif is_adjacent_to_castle(pos):
+        # King adjacent to castle: must be surrounded on the three free sides
+        cx, cy = CASTLE
+        dx = cx - x
+        dy = cy - y
+        free_directions = [d for d in [(-1,0), (1,0), (0,-1), (0,1)] if d != (dx, dy)]
+        for d in free_directions:
+            check_pos = (x + d[0], y + d[1])
+            if not (0 <= check_pos[0] < BOARD_SIZE and 0 <= check_pos[1] < BOARD_SIZE and state.board[check_pos] == BLACK_SOLDIER):
+                return False
+        return True
+    else:
+        # King elsewhere: captured like a soldier by black pieces
+        return is_soldier_captured(state, pos, 'BLACK')
+
+def apply_captures(state):
+    """Apply capture rules after a move."""
+    captures = []
+    opponent = 'BLACK' if state.turn == 'WHITE' else 'WHITE'
+    # Check opponent soldiers
+    for x in range(BOARD_SIZE):
+        for y in range(BOARD_SIZE):
+            if state.board[x, y] == (WHITE_SOLDIER if opponent == 'WHITE' else BLACK_SOLDIER):
+                if is_soldier_captured(state, (x, y), state.turn):
+                    captures.append((x, y))
+    # Check king if opponent is White
+    if opponent == 'WHITE':
+        king_pos = find_king_position(state)
+        if king_pos and is_king_captured(state, king_pos):
+            captures.append(king_pos)
+    # Remove captured pieces
+    for pos in captures:
+        state.board[pos] = EMPTY
+
+def find_king_position(state):
+    """Find the current position of the king on the board."""
+    for x in range(BOARD_SIZE):
+        for y in range(BOARD_SIZE):
+            if state.board[x, y] == KING:
+                return (x, y)
+    return None
+
+def check_game_status(state):
+    """Check if the game has ended and determine the winner."""
+    king_pos = find_king_position(state)
+    if king_pos is None:
+        return "BLACK WINS"  # King captured
+    elif king_pos in ESCAPES:
+        return "WHITE WINS"  # King reached an escape tile
+    else:
+        return "CONTINUE"
+
+def generate_board_image(state):
+    """Generate an image of the current board state."""
+    img = Image.new('RGB', (BOARD_SIZE * CELL_SIZE, BOARD_SIZE * CELL_SIZE), color=COLOR_EMPTY)
+    draw = ImageDraw.Draw(img)
+    # Draw grid lines
+    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)
+    # Draw special cells
+    for x in range(BOARD_SIZE):
+        for y in range(BOARD_SIZE):
+            if (x, y) == CASTLE:
+                color = COLOR_CASTLE
+            elif (x, y) in ESCAPES:
+                color = COLOR_ESCAPE
+            else:
+                color = COLOR_EMPTY
+            draw.rectangle([(y * CELL_SIZE, x * CELL_SIZE), ((y + 1) * CELL_SIZE, (x + 1) * CELL_SIZE)], fill=color)
+    # Draw pieces
+    for x in range(BOARD_SIZE):
+        for y in range(BOARD_SIZE):
+            piece = state.board[x, y]
+            if piece != EMPTY:
+                center = (y * CELL_SIZE + CELL_SIZE // 2, x * CELL_SIZE + CELL_SIZE // 2)
+                if piece == WHITE_SOLDIER:
+                    draw.ellipse([(center[0] - PIECE_RADIUS, center[1] - PIECE_RADIUS),
+                                  (center[0] + PIECE_RADIUS, center[1] + PIECE_RADIUS)], fill=COLOR_WHITE)
+                elif piece == BLACK_SOLDIER:
+                    draw.ellipse([(center[0] - PIECE_RADIUS, center[1] - PIECE_RADIUS),
+                                  (center[0] + PIECE_RADIUS, center[1] + PIECE_RADIUS)], fill=COLOR_BLACK)
+                elif piece == KING:
+                    draw.ellipse([(center[0] - PIECE_RADIUS, center[1] - PIECE_RADIUS),
+                                  (center[0] + PIECE_RADIUS, center[1] + PIECE_RADIUS)], fill=COLOR_KING)
+    return img
+
+# Gradio interface functions
+def make_move(state, from_str, to_str):
+    """Process a player's move."""
+    try:
+        from_pos = parse_position(from_str)
+        to_pos = parse_position(to_str)
+    except ValueError as e:
+        return state, str(e), generate_board_image(state), state.turn
+    if not is_valid_move(state, from_pos, to_pos):
+        return state, "Invalid move", generate_board_image(state), state.turn
+    # Apply the move
+    state.board[to_pos] = state.board[from_pos]
+    state.board[from_pos] = EMPTY
+    # Apply captures
+    apply_captures(state)
+    # Check game status
+    status = check_game_status(state)
+    if status != "CONTINUE":
+        message = status
+    else:
+        message = ""
+        state.turn = 'BLACK' if state.turn == 'WHITE' else 'WHITE'
+    return state, message, generate_board_image(state), state.turn
+
+def new_game():
+    """Start a new game."""
+    state = TablutState()
+    return state, "", generate_board_image(state), state.turn
+
+# Set up the Gradio interface
+with gr.Blocks(title="Tablut Game") as demo:
+    state = gr.State()
+    board_image = gr.Image(label="Board", type="pil")
+    turn_label = gr.Label(label="Turn")
+    message_label = gr.Label(label="Message")
+    with gr.Row():
+        from_input = gr.Textbox(label="From (e.g., E5)", placeholder="Enter starting position")
+        to_input = gr.Textbox(label="To (e.g., E6)", placeholder="Enter destination")
+    submit_button = gr.Button("Make Move")
+    new_game_button = gr.Button("New Game")
+
+    # Connect functions to buttons
+    submit_button.click(fn=make_move, inputs=[state, from_input, to_input],
+                        outputs=[state, message_label, board_image, turn_label])
+    new_game_button.click(fn=new_game, outputs=[state, message_label, board_image, turn_label])
+    # Initialize the game on load
+    demo.load(fn=new_game, outputs=[state, message_label, board_image, turn_label])
+
+# Launch the app
+demo.launch()