Update app.py

app.py

@@ -1,169 +1,135 @@
 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 = 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
+        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")}
         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"
-
-# Create game instance
+            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
 game = TicTacToe()
 
-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()
+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()