Create app.py

app.py

@@ -0,0 +1,248 @@
+import random
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+
+BOARD_SIZE = 5
+NUM_SHIPS = 3
+
+def place_ships(board, num_ships):
+    """ Randomly place 'num_ships' single-cell ships on 'board'. """
+    placed = 0
+    while placed < num_ships:
+        r, c = random.randint(0, BOARD_SIZE - 1), random.randint(0, BOARD_SIZE - 1)
+        if board[r][c] == 0:  # empty spot
+            board[r][c] = 1
+            placed += 1
+
+def init_game():
+    """ Create initial state for a new Battleship game. """
+    user_board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]
+    ai_board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]
+    
+    place_ships(user_board, NUM_SHIPS)
+    place_ships(ai_board, NUM_SHIPS)
+
+    return {
+        "user_board": user_board,
+        "ai_board": ai_board,
+        "user_ships_remaining": NUM_SHIPS,
+        "ai_ships_remaining": NUM_SHIPS,
+        "game_over": False,
+        "message": "Game started! Enter row and column to fire.",
+        "ai_guesses": set()
+    }
+
+def plot_board(board, is_user_board=True):
+    """
+    Visual representation of the game board using Matplotlib.
+    Different colors are used for ships, hits, and misses.
+    """
+    fig, ax = plt.subplots(figsize=(5, 5))
+    colors = {
+        0: "#D3D3D3",  # Empty - Light Gray
+        1: "#1E90FF" if is_user_board else "#D3D3D3",  # Ship - Blue for User, Hidden for AI
+        2: "#FF0000",  # Hit - Red
+        3: "#FFFFFF"   # Miss - White
+    }
+
+    grid = np.array(board)
+    if not is_user_board:
+        # Hide AI's ships by turning cells with '1' into '0'
+        grid = np.where(grid == 1, 0, grid)
+
+    colored_grid = np.vectorize(colors.get)(grid)
+    for r in range(BOARD_SIZE):
+        for c in range(BOARD_SIZE):
+            rect = plt.Rectangle((c, BOARD_SIZE - r - 1), 1, 1,
+                                 facecolor=colored_grid[r][c],
+                                 edgecolor="black")
+            ax.add_patch(rect)
+
+    ax.set_xticks(np.arange(BOARD_SIZE) + 0.5, labels=[str(i) for i in range(BOARD_SIZE)])
+    ax.set_yticks(np.arange(BOARD_SIZE) + 0.5, labels=[str(i) for i in range(BOARD_SIZE)][::-1])
+    ax.set_xticks(np.arange(BOARD_SIZE + 1), minor=True)
+    ax.set_yticks(np.arange(BOARD_SIZE + 1), minor=True)
+    ax.grid(which="minor", color="black", linestyle='-', linewidth=1)
+    ax.set_xlim(0, BOARD_SIZE)
+    ax.set_ylim(0, BOARD_SIZE)
+    ax.set_frame_on(False)
+
+    return fig
+
+def plot_color_key():
+    """ Generates a small color-coded key explaining the board symbols. """
+    fig, ax = plt.subplots(figsize=(5, 1))
+    ax.set_xlim(0, 4)
+    ax.set_ylim(0, 1)
+    color_labels = [
+        ("#1E90FF", "Your Ship"),
+        ("#FF0000", "Hit Ship"),
+        ("#FFFFFF", "Miss"),
+        ("#D3D3D3", "Hidden")
+    ]
+
+    for i, (color, label) in enumerate(color_labels):
+        rect = plt.Rectangle((i, 0), 1, 1, facecolor=color, edgecolor="black")
+        ax.add_patch(rect)
+        ax.text(i + 0.5, 0.5, label, ha='center', va='center', fontsize=10)
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_frame_on(False)
+
+    return fig
+
+def ai_guess(state):
+    """ AI randomly picks an unguessed cell in the user's board and marks hit/miss. """
+    user_board = state["user_board"]
+    valid_positions = [
+        (r, c) for r in range(BOARD_SIZE) 
+        for c in range(BOARD_SIZE) 
+        if (r, c) not in state["ai_guesses"]
+    ]
+    if not valid_positions:
+        return
+
+    r, c = random.choice(valid_positions)
+    state["ai_guesses"].add((r, c))
+
+    if user_board[r][c] == 1:
+        user_board[r][c] = 2  # AI hit
+        state["user_ships_remaining"] -= 1
+        state["message"] += f"\nAI hit your ship at ({r}, {c})!"
+    else:
+        user_board[r][c] = 3  # AI miss
+        state["message"] += f"\nAI missed at ({r}, {c})."
+
+def make_move(state, row, col):
+    """ Handles the user's move, updates the board, and checks win conditions. """
+    if state["game_over"]:
+        return (
+            plot_board(state["user_board"]),
+            plot_board(state["ai_board"], is_user_board=False),
+            state["message"],
+            plot_color_key()
+        )
+
+    # Validate row/col input
+    if not (0 <= row < BOARD_SIZE and 0 <= col < BOARD_SIZE):
+        state["message"] = "Invalid input. Row/Col must be between 0 and 4."
+        return (
+            plot_board(state["user_board"]),
+            plot_board(state["ai_board"], is_user_board=False),
+            state["message"],
+            plot_color_key()
+        )
+
+    # Check if user already attacked this cell
+    if state["ai_board"][row][col] in (2, 3):
+        state["message"] = f"You already attacked ({row}, {col})!"
+        return (
+            plot_board(state["user_board"]),
+            plot_board(state["ai_board"], is_user_board=False),
+            state["message"],
+            plot_color_key()
+        )
+
+    # If there's a ship at the target
+    if state["ai_board"][row][col] == 1:
+        state["ai_board"][row][col] = 2  # User hit
+        state["ai_ships_remaining"] -= 1
+        state["message"] = f"Hit! You hit AI's ship at ({row}, {col})."
+    else:
+        state["ai_board"][row][col] = 3  # User miss
+        state["message"] = f"Miss! No ship at ({row}, {col})."
+
+    # Check if user just won
+    if state["ai_ships_remaining"] == 0:
+        state["message"] += "\nYou sank all the AI's ships. You win!"
+        state["game_over"] = True
+        return (
+            plot_board(state["user_board"]),
+            plot_board(state["ai_board"], is_user_board=False),
+            state["message"],
+            plot_color_key()
+        )
+
+    # Otherwise, let the AI guess
+    ai_guess(state)
+
+    # Check if AI just won
+    if state["user_ships_remaining"] == 0:
+        state["message"] += "\nAI sank all your ships. You lose!"
+        state["game_over"] = True
+
+    return (
+        plot_board(state["user_board"]),
+        plot_board(state["ai_board"], is_user_board=False),
+        state["message"],
+        plot_color_key()
+    )
+
+def reset_game():
+    """ Reset the game state completely. """
+    return init_game()
+
+def update_display(state):
+    """
+    Helper function to pull out the boards and message
+    so we can show them immediately or after any reset.
+    """
+    return (
+        plot_board(state["user_board"]),
+        plot_board(state["ai_board"], is_user_board=False),
+        state["message"],
+        plot_color_key()
+    )
+
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # Battleship Game
+    
+    **Welcome to Battleship!**
+    
+    In your opponent's 5x5 grid, there are three hidden ships (size=1). 
+    Select the row (0-4) and column (0-4) you want to fire at, then hit "Fire!" 
+    Follow the messages to see who gets hit and eventually wins.
+    """)
+
+    # Initialize game state
+    state = gr.State(init_game())
+
+    # Layout
+    with gr.Row():
+        with gr.Column():
+            user_board_display = gr.Plot(label="Your Board")
+        with gr.Column():
+            ai_board_display = gr.Plot(label="AI Board")
+
+    message_display = gr.Textbox(label="Game Messages", interactive=False)
+    color_key_display = gr.Plot(label="Color Key")  # Will be updated automatically
+
+    row_in = gr.Number(label="Row (0-4)", value=0, precision=0)
+    col_in = gr.Number(label="Column (0-4)", value=0, precision=0)
+    fire_button = gr.Button("Fire!")
+    reset_button = gr.Button("Reset Game")
+
+    # Render boards on initial load
+    demo.load(fn=update_display, inputs=state,
+              outputs=[user_board_display, ai_board_display, message_display, color_key_display])
+
+    # Fire action
+    fire_button.click(
+        fn=make_move,
+        inputs=[state, row_in, col_in],
+        outputs=[user_board_display, ai_board_display, message_display, color_key_display]
+    )
+
+    # Reset action
+    # 1. Reset the state
+    # 2. Then re-render the boards using update_display
+    reset_button.click(fn=reset_game, inputs=[], outputs=state).then(
+        fn=update_display,
+        inputs=state,
+        outputs=[user_board_display, ai_board_display, message_display, color_key_display]
+    )
+
+demo.launch()