Update app.py

app.py

@@ -1,20 +1,17 @@
-#!/usr/bin/env python3
-# coding: utf-8
-"""
-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 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
 import gradio as gr
 
+# === Unicode pour les pièces ===
+UNICODE_PIECES = {
+    ("W", "p"): "♙", ("B", "p"): "♟",
+    ("W", "t"): "♖", ("B", "t"): "♜",
+    ("W", "c"): "♘", ("B", "c"): "♞",
+    ("W", "f"): "♗", ("B", "f"): "♝",
+    ("W", "R"): "♕", ("B", "R"): "♛",
+    ("W", "k"): "♔", ("B", "k"): "♚"
+}
+
 FILES = "abcdefgh"
 RANKS = "12345678"
 
@@ -22,355 +19,194 @@ def sq_to_coords(sq):
     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 ----------
+# --- initial board ---
 def initial_board():
-    # 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)]
-    # 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):
+    white_row = ['t','c','f','R','k','f','c','t']
+    for x, p in enumerate(white_row):
         board[x][0] = ('W', p)
-    for x in range(8):
         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):
+    for x, p in enumerate(black_row):
         board[x][7] = ('B', p)
-    for x in range(8):
         board[x][6] = ('B', 'p')
     return board
 
-# ---------- mines and demineur mechanics ----------
+# --- mines ---
 def generate_mines(board, density=0.15):
-    empty = [(x,y) for x in range(8) for y in range(8) if board[x][y] is None]
+    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[(x,y)] = -1
-            else:
-                cnt = 0
-                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
-                        if in_bounds(nx,ny) and (nx,ny) in mines:
-                            cnt += 1
-                adj[(x,y)] = cnt
     revealed = set()
     exploded = set()
-    return mines, revealed, adj, exploded
-
-def reveal_cascade(revealed, adj, start):
-    stack = [start]
-    while stack:
-        s = stack.pop()
-        if s in revealed:
-            continue
-        revealed.add(s)
-        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: continue
-                    if in_bounds(nx,ny) and (nx,ny) not in revealed:
-                        stack.append((nx,ny))
-
-# ---------- display ----------
-def piece_to_char(piece):
-    if piece is None:
-        return '.'
-    col,ptype = piece
-    ch = ptype
-    return ch.upper() if col=='W' else ch.lower()
+    return mines, revealed, exploded
 
-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} |"
+# --- affichage ---
+def render_board(board, mines, revealed, exploded):
+    grid = []
+    for y in range(7, -1, -1):
+        row = []
         for x in range(8):
-            if (x,y) in exploded:
-                cell = "X"
-            elif board[x][y] is not None:
-                cell = piece_to_char(board[x][y])
-            elif (x,y) in revealed:
-                cnt = adj.get((x,y), 0)
-                cell = str(cnt) if cnt>0 else ' '
+            if (x, y) in exploded:
+                row.append("💥")
+            elif board[x][y]:
+                row.append(UNICODE_PIECES[board[x][y]])
+            elif (x, y) in revealed:
+                row.append("⬜")
             else:
-                cell = '.'
-            row += ' ' + cell
-        row += f" | {y+1}"
-        lines.append(row)
-    lines.append("   -----------------")
-    lines.append("    a b c d e f g h")
-    return "\n".join(lines)
+                row.append("⬛" if (x+y) % 2 else "⬜")
+        grid.append(row)
+    return "\n".join(" ".join(r) for r in grid)
 
-# ---------- moves generation ----------
+# --- mouvements ---
 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 generate_pseudo_legal_moves_from(board, x, y):
+def generate_pseudo_legal_moves(board, x, y):
     piece = board[x][y]
     if piece is None:
         return []
     color, ptype = piece
     moves = []
-    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
+    if ptype == "p":
+        diry = 1 if color == "W" else -1
+        start_rank = 1 if color == "W" else 6
         nx, ny = x, y + diry
-        if in_bounds(nx,ny) and board[nx][ny] is None:
-            moves.append((nx,ny))
-            # 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+diry
-            if in_bounds(cx,cy) and board[cx][cy] is not None and board[cx][cy][0] != color:
-                moves.append((cx,cy))
-    elif ptype == 'c':
-        for dx,dy in KNIGHT_MOVES:
-            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':
-        for dx,dy in DIRECTIONS_ROOK:
-            nx,ny = x+dx, y+dy
-            while in_bounds(nx,ny):
-                if board[nx][ny] is None:
-                    moves.append((nx,ny))
+        if in_bounds(nx, ny) and board[nx][ny] is None:
+            moves.append((nx, ny))
+            if y == start_rank and board[x][y + 2 * diry] is None:
+                moves.append((x, y + 2 * diry))
+        for dx in (-1, 1):
+            cx, cy = x + dx, y + diry
+            if in_bounds(cx, cy) and board[cx][cy] and board[cx][cy][0] != color:
+                moves.append((cx, cy))
+    elif ptype == "c":
+        for dx, dy in KNIGHT_MOVES:
+            nx, ny = x + dx, y + dy
+            if in_bounds(nx, ny) and (not board[nx][ny] or board[nx][ny][0] != color):
+                moves.append((nx, ny))
+    elif ptype == "t":
+        for dx, dy in DIRECTIONS_ROOK:
+            nx, ny = x + dx, y + dy
+            while in_bounds(nx, ny):
+                if not board[nx][ny]:
+                    moves.append((nx, ny))
                 else:
                     if board[nx][ny][0] != color:
-                        moves.append((nx,ny))
+                        moves.append((nx, ny))
                     break
                 nx += dx; ny += dy
-    elif ptype == 'f':
-        for dx,dy in DIRECTIONS_BISHOP:
-            nx,ny = x+dx, y+dy
-            while in_bounds(nx,ny):
-                if board[nx][ny] is None:
-                    moves.append((nx,ny))
+    elif ptype == "f":
+        for dx, dy in DIRECTIONS_BISHOP:
+            nx, ny = x + dx, y + dy
+            while in_bounds(nx, ny):
+                if not board[nx][ny]:
+                    moves.append((nx, ny))
                 else:
                     if board[nx][ny][0] != color:
-                        moves.append((nx,ny))
+                        moves.append((nx, ny))
                     break
                 nx += dx; ny += dy
-    elif ptype == 'R':
-        for dx,dy in DIRECTIONS_ROOK + DIRECTIONS_BISHOP:
-            nx,ny = x+dx, y+dy
-            while in_bounds(nx,ny):
-                if board[nx][ny] is None:
-                    moves.append((nx,ny))
+    elif ptype == "R":
+        for dx, dy in DIRECTIONS_ROOK + DIRECTIONS_BISHOP:
+            nx, ny = x + dx, y + dy
+            while in_bounds(nx, ny):
+                if not board[nx][ny]:
+                    moves.append((nx, ny))
                 else:
                     if board[nx][ny][0] != color:
-                        moves.append((nx,ny))
+                        moves.append((nx, ny))
                     break
                 nx += dx; ny += dy
-    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
-                if in_bounds(nx,ny) and (board[nx][ny] is None or board[nx][ny][0] != color):
-                    moves.append((nx,ny))
+    elif ptype == "k":
+        for dx in (-1, 0, 1):
+            for dy in (-1, 0, 1):
+                if dx == dy == 0: continue
+                nx, ny = x + dx, y + dy
+                if in_bounds(nx, ny) and (not board[nx][ny] or board[nx][ny][0] != color):
+                    moves.append((nx, ny))
     return moves
 
-def is_square_attacked(board, tx, ty, attacker_color):
-    for x in range(8):
-        for y in range(8):
-            p = board[x][y]
-            if p is not None and p[0] == attacker_color:
-                for (mx,my) in generate_pseudo_legal_moves_from(board, x, y):
-                    if mx==tx and my==ty:
-                        return True
-    return False
+# --- gestion du tour ---
+def apply_move(board, mines, revealed, exploded, move, turn):
+    from_sq, to_sq = move
+    fx, fy = sq_to_coords(from_sq)
+    tx, ty = sq_to_coords(to_sq)
+    piece = board[fx][fy]
 
-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
+    if not piece or piece[0] != turn:
+        return board, "Coup invalide"
 
-def king_in_check(board, color):
-    kpos = locate_king(board, color)
-    if kpos is None:
-        return True
-    return is_square_attacked(board, kpos[0], kpos[1], 'B' if color=='W' else 'W')
+    if (tx, ty) in mines:
+        exploded.add((tx, ty))
+        board[fx][fy] = None
+        revealed.add((tx, ty))
+        return board, f"💥 {from_sq}->{to_sq} : une mine explose ! Pièce détruite."
 
-def all_legal_moves(board, color):
-    moves = []
-    for x in range(8):
-        for y in range(8):
-            p = board[x][y]
-            if p is None or p[0]!=color: continue
-            for (nx,ny) in generate_pseudo_legal_moves_from(board, x, y):
-                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
+    legal = generate_pseudo_legal_moves(board, fx, fy)
+    if (tx, ty) not in legal:
+        return board, "Coup illégal."
 
-# ---------- 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
-    # stepping onto mine?
-    if (tx,ty) in mines:
-        # piece eliminated
-        board[fx][fy] = None
-        exploded.add((tx,ty))
-        mines.remove((tx,ty))
-        revealed.add((tx,ty))
-        return board, True, False, False
-    # normal move
     capture = board[tx][ty] is not None
-    board[tx][ty] = board[fx][fy]
+    board[tx][ty] = piece
     board[fx][fy] = None
-    # 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')
-            promotion = True
-    return board, False, capture, promotion
-
-# ---------- parsing ----------
-def parse_move_input(s):
-    s = s.strip().lower().replace('-', ' ').replace('->',' ').replace(',', ' ')
-    parts = s.split()
-    if len(parts)==1 and len(parts[0])==4:
-        return parts[0][0:2], parts[0][2:4]
-    if len(parts)==2 and all(len(p)==2 for p in parts):
-        return parts[0], parts[1]
-    return None
+    revealed.add((tx, ty))
+    text = f"{from_sq}->{to_sq}"
+    if capture: text += " (prise)"
+    return board, text
 
-# ---------- Gradio app state helpers ----------
-def new_game_state(density):
+# --- partie ---
+def new_game(density):
     board = initial_board()
-    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)
+    mines, revealed, exploded = generate_mines(board, density)
+    state = dict(
+        board=board,
+        mines=mines,
+        revealed=revealed,
+        exploded=exploded,
+        turn="W",
+        log=["Nouvelle partie ! Blanc commence."]
+    )
+    return render_board(board, mines, revealed, exploded), "\n".join(state["log"]), state
+
+def play_move(move_input, state):
+    if not state: return "Aucune partie", "Aucune", None
+    move_input = move_input.strip().lower()
+    if len(move_input) != 4: return render_board(**state), "Format invalide (ex: e2e4)", state
+    from_sq, to_sq = move_input[:2], move_input[2:]
+    board, text = apply_move(state["board"], state["mines"], state["revealed"], state["exploded"], (from_sq, to_sq), state["turn"])
+    state["board"] = board
+    state["log"].append(text)
+    state["turn"] = "B" if state["turn"] == "W" else "W"
+    board_text = render_board(board, state["mines"], state["revealed"], state["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:
-            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 ----------
+# --- interface ---
 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")
+    gr.Markdown("# ♟️ Échecs + 💣 Démineur")
+    gr.Markdown("Deux joueurs. Les cases vides cachent parfois des mines... Si une pièce marche dessus, elle est détruite 💥 !")
+
+    density = gr.Slider(0.05, 0.4, value=0.18, label="Densité de mines")
+    start = gr.Button("Nouvelle partie")
+
+    board_box = gr.Textbox(label="Plateau", lines=10, interactive=False)
+    move_in = gr.Textbox(label="Entrez votre coup (ex: e2e4)")
+    play = gr.Button("Jouer le coup")
 
-    state = gr.State(None)
+    log_box = gr.Textbox(label="Journal", lines=8, interactive=False)
+    state = gr.State()
 
-    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])
+    start.click(new_game, inputs=[density], outputs=[board_box, log_box, state])
+    play.click(play_move, inputs=[move_in, state], outputs=[board_box, log_box, state])
 
-    gr.Markdown("**Règles simplifiées** : promotion automatique en reine, pas de roque, pas d'en-passant.")
+    gr.Markdown("**Pièces :** ♙♟ Pions | ♖♜ Tours | ♘♞ Cavaliers | ♗♝ Fous | ♕♛ Reines | ♔♚ Rois")
 
-# Launch app
 if __name__ == "__main__":
     demo.launch()