Update app.py

app.py

@@ -1,227 +1,149 @@
 import gradio as gr
 import numpy as np
-import json
+import random
 
 class Minesweeper:
-    def __init__(self, width=8, height=8, num_mines=10):
-        self.width = width
-        self.height = height
+    def __init__(self, size=8, num_mines=10):
+        self.size = size
         self.num_mines = num_mines
+        self.board = np.zeros((size, size), dtype=int)
+        self.revealed = np.zeros((size, size), dtype=bool)
+        self.flags = np.zeros((size, size), dtype=bool)
         self.game_over = False
-        self.won = False
         self.first_move = True
-        self.initialize_board()
-    
-    def initialize_board(self):
-        self.board = np.zeros((self.height, self.width), dtype=int)
-        self.visible_board = np.full((self.height, self.width), -2, dtype=int)
-    
+        
     def place_mines(self, first_x, first_y):
-        positions = [(x, y) for x in range(self.height) for y in range(self.width)]
+        positions = [(i, j) for i in range(self.size) for j in range(self.size)]
         positions.remove((first_x, first_y))
         mine_positions = random.sample(positions, self.num_mines)
         
         for x, y in mine_positions:
             self.board[x, y] = -1
-        
-        for x in range(self.height):
-            for y in range(self.width):
+            
+        for x in range(self.size):
+            for y in range(self.size):
                 if self.board[x, y] != -1:
                     self.board[x, y] = self.count_adjacent_mines(x, y)
     
     def count_adjacent_mines(self, x, y):
         count = 0
-        for dx in [-1, 0, 1]:
-            for dy in [-1, 0, 1]:
-                if dx == 0 and dy == 0:
-                    continue
-                new_x, new_y = x + dx, y + dy
-                if (0 <= new_x < self.height and 
-                    0 <= new_y < self.width and 
-                    self.board[new_x, new_y] == -1):
+        for i in range(max(0, x-1), min(self.size, x+2)):
+            for j in range(max(0, y-1), min(self.size, y+2)):
+                if self.board[i, j] == -1:
                     count += 1
         return count
     
     def reveal(self, x, y):
-        if self.game_over or self.won:
-            return
-        
         if self.first_move:
             self.place_mines(x, y)
             self.first_move = False
-        
+            
         if self.board[x, y] == -1:
             self.game_over = True
-            return
-        
-        self.flood_fill(x, y)
-        
-        if np.count_nonzero(self.visible_board == -2) == self.num_mines:
-            self.won = True
-    
-    def flood_fill(self, x, y):
-        if (not (0 <= x < self.height and 0 <= y < self.width) or 
-            self.visible_board[x, y] != -2):
-            return
-        
-        self.visible_board[x, y] = self.board[x, y]
+            return "💥 Game Over!"
+            
+        self.revealed[x, y] = True
         
         if self.board[x, y] == 0:
-            for dx in [-1, 0, 1]:
-                for dy in [-1, 0, 1]:
-                    self.flood_fill(x + dx, y + dy)
-    
-    def toggle_flag(self, x, y):
-        if self.game_over or self.won:
-            return
+            for i in range(max(0, x-1), min(self.size, x+2)):
+                for j in range(max(0, y-1), min(self.size, y+2)):
+                    if not self.revealed[i, j]:
+                        self.reveal(i, j)
         
-        if self.visible_board[x, y] == -2:
-            self.visible_board[x, y] = -1
-        elif self.visible_board[x, y] == -1:
-            self.visible_board[x, y] = -2
+        if self.check_win():
+            return "🎉 Você venceu!"
+        return None
+    
+    def check_win(self):
+        return np.all(self.revealed | (self.board == -1))
+    
+    def get_display(self):
+        display = []
+        for i in range(self.size):
+            row = []
+            for j in range(self.size):
+                if not self.revealed[i, j]:
+                    if self.flags[i, j]:
+                        row.append("🚩")
+                    else:
+                        row.append("⬜")
+                else:
+                    if self.board[i, j] == -1:
+                        row.append("💣")
+                    elif self.board[i, j] == 0:
+                        row.append("⬛")
+                    else:
+                        row.append(str(self.board[i, j]))
+            display.append(row)
+        return display
 
-def create_game_html(game):
-    # Cores para diferentes estados das células
-    cell_styles = {
-        -2: "background-color: #ccc;",  # Coberto
-        -1: "background-color: #f00;",  # Bandeira
-        0: "background-color: #fff;",   # Vazio
-        1: "background-color: #fff; color: blue;",
-        2: "background-color: #fff; color: green;",
-        3: "background-color: #fff; color: red;",
-        4: "background-color: #fff; color: darkblue;",
-        5: "background-color: #fff; color: darkred;",
-        6: "background-color: #fff; color: teal;",
-        7: "background-color: #fff; color: black;",
-        8: "background-color: #fff; color: gray;"
-    }
-    
-    html = """
-    <style>
-        .minesweeper-board {
-            display: inline-block;
-            border: 2px solid #999;
-            background-color: #eee;
-            padding: 10px;
-        }
-        .board-row {
-            display: flex;
-        }
-        .cell {
-            width: 40px;
-            height: 40px;
-            border: 1px solid #999;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-weight: bold;
-            font-size: 20px;
-            cursor: pointer;
-            user-select: none;
-        }
-        .game-over .cell {
-            cursor: not-allowed;
-        }
-    </style>
-    
-    <div class="minesweeper-board">
-    """
+def create_game():
+    return Minesweeper()
+
+def make_move(x, y, is_flag, game):
+    if game is None:
+        game = create_game()
     
