Update app.py

app.py

@@ -1,164 +1,146 @@
 import gradio as gr
 import random
+import copy
 
-# Initialize the game board and state
-def initialize_game():
-    board = [["" for _ in range(3)] for _ in range(3)]
-    current_player = "X"
-    status = "Player 1's turn (X)"
-    buttons = [gr.Button(value="", elem_classes=["cell-btn"], interactive=True) for _ in range(9)]
-    return board, current_player, status, *buttons
+# Initialize the board
+def initialize_board():
+    return [["" for _ in range(3)] for _ in range(3)]
 
-# Check for a winner
+# Check for winner
 def check_winner(board):
-    for i in range(3):
-        if board[i][0] == board[i][1] == board[i][2] and board[i][0] != "":
-            return board[i][0]
-        if board[0][i] == board[1][i] == board[2][i] and board[0][i] != "":
-            return board[0][i]
+    for row in board:
+        if row[0] == row[1] == row[2] and row[0] != "":
+            return row[0]
+    for col in range(3):
+        if board[0][col] == board[1][col] == board[2][col] and board[0][col] != "":
+            return board[0][col]
     if board[0][0] == board[1][1] == board[2][2] and board[0][0] != "":
         return board[0][0]
     if board[0][2] == board[1][1] == board[2][0] and board[0][2] != "":
         return board[0][2]
+    if all(board[row][col] != "" for row in range(3) for col in range(3)):
+        return "Draw"
     return None
 
-# Check for a draw
-def check_draw(board):
-    return all(cell != "" for row in board for cell in row)
-
-# Minimax algorithm for AI's move
-def minimax(board, depth, is_maximizing, difficulty):
+# Minimax algorithm
+def minimax(board, depth, is_maximizing):
     winner = check_winner(board)
     if winner == "X":
         return -10 + depth
     elif winner == "O":
         return 10 - depth
-    elif check_draw(board):
+    elif winner == "Draw":
         return 0
 
     if is_maximizing:
-        best = -float('inf')
-        for i in range(3):
-            for j in range(3):
-                if board[i][j] == "":
-                    board[i][j] = "O"
-                    best = max(best, minimax(board, depth + 1, False, difficulty))
-                    board[i][j] = ""
-        return best
+        best_score = -float("inf")
+        for row in range(3):
+            for col in range(3):
+                if board[row][col] == "":
+                    board[row][col] = "O"
+                    score = minimax(board, depth + 1, False)
+                    board[row][col] = ""
+                    best_score = max(score, best_score)
+        return best_score
     else:
-        best = float('inf')
-        for i in range(3):
-            for j in range(3):
-                if board[i][j] == "":
-                    board[i][j] = "X"
-                    best = min(best, minimax(board, depth + 1, True, difficulty))
-                    board[i][j] = ""
-        return best
-
-# Find the best move for AI
-def get_best_move(board, difficulty):
-    if difficulty == "easy":
-        # Random move for easy level
-        empty_cells = [(i, j) for i in range(3) for j in range(3) if board[i][j] == ""]
-        if empty_cells:
+        best_score = float("inf")
+        for row in range(3):
+            for col in range(3):
+                if board[row][col] == "":
+                    board[row][col] = "X"
+                    score = minimax(board, depth + 1, True)
+                    board[row][col] = ""
+                    best_score = min(score, best_score)
+        return best_score
+
+# AI move using Minimax
+def ai_move(board, difficulty):
+    if difficulty == "Easy":
+        empty_cells = [(row, col) for row in range(3) for col in range(3) if board[row][col] == ""]
+        return random.choice(empty_cells)
+
+    if difficulty == "Intermediate":
+        if random.random() < 0.5:
+            empty_cells = [(row, col) for row in range(3) for col in range(3) if board[row][col] == ""]
             return random.choice(empty_cells)
 
-    if difficulty == "intermediate":
-        # Mixed strategy for intermediate
-        if random.random() < 0.5:
-            return get_best_move(board, "easy")
-    
-    best_val = -float('inf')
-    best_move = (-1, -1)
-    for i in range(3):
-        for j in range(3):
-            if board[i][j] == "":
-                board[i][j] = "O"
-                move_val = minimax(board, 0, False, difficulty)
-                board[i][j] = ""
-                if move_val > best_val:
-                    best_move = (i, j)
-                    best_val = move_val
+    best_score = -float("inf")
+    best_move = None
+    for row in range(3):
+        for col in range(3):
+            if board[row][col] == "":
+                board[row][col] = "O"
+                score = minimax(board, 0, False)
+                board[row][col] = ""
+                if score > best_score:
+                    best_score = score
+                    best_move = (row, col)
     return best_move
 
 # Handle a move
