Update app.py

app.py

@@ -1,137 +1,103 @@
 #!/usr/bin/env python3
+# coding: utf-8
 """
-Jeu d'échecs console 2 joueurs + mécanique démineur sur cases vides initiales.
+Jeu d'échecs + démineur — interface web Gradio (2 joueurs, tour par tour).
 - Pièces: p (pion), f (fou), t (tour), c (cavalier), R (reine), k (roi)
-- MAJ = Blanc, minuscule = Noir
-- Mines générées aléatoirement à l'initialisation sur les cases vides.
-- Quand une pièce marche sur une mine -> la pièce est éliminée.
-- Quand une pièce marche sur une case sûre -> la case est révélée et affiche le nombre
-  de mines adjacentes (cascade si 0).
-- Règles de base : mouvements, captures, échec, échec-et-mat, promotion.
-- Castling et en passant non gérés pour simplifier.
+  MAJ = Blanc, minuscule = Noir
+- Mines placées aléatoirement sur cases vides au début.
+- Déplacement sur une mine -> pièce éliminée (mine explose).
+- Cases sûres révélées comme en démineur (compte des mines adjacentes, cascade si 0).
+- Règles de base : mouvements, captures, échec, échec-et-mat, promotion automatique.
+- Castling & en passant non implémentés.
 """
 
 import random
 import copy
-
-# === Utilitaires de gestion du plateau ===
+import gradio as gr
 
 FILES = "abcdefgh"
 RANKS = "12345678"
 
 def sq_to_coords(sq):
-    """ex: 'e4' -> (4, 4) where (file, rank) indices 0..7"""
-    file = FILES.index(sq[0])
-    rank = RANKS.index(sq[1])
-    return (file, rank)
+    sq = sq.lower()
+    return FILES.index(sq[0]), RANKS.index(sq[1])
 
-def coords_to_sq(x, y):
+def coords_to_sq(x,y):
     return FILES[x] + RANKS[y]
 
-def in_bounds(x, y):
+def in_bounds(x,y):
     return 0 <= x < 8 and 0 <= y < 8
 
-# === Initial board setup (standard chess) ===
+# ---------- initial board ----------
 def initial_board():
-    # Empty board: None
+    # board[x][y] with x file 0..7 (a..h), y rank 0..7 (1..8)
     board = [[None for _ in range(8)] for _ in range(8)]
-    # Place pieces: white at rank 1-2 (y=0..1), black at rank 7-8 (y=6..7) but we'll use rank indices 0..7 with 0='1'
-    # We'll map ranks: y=0 -> '1', y=7 -> '8' (consistent with coords_to_sq)
-    # White pieces (bottom, ranks 1 & 2 -> y=0 and y=1)
-    white_row = ['t','c','f','R','k','f','c','t']  # tour, cavalier, fou, reine, roi, ...
+    # White (bottom) y=0 (rank1) and y=1 (rank2)
+    white_row = ['t','c','f','R','k','f','c','t']  # types; will display uppercase for white
     for x,p in enumerate(white_row):
-        board[x][0] = ('W', p)  # white pieces uppercase display
+        board[x][0] = ('W', p)
     for x in range(8):
-        board[x][1] = ('W', 'p')  # pawns
-
-    # Black pieces (top, ranks 8 & 7 -> y=7 and y=6)
+        board[x][1] = ('W', 'p')
+    # Black (top) y=7 (rank8) and y=6 (rank7)
     black_row = ['t','c','f','R','k','f','c','t']
     for x,p in enumerate(black_row):
-        board[x][7] = ('B', p)  # color 'B' but will display as lowercase
+        board[x][7] = ('B', p)
     for x in range(8):
         board[x][6] = ('B', 'p')
-
     return board
 
-# === Mines field and reveal map ===
+# ---------- mines and demineur mechanics ----------
 def generate_mines(board, density=0.15):
-    """
-    board: current board 2D list with None or (color, piece)
-    density: fraction of empty squares to turn into mines (0..1)
-    Returns:
-      mines: set of (x,y) coordinates with mines
-      revealed: set of (x,y) coordinates already revealed (initially empty)
-      adj_counts: dict (x,y) -> adjacent mine count
-    Mines only placed on squares that are empty at initialisation (no piece).
-    """
-    empty_sqs = [(x,y) for x in range(8) for y in range(8) if board[x][y] is None]
-    count = max(1, int(len(empty_sqs) * density))
-    mines = set(random.sample(empty_sqs, count))
-    adj_counts = {}
+    empty = [(x,y) for x in range(8) for y in range(8) if board[x][y] is None]
+    n = max(1, int(len(empty) * density))
+    mines = set(random.sample(empty, n))
+    adj = {}
     for x in range(8):
         for y in range(8):
             if (x,y) in mines:
