Update app.py

app.py

@@ -1,135 +1,169 @@
 import gradio as gr
+import numpy as np
+from typing import List, Tuple, Optional
 
-# Tic Tac Toe logic with Minimax AI
 class TicTacToe:
     def __init__(self):
-        self.board = [" "] * 9
-        self.current_winner = None
-
-    def print_board(self):
-        for row in [self.board[i * 3:(i + 1) * 3] for i in range(3)]:
-            print("| " + " | ".join(row) + " |")
-
-    def available_moves(self):
-        return [i for i, spot in enumerate(self.board) if spot == " "]
-
-    def empty_squares(self):
-        return " " in self.board
-
-    def num_empty_squares(self):
-        return len(self.available_moves())
-
-    def make_move(self, square, letter):
-        if self.board[square] == " ":
-            self.board[square] = letter
-            if self.winner(square, letter):
-                self.current_winner = letter
-            return True
-        return False
-
-    def winner(self, square, letter):
-        # Check row
-        row_ind = square // 3
-        row = self.board[row_ind * 3:(row_ind + 1) * 3]
-        if all([spot == letter for spot in row]):
-            return True
-        # Check column
-        col_ind = square % 3
-        column = [self.board[col_ind + i * 3] for i in range(3)]
-        if all([spot == letter for spot in column]):
-            return True
-        # Check diagonals
-        if square % 2 == 0:
-            diagonal1 = [self.board[i] for i in [0, 4, 8]]
-            if all([spot == letter for spot in diagonal1]):
-                return True
-            diagonal2 = [self.board[i] for i in [2, 4, 6]]
-            if all([spot == letter for spot in diagonal2]):
-                return True
-        return False
-
-    def minimax(self, state, player):
-        max_player = "O"
-        other_player = "X" if player == "O" else "O"
-
-        if self.current_winner == other_player:
-            return {"position": None, "score": 1 * (state.count(" ") + 1) if other_player == max_player else -1 * (
-                    state.count(" ") + 1)}
-        elif not self.empty_squares():
-            return {"position": None, "score": 0}
-
-        if player == max_player:
-            best = {"position": None, "score": -float("inf")}
+        self.board = np.zeros((3, 3))
+        self.human_player = 1
+        self.ai_player = -1
+        
+    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 = {"position": None, "score": float("inf")}
-
-        for possible_move in self.available_moves():
-            self.board[possible_move] = player
-            sim_score = self.minimax(self.board, other_player)
-
-            self.board[possible_move] = " "
-            sim_score["position"] = possible_move
-
-            if player == max_player:
-                if sim_score["score"] > best["score"]:
-                    best = sim_score
-            else:
-                if sim_score["score"] < best["score"]:
-                    best = sim_score
-
-        return best
-
-    def ai_move(self):
-        if len(self.available_moves()) == 9:
-            square = 4
-        else:
-            square = self.minimax(self.board, "O")["position"]
-        self.make_move(square, "O")
-        return square
-
-
-# Gradio Interface
+            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"
+
+# Create game instance
 game = TicTacToe()
 
-def play_tic_tac_toe(human_move):
-    if not game.empty_squares() or game.current_winner is not None:
-        return {"output": "Game Over! Reset to play again.", "board": game.board}
-
-    if game.board[human_move] != " ":
-        return {"output": "Invalid move. Try again.", "board": game.board}
-
-    game.make_move(human_move, "X")
-    if game.current_winner:
-        return {"output": "You win!", "board": game.board}
-
-    if game.empty_squares():
-        ai_move = game.ai_move()
-        if game.current_winner:
-            return {"output": "AI wins!", "board": game.board}
-
-    return {"output": "Your move.", "board": game.board}
-
-def reset_game():
-    global game
-    game = TicTacToe()
-    return {"output": "Game reset! Your move.", "board": game.board}
-
-# Gradio app
-def render_game(human_move=None):
-    if human_move is None:
-        return reset_game()
-    return play_tic_tac_toe(int(human_move))
-
-interface = gr.Interface(
-    fn=render_game,
-    inputs=gr.Dropdown(choices=[str(i) for i in range(9)], label="Your Move (0-8)"),
-    outputs=[
-        gr.Textbox(label="Game Status"),
-        gr.Textbox(label="Current Board State")
-    ],
-    live=True,
-    title="Tic Tac Toe with AI",
-    description="Play Tic Tac Toe against an AI powered by the Minimax algorithm!"
-)
-
-interface.launch()
+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)
+
+def reset_game() -> Tuple[str, str]:
+    return game.reset_board(), "Game reset! Your turn (X)"
+
+# 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])
+
+# Launch app
+demo.launch()