-def handle_move(board, current_player, button_idx, game_status, difficulty):
-    if "wins" in game_status or "draw" in game_status:
-        buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"], interactive=False) for i in range(9)]
-        return board, current_player, game_status, *buttons
-
-    row, col = divmod(button_idx, 3)
-    if board[row][col] != "":
-        status = f"Invalid move! Player {1 if current_player == 'X' else 2}'s turn ({current_player})"
-        buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"]) for i in range(9)]
-        return board, current_player, status, *buttons
+def handle_move(state, row, col, difficulty):
+    board, current_player, status = state
+    if board[row][col] != "" or status != "Game On":
+        return state
 
     board[row][col] = current_player
     winner = check_winner(board)
+
     if winner:
-        status = f"Player {1 if winner == 'X' else 2} ({winner}) wins! 🎉"
-        buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"], interactive=False) for i in range(9)]
-        return board, current_player, status, *buttons
-
-    if check_draw(board):
-        status = "It's a draw! 🤝"
-        buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"], interactive=False) for i in range(9)]
-        return board, current_player, status, *buttons
-
-    # AI's turn
-    if current_player == "X":
-        current_player = "O"
-        ai_row, ai_col = get_best_move(board, difficulty)
+        return board, current_player, f"{winner} wins!" if winner != "Draw" else "It's a Draw!"
+
+    current_player = "O" if current_player == "X" else "X"
+
+    if current_player == "O":
+        ai_row, ai_col = ai_move(board, difficulty)
         board[ai_row][ai_col] = "O"
         winner = check_winner(board)
         if winner:
-            status = f"AI ({winner}) wins! 🎉"
-            buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"], interactive=False) for i in range(9)]
-            return board, current_player, status, *buttons
+            return board, current_player, f"{winner} wins!" if winner != "Draw" else "It's a Draw!"
+        current_player = "X"
 
-        if check_draw(board):
-            status = "It's a draw! 🤝"
-            buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"], interactive=False) for i in range(9)]
-            return board, current_player, status, *buttons
+    return board, current_player, "Game On"
 
-        current_player = "X"
-        status = f"Player 1's turn (X)"
-
-    buttons = [gr.Button(value=board[i // 3][i % 3], elem_classes=["cell-btn"]) for i in range(9)]
-    return board, current_player, status, *buttons
-
-# Build the Gradio UI
-with gr.Blocks(css=".cell-btn {height: 100px; width: 100px; font-size: 2em; text-align: center;}") as tic_tac_toe:
-    gr.Markdown("## Tic-Tac-Toe with AI 🎮")
-    difficulty = gr.Radio(["easy", "intermediate", "impossible"], value="impossible", label="Difficulty Level")
-
-    # Initialize states
-    board_state = gr.State([["" for _ in range(3)] for _ in range(3)])
-    current_player = gr.State("X")
-    game_status = gr.Textbox(value="Player 1's turn (X)", label="Game Status", interactive=False)
-
-    # Create grid buttons
-    buttons = []
-    for i in range(3):
-        with gr.Row():
-            for j in range(3):
-                btn = gr.Button(value="", elem_classes=["cell-btn"])
-                buttons.append(btn)
-
-    # Update buttons dynamically on click
-    for idx, btn in enumerate(buttons):
-        btn.click(
-            handle_move,
-            inputs=[board_state, current_player, gr.Number(idx, visible=False), game_status, difficulty],
-            outputs=[board_state, current_player, game_status, *buttons],
+# Gradio Interface
+def reset_game():
+    return initialize_board(), "X", "Game On"
+
+def display_board(board):
+    return [[gr.Button.update(value=board[row][col], interactive=(board[row][col] == "")) for col in range(3)] for row in range(3)]
+
+def on_click(state, row, col, difficulty):
+    new_state = handle_move(state, row, col, difficulty)
+    board, _, status = new_state
+    return new_state, display_board(board), status
+
+def main():
+    with gr.Blocks() as app:
+        gr.Markdown("# Tic Tac Toe with Smart AI")
+
+        difficulty = gr.Radio(["Easy", "Intermediate", "Impossible"], value="Impossible", label="Select Difficulty")
+
+        board = gr.State(initialize_board())
+        current_player = gr.State("X")
+        status = gr.State("Game On")
+
+        output_board = gr.Grid([[gr.Button("", elem_id=f"cell-{row}-{col}", interactive=True) for col in range(3)] for row in range(3)])
+        status_display = gr.Textbox("Game On", interactive=False, label="Status")
+
+        reset_button = gr.Button("Reset Game")
+
+        for row in range(3):
+            for col in range(3):
+                output_board[row][col].click(
+                    on_click,
+                    inputs=[board, current_player, status, gr.State(row), gr.State(col), difficulty],
+                    outputs=[board, output_board, status_display]
+                )
+
+        reset_button.click(
+            reset_game, inputs=[], outputs=[board, current_player, status, output_board, status_display]
         )
 
-    # Reset game button
-    reset_button = gr.Button("Reset Game")
-    reset_button.click(
-        initialize_game,
-        inputs=[],
-        outputs=[board_state, current_player, game_status, *buttons],
-    )
+    return app
 
-tic_tac_toe.launch()
+app = main()
+app.launch()