-                adj_counts[(x,y)] = -1
+                adj[(x,y)] = -1
             else:
                 cnt = 0
                 for dx in (-1,0,1):
                     for dy in (-1,0,1):
-                        nx, ny = x+dx, y+dy
-                        if (dx==0 and dy==0) or not in_bounds(nx,ny):
-                            continue
-                        if (nx,ny) in mines:
+                        if dx==0 and dy==0: continue
+                        nx,ny = x+dx, y+dy
+                        if in_bounds(nx,ny) and (nx,ny) in mines:
                             cnt += 1
-                adj_counts[(x,y)] = cnt
+                adj[(x,y)] = cnt
     revealed = set()
-    exploded = set()  # squares where a mine exploded
-    return mines, revealed, adj_counts, exploded
+    exploded = set()
+    return mines, revealed, adj, exploded
 
-def reveal_cascade(revealed, adj_counts, start):
-    """Reveal start and cascade zeros recursively (like démineur)."""
+def reveal_cascade(revealed, adj, start):
     stack = [start]
     while stack:
         s = stack.pop()
         if s in revealed:
             continue
         revealed.add(s)
-        if adj_counts.get(s, 0) == 0:
+        if adj.get(s,0) == 0:
             x,y = s
             for dx in (-1,0,1):
                 for dy in (-1,0,1):
-                    nx, ny = x+dx, y+dy
-                    if (dx==0 and dy==0) or not in_bounds(nx,ny):
-                        continue
-                    if (nx,ny) not in revealed:
+                    nx,ny = x+dx, y+dy
+                    if dx==0 and dy==0: continue
+                    if in_bounds(nx,ny) and (nx,ny) not in revealed:
                         stack.append((nx,ny))
 
-# === Display functions ===
+# ---------- display ----------
 def piece_to_char(piece):
-    # piece is (color, type) or None
     if piece is None:
         return '.'
-    color, ptype = piece
-    # ptype is one of p,f,t,c,R,k
-    # Display: White = uppercase letter, Black = lowercase
-    char = ptype
-    if color == 'W':
-        return char.upper()
-    else:
-        return char.lower()
-
-def render_board(board, mines, revealed, adj_counts, exploded):
-    """
-    Returns a printable multiline string representing the board.
-    - Shows coordinates.
-    - For squares:
-      - If occupied by piece -> display piece char
-      - Else if revealed -> display adj count digit (0..8 -> '0' shown as ' ')
-      - Else -> '.' (hidden)
-      - If exploded mine -> 'X'
-    """
-    rows = []
-    rows.append("    a b c d e f g h")
-    rows.append("   -----------------")
-    for y in range(7, -1, -1):
+    col,ptype = piece
+    ch = ptype
+    return ch.upper() if col=='W' else ch.lower()
+
+def render_board(board, mines, revealed, adj, exploded):
+    lines = []
+    lines.append("    a b c d e f g h")
+    lines.append("   -----------------")
+    for y in range(7,-1,-1):
         row = f" {y+1} |"
         for x in range(8):
             if (x,y) in exploded:
@@ -139,102 +105,53 @@ def render_board(board, mines, revealed, adj_counts, exploded):
             elif board[x][y] is not None:
                 cell = piece_to_char(board[x][y])
             elif (x,y) in revealed:
-                cnt = adj_counts.get((x,y), 0)
+                cnt = adj.get((x,y), 0)
                 cell = str(cnt) if cnt>0 else ' '
             else:
                 cell = '.'
             row += ' ' + cell
         row += f" | {y+1}"
-        rows.append(row)
-    rows.append("   -----------------")
-    rows.append("    a b c d e f g h")
-    return "\n".join(rows)
-
-# === Chess move generation & legality check (basic but robust) ===
+        lines.append(row)
+    lines.append("   -----------------")
+    lines.append("    a b c d e f g h")
+    return "\n".join(lines)
 
+# ---------- moves generation ----------
 DIRECTIONS_ROOK = [(1,0),(-1,0),(0,1),(0,-1)]
 DIRECTIONS_BISHOP = [(1,1),(1,-1),(-1,1),(-1,-1)]
 KNIGHT_MOVES = [(2,1),(2,-1),(-2,1),(-2,-1),(1,2),(1,-2),(-1,2),(-1,-2)]
 
