Update app.py

app.py

@@ -1,200 +1,191 @@
 import gradio as gr
-import numpy as np
-
-# Game constants
-X = "X"
-O = "O"
-EMPTY = None
+import random
 
 class TicTacToe:
     def __init__(self):
-        self.board = [[EMPTY for _ in range(3)] for _ in range(3)]
-        self.current_player = X
-        self.game_over = False
-        
+        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 = [[EMPTY for _ in range(3)] for _ in range(3)]
-        self.current_player = X
-        self.game_over = False
-        
-    def make_move(self, row, col):
-        if self.board[row][col] is not None or self.game_over:
-            return False
-            
-        self.board[row][col] = self.current_player
-        if self.check_winner():
-            self.game_over = True
+        self.board = [" " for _ in range(9)]
+        self.current_player = self.human
+        return self.board
+
+    def make_move(self, position):
+        if self.board[position] == " " and not self.is_game_over():
+            self.board[position] = self.current_player
+            if self.current_player == self.human:
+                self.current_player = self.ai
+                # AI makes its move after human
+                if not self.is_game_over():
+                    ai_move = self.get_best_move()
+                    self.board[ai_move] = self.ai
+                    self.current_player = self.human
             return True
-            
-        if self.is_board_full():
-            self.game_over = True
-            return True
-            
-        self.current_player = O if self.current_player == X else X
-        return True
-        
-    def check_winner(self):
-        # Check rows
-        for row in self.board:
-            if row.count(row[0]) == 3 and row[0] is not None:
-                return True
-                
-        # Check columns
-        for col in range(3):
-            if (self.board[0][col] == self.board[1][col] == self.board[2][col] 
-                and self.board[0][col] is not None):
+        return False
+
+    def is_winner(self, player):
+        for combo in self.winning_combinations:
+            if all(self.board[i] == player for i in combo):
                 return True
-                
-        # Check diagonals
-        if (self.board[0][0] == self.board[1][1] == self.board[2][2] 
-            and self.board[0][0] is not None):
-            return True
-        if (self.board[0][2] == self.board[1][1] == self.board[2][0] 
-            and self.board[0][2] is not None):
-            return True
-            
         return False
-        
-    def is_board_full(self):
-        return all(all(cell is not None for cell in row) for row in self.board)
 
-# Initialize game
+    def is_game_over(self):
+        return self.is_winner(self.human) or self.is_winner(self.ai) or " " not in self.board
+
+    def get_status(self):
+        if self.is_winner(self.human):
+            return "You win! 🎉"
+        elif self.is_winner(self.ai):
+            return "AI wins! 🤖"
+        elif " " not in self.board:
+            return "It's a tie! 🤝"
+        return "Your turn!"
+
+    def minimax(self, depth, is_maximizing):
+        if self.is_winner(self.ai):
+            return 1
+        if self.is_winner(self.human):
+            return -1
+        if " " not in self.board:
+            return 0
+
+        if is_maximizing:
+            best_score = float('-inf')
+            for i in range(9):
+                if self.board[i] == " ":
+                    self.board[i] = self.ai
+                    score = self.minimax(depth + 1, False)
+                    self.board[i] = " "
+                    best_score = max(score, best_score)
+            return best_score
+        else:
+            best_score = float('inf')
+            for i in range(9):
+                if self.board[i] == " ":
+                    self.board[i] = self.human
+                    score = self.minimax(depth + 1, True)
+                    self.board[i] = " "
+                    best_score = min(score, best_score)
+            return best_score
+
+    def get_best_move(self):
+        best_score = float('-inf')
+        best_move = None
+        for i in range(9):
+            if self.board[i] == " ":
+                self.board[i] = self.ai
+                score = self.minimax(0, False)
+                self.board[i] = " "
+                if score > best_score:
+                    best_score = score
+                    best_move = i
+        return best_move
+
 game = TicTacToe()
 
-# Custom CSS
-custom_css = """
+css = """
 #game-container {
     max-width: 300px;
     margin: 0 auto;
-    padding: 20px;
-    background: #f5f5f5;
-    border-radius: 10px;
+    padding: 15px;
 }
 
