Update app.py

app.py

@@ -1,86 +1,169 @@
 import gradio as gr
-import random
-from typing import Dict
-import uuid
+import numpy as np
+from typing import List, Tuple, Optional
 
 class TicTacToe:
     def __init__(self):
-        self.board = [" " for _ in range(9)]
-        self.winning_combinations = [
-            [0, 1, 2], [3, 4, 5], [6, 7, 8],  # Rows
-            [0, 3, 6], [1, 4, 7], [2, 5, 8],  # Columns
-            [0, 4, 8], [2, 4, 6]              # Diagonals
-        ]
-        self.human = "X"
-        self.ai = "O"
-        self.current_player = self.human
-
-    def reset(self):
-        self.board = [" " for _ in range(9)]
-        self.current_player = self.human
-        return self.board
-
-    # Rest of your TicTacToe class remains the same...
-    # (keeping all other methods identical)
-
-# Dictionary to store game instances for each session
-games: Dict[str, TicTacToe] = {}
-
-def get_game(session_id: str) -> TicTacToe:
-    if session_id not in games:
-        games[session_id] = TicTacToe()
-    return games[session_id]
-
-css = """
-# Your existing CSS remains the same
-"""
-
-def create_interface():
-    with gr.Blocks(css=css) as demo:
-        session_id = gr.State(lambda: str(uuid.uuid4()))
+        self.board = np.zeros((3, 3))
+        self.human_player = 1
+        self.ai_player = -1
         
-        with gr.Column(elem_id="game-container"):
-            status = gr.Markdown("Your turn!", elem_id="message")
-            
-            with gr.Column(elem_classes=["board"]):
-                cells = []
-                for i in range(9):
-                    cells.append(gr.Button(" ", elem_classes=["cell"]))
-            
-            reset = gr.Button("New Game", elem_id="reset-btn")
-
-        def handle_click(idx, session):
-            game = get_game(session)
-            if game.make_move(idx):
-                return {
-                    status: game.get_status(),
-                    **{cell: game.board[i] for i, cell in enumerate(cells)}
-                }
-            return {status: "Invalid move!"}
+    def reset_board(self):
+        self.board = np.zeros((3, 3))
+        return self.format_board()
+    
+    def check_winner(self) -> Optional[int]:
+        # Check rows, columns and diagonals
+        for player in [self.human_player, self.ai_player]:
+            # Rows and columns
+            for i in range(3):
+                if all(self.board[i, :] == player) or all(self.board[:, i] == player):
+                    return player
+            # Diagonals
+            if all(np.diag(self.board) == player) or all(np.diag(np.fliplr(self.board)) == player):
+                return player
+        
+        # Check for draw
+        if np.all(self.board != 0):
+            return 0
+        
+        return None
+    
+    def get_valid_moves(self) -> List[Tuple[int, int]]:
+        return [(i, j) for i in range(3) for j in range(3) if self.board[i, j] == 0]
+    
+    def minimax(self, depth: int, is_maximizing: bool, alpha: float = float('-inf'), beta: float = float('inf')) -> Tuple[int, Optional[Tuple[int, int]]]:
+        winner = self.check_winner()
+        if winner is not None:
+            return winner * 100, None
+        
+        if is_maximizing:
+            best_score = float('-inf')
+            best_move = None
+            for move in self.get_valid_moves():
+                self.board[move] = self.ai_player
+                score, _ = self.minimax(depth + 1, False, alpha, beta)
+                self.board[move] = 0
+                
+                if score > best_score:
+                    best_score = score
+                    best_move = move
+                
+                alpha = max(alpha, best_score)
+                if beta <= alpha:
+                    break
+                    
+            return best_score, best_move
+        else:
+            best_score = float('inf')
+            best_move = None
+            for move in self.get_valid_moves():
+                self.board[move] = self.human_player
+                score, _ = self.minimax(depth + 1, True, alpha, beta)
+                self.board[move] = 0
+                
+                if score < best_score:
+                    best_score = score
+                    best_move = move
+                    
+                beta = min(beta, best_score)
+                if beta <= alpha:
+                    break
+                    
+            return best_score, best_move
+    
+    def ai_move(self) -> str:
+        if len(self.get_valid_moves()) == 0:
+            return self.format_board()
+        
+        _, best_move = self.minimax(0, True)
+        if best_move is not None:
+            self.board[best_move] = self.ai_player
+        
+        return self.format_board()
+    
+    def format_board(self) -> str:
+        symbols = {0: " ", 1: "X", -1: "O"}
+        return "\n".join([
+            "-------------",
+            f"| {symbols[self.board[0,0]]} | {symbols[self.board[0,1]]} | {symbols[self.board[0,2]]} |",
+            "-------------",
+            f"| {symbols[self.board[1,0]]} | {symbols[self.board[1,1]]} | {symbols[self.board[1,2]]} |",
+            "-------------",
+            f"| {symbols[self.board[2,0]]} | {symbols[self.board[2,1]]} | {symbols[self.board[2,2]]} |",
+            "-------------"
+        ])
+    
+    def make_move(self, row: int, col: int) -> Tuple[str, str]:
+        # Check if move is valid
+        if self.board[row, col] != 0:
+            return self.format_board(), "Invalid move! Cell already taken."
+        
+        # Make human move
+        self.board[row, col] = self.human_player
+        
+        # Check if game is over after human move
+        winner = self.check_winner()
+        if winner is not None:
+            if winner == self.human_player:
+                return self.format_board(), "You win!"
+            elif winner == 0:
+                return self.format_board(), "It's a draw!"
+        
+        # Make AI move
+        self.ai_move()
+        
+        # Check if game is over after AI move
+        winner = self.check_winner()
+        if winner is not None:
+            if winner == self.ai_player:
+                return self.format_board(), "AI wins!"
+            elif winner == 0:
+                return self.format_board(), "It's a draw!"
+        
+        return self.format_board(), "Game in progress"
 