-def is_opponent(piece, color):
-    return piece is not None and piece[0] != color
-
-def is_same_color(piece, color):
-    return piece is not None and piece[0] == color
-
-def locate_king(board, color):
-    for x in range(8):
-        for y in range(8):
-            p = board[x][y]
-            if p is not None and p[0]==color and p[1]=='k':
-                return (x,y)
-    return None
-
-def square_attacked(board, x, y, by_color, mines=None):
-    """
-    Returns True if square (x,y) is attacked by any piece of by_color.
-    Mines do not affect attacks (they only trigger on moving onto them).
-    """
-    # Pawns attack diagonally forward (white up the board y+1, black down y-1)
-    if by_color == 'W':
-        for dx in (-1,1):
-            nx, ny = x+dx, y-1  # careful: we used y index 0->rank1; white moves up (increasing y)
-            # Wait: In our coords mapping y=0 is rank1, y=7 is rank8.
-            # White moves from rank1 to rank8 -> increasing y. Pawns attack y+1
-        # fix: white pawns attack y+1
-    # We'll implement correctly:
-    # Pawns
-    if by_color == 'W':
-        for dx in (-1,1):
-            nx, ny = x+dx, y-1  # incorrect earlier; correct is ny = y-1? Let's reason:
-            # Our rendering uses y increasing upwards (y=0 is rank1). White pawns start at y=1 and move to y=7 (increasing).
-            # So white pawn attacks at y+1. So ny = y+1 when attacking square (x,y) from a pawn at (nx,ny).
-            # We need to check pawns located at (nx,ny) such that they can attack (x,y).
-            pass
-
-# To avoid confusion, we will implement attack detection by scanning all opponent pieces and checking if they can move to (x,y)
-def generate_pseudo_legal_moves_from(board, x, y, mines=None):
-    """
-    Generate pseudo-legal moves (ignores checks) for piece at (x,y).
-    Returns list of target (tx,ty) coordinates.
-    """
+def generate_pseudo_legal_moves_from(board, x, y):
     piece = board[x][y]
     if piece is None:
         return []
     color, ptype = piece
     moves = []
-    if ptype == 'p':  # pawn
-        if color == 'W':
-            forward = (0, 1)
-            start_rank = 1
-            dir_sign = 1
-        else:
-            forward = (0, -1)
-            start_rank = 6
-            dir_sign = -1
-        # one step
-        nx, ny = x + forward[0], y + forward[1]
-        if in_bounds(nx, ny) and board[nx][ny] is None:
+    if ptype == 'p':
+        # pawns: white moves up (y+1), black moves down (y-1)
+        diry = 1 if color=='W' else -1
+        start_rank = 1 if color=='W' else 6
+        # one forward
+        nx, ny = x, y + diry
+        if in_bounds(nx,ny) and board[nx][ny] is None:
             moves.append((nx,ny))
-            # two steps from starting rank
-            if y == start_rank:
-                nx2, ny2 = x + forward[0]*2, y + forward[1]*2
-                if in_bounds(nx2, ny2) and board[nx2][ny2] is None:
-                    moves.append((nx2, ny2))
-        # captures diagonally
+            # two forward from start
+            nx2, ny2 = x, y + 2*diry
+            if y == start_rank and in_bounds(nx2,ny2) and board[nx2][ny2] is None:
+                moves.append((nx2,ny2))
+        # captures
         for dx in (-1,1):
-            cx, cy = x+dx, y+forward[1]
+            cx, cy = x+dx, y+diry
             if in_bounds(cx,cy) and board[cx][cy] is not None and board[cx][cy][0] != color:
                 moves.append((cx,cy))
-        # Note: en passant NOT implemented
-    elif ptype == 'c':  # cavalier
+    elif ptype == 'c':
         for dx,dy in KNIGHT_MOVES:
-            nx, ny = x+dx, y+dy
+            nx,ny = x+dx, y+dy
             if in_bounds(nx,ny) and (board[nx][ny] is None or board[nx][ny][0] != color):
                 moves.append((nx,ny))
-    elif ptype == 't':  # tour (rook)
+    elif ptype == 't':
         for dx,dy in DIRECTIONS_ROOK:
-            nx, ny = x+dx, y+dy
+            nx,ny = x+dx, y+dy
             while in_bounds(nx,ny):
                 if board[nx][ny] is None:
                     moves.append((nx,ny))
@@ -243,9 +160,9 @@ def generate_pseudo_legal_moves_from(board, x, y, mines=None):
                         moves.append((nx,ny))
                     break
                 nx += dx; ny += dy