-.board-row {
-    display: flex !important;
-    justify-content: center !important;
-    gap: 3px !important;
-    margin: 3px 0 !important;
+.board {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 4px;
+    background: #ff0000;
+    padding: 4px;
+    width: 240px;
+    margin: 0 auto;
 }
 
 .cell {
-    width: 60px !important;
-    height: 60px !important;
+    width: 100% !important;
+    height: 75px !important;
     font-size: 24px !important;
     font-weight: bold !important;
     background: white !important;
-    border: none !important;
     color: #0066cc !important;
+    border: none !important;
     display: flex !important;
     align-items: center !important;
     justify-content: center !important;
     cursor: pointer !important;
-    padding: 0 !important;
-    margin: 0 !important;
 }
 
-.board-container {
-    background: #ff0000;
-    padding: 3px;
-    width: fit-content;
-    margin: 20px auto;
-    border-radius: 4px;
+.cell:hover {
+    background: #f0f0f0 !important;
 }
 
-#status-message {
+#message {
     text-align: center;
     margin: 15px 0;
     font-size: 18px;
     color: #333;
 }
 
-#reset-button {
-    display: block !important;
-    margin: 20px auto !important;
-    padding: 10px 20px !important;
+#reset-btn {
     background: #e74c3c !important;
     color: white !important;
     border: none !important;
+    padding: 10px 20px !important;
     border-radius: 5px !important;
     cursor: pointer !important;
-    font-size: 16px !important;
-}
-
-#reset-button:hover {
-    background: #c0392b !important;
+    margin: 10px auto !important;
+    display: block !important;
+    width: 120px !important;
 }
 """
 
-def create_board():
-    with gr.Blocks(css=custom_css) as demo:
+def create_interface():
+    with gr.Blocks(css=css) as demo:
         with gr.Column(elem_id="game-container"):
-            status = gr.Markdown("Player X's turn", elem_id="status-message")
-            
-            # Create board container with red background
-            with gr.Column(elem_classes=["board-container"]):
-                # Create 3x3 grid
-                buttons = [[None for _ in range(3)] for _ in range(3)]
-                for i in range(3):
-                    with gr.Row(elem_classes=["board-row"]):
-                        for j in range(3):
-                            buttons[i][j] = gr.Button(
-                                " ",
-                                elem_classes=["cell"],
-                                elem_id=f"cell-{i}-{j}"
-                            )
+            status = gr.Markdown("Your turn!", elem_id="message")
             
-            reset_btn = gr.Button("New Game", elem_id="reset-button")
-
-        def handle_click(i, j):
-            if game.make_move(i, j):
-                symbol = game.board[i][j]
-                message = ""
-                
-                if game.game_over:
-                    if game.check_winner():
-                        message = f"Player {symbol} wins! 🎉"
-                    else:
-                        message = "It's a tie! 🤝"
-                else:
-                    next_player = "O" if symbol == "X" else "X"
-                    message = f"Player {next_player}'s turn"
-                
-                # Update all buttons
-                button_updates = {}
-                for r in range(3):
-                    for c in range(3):
-                        value = game.board[r][c] if game.board[r][c] is not None else " "
-                        button_updates[buttons[r][c]] = value
-                
-                return {status: message, **button_updates}
+            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):
+            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_game():
             game.reset()
-            updates = {status: "Player X's turn"}
-            for i in range(3):
-                for j in range(3):
-                    updates[buttons[i][j]] = " "
-            return updates
-
-        # Connect event handlers
-        for i in range(3):
-            for j in range(3):
-                buttons[i][j].click(
-                    lambda x, y: handle_click(x, y),
-                    inputs=[gr.State(i), gr.State(j)],
-                    outputs=[status, *sum(buttons, [])]
-                )
-        
-        reset_btn.click(
+            return {
+                status: "Your turn!",
+                **{cell: " " for cell in cells}
+            }
+
+        for i, cell in enumerate(cells):
+            cell.click(
+                handle_click,
+                inputs=[gr.State(i)],
+                outputs=[status, *cells]
+            )
+
+        reset.click(
             reset_game,
-            outputs=[status, *sum(buttons, [])]
+            outputs=[status, *cells]
         )
 
     return demo
 
-# Launch the app
-demo = create_board()
+demo = create_interface()
 demo.launch()