-    # Adicionar status do jogo
     if game.game_over:
-        html += '<div style="text-align: center; margin-bottom: 10px; color: red; font-weight: bold;">Game Over!</div>'
-    elif game.won:
-        html += '<div style="text-align: center; margin-bottom: 10px; color: green; font-weight: bold;">Você Venceu!</div>'
+        return "Game Over! Clique em 'Novo Jogo'", game
     
-    # Criar tabuleiro
-    for i in range(game.height):
-        html += '<div class="board-row">'
-        for j in range(game.width):
-            cell_value = game.visible_board[i, j]
-            style = cell_styles[cell_value]
-            
-            # Se o jogo acabou, mostrar as minas
-            if game.game_over and game.board[i, j] == -1:
-                cell_content = "💣"
-                style = "background-color: #f00;"
-            # Se é uma bandeira
-            elif cell_value == -1:
-                cell_content = "🚩"
-            # Se está coberto
-            elif cell_value == -2:
-                cell_content = ""
-            # Se é um número
-            else:
-                cell_content = str(cell_value) if cell_value > 0 else ""
-            
-            html += f'<div class="cell" style="{style}" data-x="{i}" data-y="{j}">{cell_content}</div>'
-        html += '</div>'
-    html += '</div>'
-    
-    # Adicionar JavaScript para handling de cliques
-    html += """
-    <script>
-        function handleCellClick(event) {
-            const cell = event.target;
-            if (!cell.classList.contains('cell')) return;
-            
-            const x = cell.getAttribute('data-x');
-            const y = cell.getAttribute('data-y');
-            
-            if (event.button === 2 || event.ctrlKey) {  // Clique direito ou Ctrl+Clique
-                handleAction(x, y, 'flag');
-            } else {  // Clique esquerdo
-                handleAction(x, y, 'reveal');
-            }
-        }
-        
-        document.querySelector('.minesweeper-board').addEventListener('click', handleCellClick);
-        document.querySelector('.minesweeper-board').addEventListener('contextmenu', (e) => {
-            e.preventDefault();
-            handleCellClick(e);
-        });
-    </script>
-    """
-    
-    return html
-
-def handle_action(x, y, action, game_state):
-    if not game_state:
-        game = Minesweeper()
-    else:
-        game = Minesweeper()
-        game.__dict__ = game_state
-    
-    if action == "reveal":
-        game.reveal(int(x), int(y))
+    if is_flag:
+        game.flags[x, y] = not game.flags[x, y]
+        message = None
     else:
-        game.toggle_flag(int(x), int(y))
-    
-    return create_game_html(game), game.__dict__
-
-def new_game():
-    game = Minesweeper()
-    return create_game_html(game), game.__dict__
-
-with gr.Blocks(title="Campo Minado") as demo:
-    gr.Markdown("""
-    # Campo Minado
+        if game.flags[x, y]:
+            return "Remova a bandeira primeiro!", game
+        message = game.reveal(x, y)
     
-    Instruções:
-    - Clique esquerdo para revelar uma célula
-    - Clique direito (ou Ctrl+Clique) para colocar/remover bandeira
-    - Evite as minas!
-    """)
+    if game.game_over:
+        game.revealed = np.ones((game.size, game.size), dtype=bool)
     
-    game_state = gr.State()
-    board = gr.HTML()
+    grid = game.get_display()
+    buttons = []
     
-    with gr.Row():
-        new_game_btn = gr.Button("Novo Jogo")
+    for i in range(game.size):
+        for j in range(game.size):
+            buttons.append(gr.Button(value=grid[i][j], scale=1))
     
-    board.change(handle_action, [board], [board, game_state])  # Para atualização após cliques
-    new_game_btn.click(new_game, outputs=[board, game_state])
+    return message if message else "Jogo em andamento", game
+
+def create_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("""
+        # 💣 Campo Minado
+        
+        - Clique nos quadrados para revelar
+        - Use 'Bandeira' para marcar possíveis minas
+        - Evite todas as minas!
+        """)
+        
+        game_state = gr.State()
+        status = gr.Textbox(label="Status", value="Clique para começar!")
+        
+        with gr.Column():
+            use_flag = gr.Checkbox(label="Bandeira")
+            new_game = gr.Button("Novo Jogo")
+        
+        with gr.Row():
+            for i in range(8):
+                with gr.Column(scale=1):
+                    for j in range(8):
+                        btn = gr.Button("⬜", scale=1)
+                        btn.click(
+                            make_move, 
+                            inputs=[gr.Number(value=i, visible=False), 
+                                   gr.Number(value=j, visible=False),
+                                   use_flag,
+                                   game_state],
+                            outputs=[status, game_state]
+                        )
+        
+        new_game.click(
+            lambda: (None, create_game()),
+            outputs=[status, game_state]
+        )
     
-    demo.load(new_game, outputs=[board, game_state])
+    return demo
 
+demo = create_interface()
 demo.launch()