-    elif ptype == 'f':  # fou (bishop)
+    elif ptype == 'f':
         for dx,dy in DIRECTIONS_BISHOP:
-            nx, ny = x+dx, y+dy
+            nx,ny = x+dx, y+dy
             while in_bounds(nx,ny):
                 if board[nx][ny] is None:
                     moves.append((nx,ny))
@@ -254,9 +171,9 @@ def generate_pseudo_legal_moves_from(board, x, y, mines=None):
                         moves.append((nx,ny))
                     break
                 nx += dx; ny += dy
-    elif ptype == 'R':  # reine (queen)
+    elif ptype == 'R':
         for dx,dy in DIRECTIONS_ROOK + DIRECTIONS_BISHOP:
-            nx, ny = x+dx, y+dy
+            nx,ny = x+dx, y+dy
             while in_bounds(nx,ny):
                 if board[nx][ny] is None:
                     moves.append((nx,ny))
@@ -265,19 +182,16 @@ def generate_pseudo_legal_moves_from(board, x, y, mines=None):
                         moves.append((nx,ny))
                     break
                 nx += dx; ny += dy
-    elif ptype == 'k':  # roi
+    elif ptype == 'k':
         for dx in (-1,0,1):
             for dy in (-1,0,1):
                 if dx==0 and dy==0: continue
-                nx, ny = x+dx, y+dy
+                nx,ny = x+dx, y+dy
                 if in_bounds(nx,ny) and (board[nx][ny] is None or board[nx][ny][0] != color):
                     moves.append((nx,ny))
-        # Castling omitted in this version
     return moves
 
 def is_square_attacked(board, tx, ty, attacker_color):
-    """Return True if (tx,ty) is attacked by attacker_color pieces."""
-    # naive: iterate all attacker_color pieces and see if any pseudo-legal move reaches (tx,ty)
     for x in range(8):
         for y in range(8):
             p = board[x][y]
@@ -287,79 +201,66 @@ def is_square_attacked(board, tx, ty, attacker_color):
                         return True
     return False
 
+def locate_king(board, color):
+    for x in range(8):
+        for y in range(8):
+            p = board[x][y]
+            if p is not None and p[0]==color and p[1]=='k':
+                return (x,y)
+    return None
+
 def king_in_check(board, color):
     kpos = locate_king(board, color)
     if kpos is None:
-        return True  # no king = in "check" (dead)
+        return True
     return is_square_attacked(board, kpos[0], kpos[1], 'B' if color=='W' else 'W')
 
 def all_legal_moves(board, color):
-    """
-    Generate all legal moves (from,to) for color, filtering out moves that leave king in check.
-    Returns list of ((x,y),(nx,ny)) moves.
-    """
     moves = []
     for x in range(8):
         for y in range(8):
             p = board[x][y]
-            if p is None or p[0]!=color:
-                continue
+            if p is None or p[0]!=color: continue
             for (nx,ny) in generate_pseudo_legal_moves_from(board, x, y):
-                # simulate move
                 b2 = copy.deepcopy(board)
                 b2[nx][ny] = b2[x][y]
                 b2[x][y] = None
+                # If move captures the opponent king by moving onto it, that's allowed but leads to win
                 if not king_in_check(b2, color):
                     moves.append(((x,y),(nx,ny)))
     return moves
 
-# === Game loop & move execution including mine logic ===
-
-def apply_move(board, from_xy, to_xy, mines, revealed, adj_counts, exploded, color):
-    """
-    Executes a move from -> to.
-    Returns (board, moved_piece_was_eliminated(bool), capture(bool), promotion(bool))
-    If destination is mined, the moving piece is removed instead.
-    """
+# ---------- apply move with mine logic ----------
+def apply_move(board, from_xy, to_xy, mines, revealed, adj, exploded):
     fx,fy = from_xy; tx,ty = to_xy
     piece = board[fx][fy]
     if piece is None:
         return board, False, False, False
-
-    # If moving onto a mine
+    # stepping onto mine?
     if (tx,ty) in mines:
         # piece eliminated
         board[fx][fy] = None
         exploded.add((tx,ty))
-        # The mine is now exploded and removed from mines set (can't explode again)
         mines.remove((tx,ty))
-        # Reveal the exploded square and possibly neighbors (we reveal adjacent counts too)
         revealed.add((tx,ty))
         return board, True, False, False
