Create chess_mines.py

chess_mines.py

@@ -0,0 +1,447 @@
+#!/usr/bin/env python3
+"""
+Jeu d'échecs console 2 joueurs + mécanique démineur sur cases vides initiales.
+- 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.
+"""
+
+import random
+import copy
+
+# === Utilitaires de gestion du plateau ===
+
+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)
+
+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 setup (standard chess) ===
+def initial_board():
+    # Empty board: None
+    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, ...
+    for x,p in enumerate(white_row):
+        board[x][0] = ('W', p)  # white pieces uppercase display
+    for x in range(8):
+        board[x][1] = ('W', 'p')  # pawns
+
+    # Black pieces (top, ranks 8 & 7 -> y=7 and y=6)
+    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
+    for x in range(8):
+        board[x][6] = ('B', 'p')
+
+    return board
+
+# === Mines field and reveal map ===
+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 = {}
+    for x in range(8):
+        for y in range(8):
+            if (x,y) in mines:
+                adj_counts[(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:
+                            cnt += 1
+                adj_counts[(x,y)] = cnt
+    revealed = set()
+    exploded = set()  # squares where a mine exploded
+    return mines, revealed, adj_counts, exploded
+
+def reveal_cascade(revealed, adj_counts, start):
+    """Reveal start and cascade zeros recursively (like démineur)."""
+    stack = [start]
+    while stack:
+        s = stack.pop()
+        if s in revealed:
+            continue
+        revealed.add(s)
+        if adj_counts.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:
+                        stack.append((nx,ny))
+
+# === Display functions ===
+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):
+        row = f" {y+1} |"
+        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_counts.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) ===
+
+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.
+    """
+    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:
+            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
+        for dx in (-1,1):
+            cx, cy = x+dx, y+forward[1]
+            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
+        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':  # tour (rook)
+        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))
+                else:
+                    if board[nx][ny][0] != color:
+                        moves.append((nx,ny))
+                    break
+                nx += dx; ny += dy
+    elif ptype == 'f':  # fou (bishop)
+        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))
+                else:
+                    if board[nx][ny][0] != color:
+                        moves.append((nx,ny))
+                    break
+                nx += dx; ny += dy
+    elif ptype == 'R':  # reine (queen)
+        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))
+                else:
+                    if board[nx][ny][0] != color:
+                        moves.append((nx,ny))
+                    break
+                nx += dx; ny += dy
+    elif ptype == 'k':  # roi
+        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))
+        # 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]
+            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
+
+def king_in_check(board, color):
+    kpos = locate_king(board, color)
+    if kpos is None:
+        return True  # no king = in "check" (dead)
+    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
+            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 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.
+    """
+    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
+    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
+    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
+    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)
+            promotion = True
+
+    return board, False, capture, promotion
+
+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:
+        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
+
+def main():
+    print("=== ÉCHECS + DÉMINEUR ===")
+    print("Règles simplifiées : castling/en passant non implémentés. Promotion automatique en reine.")
+    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
+        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
+
+if __name__ == "__main__":
+    main()