Update app.py

app.py

@@ -1,19 +1,33 @@
 import random
-import copy
 import gradio as gr
 
-# === Unicode pour les pièces ===
-UNICODE_PIECES = {
+FILES = "abcdefgh"
+RANKS = "12345678"
+
+# 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"): "♚"
+    ("W", "k"): "♔", ("B", "k"): "♚",
 }
 
-FILES = "abcdefgh"
-RANKS = "12345678"
+def in_bounds(x, y):
+    return 0 <= x < 8 and 0 <= y < 8
+
+def initial_board():
+    b = [[None for _ in range(8)] for _ in range(8)]
+    white_row = ['t', 'c', 'f', 'R', 'k', 'f', 'c', 't']
+    for x, p in enumerate(white_row):
+        b[x][0] = ('W', p)
+        b[x][1] = ('W', 'p')
+    black_row = ['t', 'c', 'f', 'R', 'k', 'f', 'c', 't']
+    for x, p in enumerate(black_row):
+        b[x][7] = ('B', p)
+        b[x][6] = ('B', 'p')
+    return b
 
 def sq_to_coords(sq):
     sq = sq.lower()
@@ -22,120 +36,34 @@ def sq_to_coords(sq):
 def coords_to_sq(x, y):
     return FILES[x] + RANKS[y]
 
-def in_bounds(x, y):
-    return 0 <= x < 8 and 0 <= y < 8
-
-# --- initial board ---
-def initial_board():
-    board = [[None for _ in range(8)] for _ in range(8)]
-    white_row = ['t','c','f','R','k','f','c','t']
-    for x, p in enumerate(white_row):
-        board[x][0] = ('W', p)
-        board[x][1] = ('W', 'p')
-    black_row = ['t','c','f','R','k','f','c','t']
-    for x, p in enumerate(black_row):
-        board[x][7] = ('B', p)
-        board[x][6] = ('B', 'p')
-    return board
-
-# --- 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]
     n = max(1, int(len(empty) * density))
     mines = set(random.sample(empty, n))
-    revealed = set()
-    exploded = set()
-    return mines, revealed, exploded
+    return mines, set(), set()
+
+def count_adjacent_mines(x, y, mines):
+    return sum((nx, ny) in mines for nx in range(x-1, x+2) for ny in range(y-1, y+2)
+               if (nx, ny) != (x, y) and in_bounds(nx, ny))
 
-# --- affichage ---
-def render_board(board, mines, revealed, exploded):
+def render_board(board, mines, revealed, exploded, hints):
     grid = []
     for y in range(7, -1, -1):
         row = []
         for x in range(8):
             if (x, y) in exploded:
-                row.append("💥")
+                cell = "💥"
             elif board[x][y]:
-                row.append(UNICODE_PIECES[board[x][y]])
+                cell = PIECES[board[x][y]]
             elif (x, y) in revealed:
-                row.append("⬜")
+                cell = str(hints.get((x, y), 0)) if hints.get((x, y), 0) > 0 else "·"
             else:
-                row.append("⬛" if (x+y) % 2 else "⬜")
+                cell = "⬜" if (x + y) % 2 else "⬛"
+            row.append(cell)
         grid.append(row)
-    return "\n".join(" ".join(r) for r in grid)
-
-# --- 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(board, x, y):
-    piece = board[x][y]
-    if piece is None:
-        return []
-    color, ptype = piece
-    moves = []
-    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))
-            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))
-                    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 not board[nx][ny]:
-                    moves.append((nx, ny))
-                else:
-                    if board[nx][ny][0] != color:
-                        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 not board[nx][ny]:
-                    moves.append((nx, ny))
-                else:
-                    if board[nx][ny][0] != color:
-                        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 == 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
-
-# --- gestion du tour ---
-def apply_move(board, mines, revealed, exploded, move, turn):
+    return "\n".join(" ".join(row) for row in grid)
+
+def apply_move(board, mines, revealed, exploded, hints, move, turn):
     from_sq, to_sq = move
     fx, fy = sq_to_coords(from_sq)
     tx, ty = sq_to_coords(to_sq)
@@ -144,69 +72,62 @@ def apply_move(board, mines, revealed, exploded, move, turn):
     if not piece or piece[0] != turn:
         return board, "Coup invalide"
 
+    if not in_bounds(tx, ty):
+        return board, "Coup hors du plateau"
+
+    # Déplacement
+    board[fx][fy] = None
+
     if (tx, ty) in mines:
         exploded.add((tx, ty))
-        board[fx][fy] = None
+        text = f"💥 {from_sq}->{to_sq} : Mine ! Pièce détruite."
+    else:
+        board[tx][ty] = piece
         revealed.add((tx, ty))
-        return board, f"💥 {from_sq}->{to_sq} : une mine explose ! Pièce détruite."
-
-    legal = generate_pseudo_legal_moves(board, fx, fy)
-    if (tx, ty) not in legal:
-        return board, "Coup illégal."
-
-    capture = board[tx][ty] is not None
-    board[tx][ty] = piece
-    board[fx][fy] = None
-    revealed.add((tx, ty))
-    text = f"{from_sq}->{to_sq}"
-    if capture: text += " (prise)"
+        count = count_adjacent_mines(tx, ty, mines)
+        hints[(tx, ty)] = count
+        text = f"{from_sq}->{to_sq} (zone sûre, {count} mines autour)"
     return board, text
 
-# --- partie ---
 def new_game(density):
     board = initial_board()
     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
+    hints = {}
+    state = dict(board=board, mines=mines, revealed=revealed,
+                 exploded=exploded, hints=hints, turn="W", log=["Nouvelle partie"])
+    return render_board(board, mines, revealed, exploded, hints), "\n".join(state["log"]), state
 
 def play_move(move_input, state):
-    if not state: return "Aucune partie", "Aucune", None
+    if not state:
+        return "Pas de partie", "Commence une nouvelle partie", None
     move_input = move_input.strip().lower()
-    if len(move_input) != 4: return render_board(**state), "Format invalide (ex: e2e4)", state
+    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"])
+    board, text = apply_move(state["board"], state["mines"], state["revealed"],
+                             state["exploded"], state["hints"], (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
+    return render_board(board, state["mines"], state["revealed"], state["exploded"], state["hints"]), "\n".join(state["log"]), state
 
-# --- interface ---
 with gr.Blocks() as demo:
-    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 💥 !")
+    gr.Markdown("# ♟️ ChessMine — Échecs + 💣 Démineur")
+    gr.Markdown("Deux joueurs alternent leurs coups. Si une pièce marche sur une mine 💥 elle explose, sinon la case révèle le nombre de mines autour 🔢.")
 
-    density = gr.Slider(0.05, 0.4, value=0.18, label="Densité de mines")
+    density = gr.Slider(0.05, 0.4, value=0.15, 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")
-
+    move_in = gr.Textbox(label="Coup (ex: e2e4)")
+    play = gr.Button("Jouer")
     log_box = gr.Textbox(label="Journal", lines=8, interactive=False)
     state = gr.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("**Pièces :** ♙♟ Pions | ♖♜ Tours | ♘♞ Cavaliers | ♗♝ Fous | ♕♛ Reines | ♔♚ Rois")
+    gr.Markdown("**Règles :**\n- Entrez vos coups en format `e2e4`.\n- Si la case cible contient une 💣 → explosion !\n- Sinon, un nombre indique combien de mines se trouvent autour.\n- Les pièces utilisent les symboles Unicode standards ♙♟♖♜♘♞♗♝♕♛♔♚.")
 
 if __name__ == "__main__":
     demo.launch()