-
-    # Normal move/capture
+    # normal move
     capture = board[tx][ty] is not None
     board[tx][ty] = board[fx][fy]
     board[fx][fy] = None
-
-    # Reveal the destination (safe)
-    reveal_cascade(revealed, adj_counts, (tx,ty))
-
-    # Pawn promotion
+    # reveal
+    reveal_cascade(revealed, adj, (tx,ty))
+    # promotion
     promotion = False
     col, ptype = board[tx][ty]
     if ptype == 'p':
         if (col=='W' and ty==7) or (col=='B' and ty==0):
-            board[tx][ty] = (col, 'R')  # promote to queen (R)
+            board[tx][ty] = (col, 'R')
             promotion = True
-
     return board, False, capture, promotion
 
+# ---------- parsing ----------
 def parse_move_input(s):
-    """
-    Accepts formats like: e2e4 or e2 e4 or e2-e4
-    Returns (from_sq,to_sq) strings or None if invalid
-    """
     s = s.strip().lower().replace('-', ' ').replace('->',' ').replace(',', ' ')
     parts = s.split()
     if len(parts)==1 and len(parts[0])==4:
@@ -368,80 +269,108 @@ def parse_move_input(s):
         return parts[0], parts[1]
     return None
 
-def main():
-    print("=== ÉCHECS + DÉMINEUR ===")
-    print("Règles simplifiées : castling/en passant non implémentés. Promotion automatique en reine.")
+# ---------- Gradio app state helpers ----------
+def new_game_state(density):
     board = initial_board()
-    mines, revealed, adj_counts, exploded = generate_mines(board, density=0.18)
-    turn = 'W'  # White starts
-    move_number = 1
-
-    while True:
-        print("\n" + render_board(board, mines, revealed, adj_counts, exploded))
-        if king_in_check(board, turn):
-            print(f"Tour {move_number} - {'Blanc' if turn=='W' else 'Noir'}: Votre roi est en échec !")
-        else:
-            print(f"Tour {move_number} - {'Blanc' if turn=='W' else 'Noir'} à jouer.")
-
-        legal = all_legal_moves(board, turn)
-        if not legal:
-            if king_in_check(board, turn):
-                print(f"Échec et mat ! {'Noir' if turn=='W' else 'Blanc'} gagne.")
-            else:
-                print("Pat (stalemate).")
-            break
-
-        print("Entrez votre coup (ex: e2e4 ou e7 e5) ou 'quit' pour abandonner.")
-        inp = input("> ").strip()
-        if inp.lower() in ('quit','exit','q'):
-            print(f"{'Blanc' if turn=='W' else 'Noir'} a abandonné. Fin du jeu.")
-            break
-
-        parsed = parse_move_input(inp)
-        if parsed is None:
-            print("Format invalide. Réessayez.")
-            continue
-        from_sq, to_sq = parsed
-        try:
-            fx,fy = sq_to_coords(from_sq)
-            tx,ty = sq_to_coords(to_sq)
-        except Exception:
-            print("Coordonnées invalides. Utilisez a1..h8.")
-            continue
-
-        # Validate that there's a piece of player's color at from_sq
-        p = board[fx][fy]
-        if p is None or p[0] != turn:
-            print("Pas de pièce de votre couleur sur la case de départ.")
-            continue
-
-        # Check move is among legal moves
-        move_ok = False
-        for (a,b),(c,d) in legal:
-            if a==fx and b==fy and c==tx and d==ty:
-                move_ok = True; break
-        if not move_ok:
-            print("Coup illégal ou qui laisserait votre roi en échec. Réessayez.")
-            continue
-
-        # Apply move
-        board, eliminated, capture, promotion = apply_move(board, (fx,fy), (tx,ty), mines, revealed, adj_counts, exploded, turn)
-        if eliminated:
-            print("BOOM ! Mine déclenchée. Votre pièce a été éliminée.")
-            # If it was a king that exploded we should detect loss
-            # We'll check if the player's king still exists
-            if locate_king(board, turn) is None:
-                print(f"Votre roi a été éliminé par une mine. {'Noir' if turn=='W' else 'Blanc'} gagne.")
-                break
+    mines, revealed, adj, exploded = generate_mines(board, density=density)
+    state = {
+        "board": board,
+        "mines": mines,
+        "revealed": revealed,
+        "adj": adj,
+        "exploded": exploded,
+        "turn": 'W',
+        "move_number": 1,
+        "log": ["Nouvelle partie créée. Blanc commence."]
+    }
+    return state
+
+# ---------- Gradio callbacks ----------
+def start_new_game(density):
+    state = new_game_state(density)
+    board = state["board"]; mines=state["mines"]; revealed=state["revealed"]; adj=state["adj"]; exploded=state["exploded"]
+    board_text = render_board(board, mines, revealed, adj, exploded)
+    return board_text, "\n".join(state["log"]), state
+
+def submit_move(move_str, state):
+    if state is None:
+        return "Aucune partie en cours.", "Aucune", None
+    board = state["board"]; mines=state["mines"]; revealed=state["revealed"]; adj=state["adj"]; exploded=state["exploded"]
+    turn = state["turn"]
+    log = state["log"]
+    move = parse_move_input(move_str or "")
+    if move is None:
+        log.append("Format invalide. Utilisez ex: e2e4")
+        return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+    from_sq, to_sq = move
+    try:
+        fx,fy = sq_to_coords(from_sq)
+        tx,ty = sq_to_coords(to_sq)
+    except Exception:
+        log.append("Coordonnées invalides.")
+        return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+    p = board[fx][fy]
+    if p is None or p[0] != turn:
+        log.append("Pas de pièce de votre couleur sur la case de départ.")
+        return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+    legal = all_legal_moves(board, turn)
+    ok = False
+    for (a,b),(c,d) in legal:
+        if a==fx and b==fy and c==tx and d==ty:
+            ok = True; break
+    if not ok:
+        log.append("Coup illégal ou qui laisserait le roi en échec.")
+        return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+    board, eliminated, capture, promotion = apply_move(board, (fx,fy), (tx,ty), mines, revealed, adj, exploded)
+    if eliminated:
+        log.append(f"BOOM ! Mine déclenchée en {to_sq}. Pièce éliminée.")
+        # check if king remains
+        if locate_king(board, turn) is None:
+            winner = 'Noir' if turn=='W' else 'Blanc'
+            log.append(f"Le roi de {'Blanc' if turn=='W' else 'Noir'} a été éliminé. {winner} gagne.")
+            return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+    else:
+        if capture:
+            log.append(f"Prise en {to_sq}.")
+        if promotion:
+            log.append(f"Promotion en Reine en {to_sq}.")
+    # switch turn
+    state["turn"] = 'B' if turn=='W' else 'W'
+    state["move_number"] += 1
+    # check for check/checkmate/stalemate
+    next_color = state["turn"]
+    if king_in_check(board, next_color):
+        # check if has legal moves
+        if not all_legal_moves(board, next_color):
+            winner = 'Blanc' if next_color=='B' else 'Noir'
+            log.append(f"Échec et mat ! {winner} gagne.")
         else:
