app.py

import gradio as gr
import numpy as np
import random

class Minesweeper:
    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.first_move = True
        
    def place_mines(self, first_x, first_y):
        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.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 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.first_move:
            self.place_mines(x, y)
            self.first_move = False
            
        if self.board[x, y] == -1:
            self.game_over = True
            return "💥 Game Over!"
            
        self.revealed[x, y] = True
        
        if self.board[x, y] == 0:
            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.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():
    return Minesweeper()

def make_move(x, y, is_flag, game):
    if game is None:
        game = create_game()
    
    if game.game_over:
        return "Game Over! Clique em 'Novo Jogo'", game
    
    if is_flag:
        game.flags[x, y] = not game.flags[x, y]
        message = None
    else:
        if game.flags[x, y]:
            return "Remova a bandeira primeiro!", game
        message = game.reveal(x, y)
    
    if game.game_over:
        game.revealed = np.ones((game.size, game.size), dtype=bool)
    
    grid = game.get_display()
    buttons = []
    
    for i in range(game.size):
        for j in range(game.size):
            buttons.append(gr.Button(value=grid[i][j], scale=1))
    
    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]
        )
    
    return demo

demo = create_interface()
demo.launch()