-        def reset_game(session):
-            game = get_game(session)
-            game.reset()
-            return {
-                status: "Your turn!",
-                **{cell: " " for cell in cells}
-            }
+# Create game instance
+game = TicTacToe()
 
-        for i, cell in enumerate(cells):
-            cell.click(
-                handle_click,
-                inputs=[gr.State(i), session_id],
-                outputs=[status, *cells]
-            )
+def play_game(row: int, col: int, board_state: str, game_status: str) -> Tuple[str, str]:
+    if "win" in game_status or "draw" in game_status:
+        return board_state, game_status
+    return game.make_move(row, col)
 
-        reset.click(
-            reset_game,
-            inputs=[session_id],
-            outputs=[status, *cells]
-        )
+def reset_game() -> Tuple[str, str]:
+    return game.reset_board(), "Game reset! Your turn (X)"
 
-    return demo
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Tic Tac Toe vs AI")
+    gr.Markdown("You play as X, AI plays as O. Click the buttons to make your move!")
+    
+    with gr.Row():
+        # Game board display
+        board_display = gr.Textbox(value=game.format_board(), label="Game Board", lines=7)
+        game_status = gr.Textbox(value="Your turn (X)", label="Game Status")
+    
+    # Create 3x3 grid of buttons
+    with gr.Row():
+        for i in range(3):
+            with gr.Column():
+                for j in range(3):
+                    btn = gr.Button(f"Row {i}, Col {j}")
+                    btn.click(
+                        fn=play_game,
+                        inputs=[
+                            gr.Number(value=i, visible=False),
+                            gr.Number(value=j, visible=False),
+                            board_display,
+                            game_status
+                        ],
+                        outputs=[board_display, game_status]
+                    )
+    
+    # Reset button
+    reset_btn = gr.Button("Reset Game")
+    reset_btn.click(fn=reset_game, inputs=[], outputs=[board_display, game_status])
 
-demo = create_interface()
-demo.queue()  # Enable queuing for multiple users
+# Launch app
 demo.launch()