-            if capture:
-                print("Prise !")
-            if promotion:
-                print("Promotion automatique en Reine (R).")
-
-        # next turn
-        turn = 'B' if turn=='W' else 'W'
-        move_number += 1
-
+            log.append(f"{'Blanc' if next_color=='W' else 'Noir'} est en échec.")
+    else:
+        if not all_legal_moves(board, next_color):
+            log.append("Pat (stalemate).")
+    state["log"] = log
+    return render_board(board,mines,revealed,adj,exploded), "\n".join(log), state
+
+# ---------- Gradio UI ----------
+with gr.Blocks() as demo:
+    gr.Markdown("# ♟️ Échecs + Démineur (2 joueurs)")
+    gr.Markdown("Déplacez vos pièces normalement. Les cases vides initiales contiennent des mines aléatoires ; si une de vos pièces marche sur une mine, elle est éliminée.")
+    with gr.Row():
+        density = gr.Slider(minimum=0.05, maximum=0.35, value=0.18, step=0.01, label="Densité des mines (fraction des cases vides)")
+        btn_new = gr.Button("Nouvelle partie")
+    board_area = gr.Textbox(label="Plateau", interactive=False, lines=12)
+    log_area = gr.Textbox(label="Journal de partie", interactive=False, lines=8)
+    move_in = gr.Textbox(label="Votre coup (ex: e2e4)", placeholder="e2e4", lines=1)
+    btn_move = gr.Button("Jouer le coup")
+
+    state = gr.State(None)
+
+    btn_new.click(fn=start_new_game, inputs=[density], outputs=[board_area, log_area, state])
+    btn_move.click(fn=submit_move, inputs=[move_in, state], outputs=[board_area, log_area, state])
+
+    gr.Markdown("**Règles simplifiées** : promotion automatique en reine, pas de roque, pas d'en-passant.")
+
+# Launch app
 if __name__ == "__main__":
-    main()
+    demo.launch()