Create app.py

app.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+demineur.py
+Version simple en terminal (ligne de commande).
+
+Commandes :
+  r i j   -> révéler la case (ligne i, colonne j)   (1-based)
+  f i j   -> poser/enlever un drapeau sur la case
+
+Exemple:
+  r 3 4
+  f 2 1
+"""
+
+import random
+import sys
+from typing import List, Set, Tuple
+
+# ---------- Configuration par défaut ----------
+DEFAULT_ROWS = 9
+DEFAULT_COLS = 9
+DEFAULT_MINES = 10
+
+# ---------- Génération du plateau ----------
+def create_board(rows: int, cols: int, mines: int):
+    if mines >= rows * cols:
+        raise ValueError("Le nombre de mines doit être inférieur au nombre total de cases.")
+    # board: -1 = mine, otherwise number of adjacent mines
+    board = [[0 for _ in range(cols)] for _ in range(rows)]
+    # placement aléatoire des mines
+    all_positions = [(r, c) for r in range(rows) for c in range(cols)]
+    mine_positions = set(random.sample(all_positions, mines))
+    for (r, c) in mine_positions:
+        board[r][c] = -1
+    # calcul des voisins
+    for r in range(rows):
+        for c in range(cols):
+            if board[r][c] == -1:
+                continue
+            count = 0
+            for dr in (-1, 0, 1):
+                for dc in (-1, 0, 1):
+                    if dr == 0 and dc == 0:
+                        continue
+                    nr, nc = r + dr, c + dc
+                    if 0 <= nr < rows and 0 <= nc < cols and board[nr][nc] == -1:
+                        count += 1
+            board[r][c] = count
+    return board, mine_positions
+
+# ---------- Affichage ----------
+def display(rows:int, cols:int, revealed: Set[Tuple[int,int]], flags: Set[Tuple[int,int]], board: List[List[int]], show_mines=False):
+    # entêtes colonnes
+    header = "    " + " ".join(f"{c+1:2}" for c in range(cols))
+    sep = "   +" + "---"*cols + "+"
+    print(header)
+    print(sep)
+    for r in range(rows):
+        row_cells = []
+        for c in range(cols):
+            pos = (r, c)
+            if pos in flags:
+                cell = " F"
+            elif pos in revealed:
+                val = board[r][c]
+                if val == -1:
+                    cell = " *"  # mine
+                elif val == 0:
+                    cell = "  "  # vide
+                else:
+                    cell = f" {val}"
+            else:
+                if show_mines and board[r][c] == -1:
+                    cell = " *"
+                else:
+                    cell = " #"
+            row_cells.append(cell)
+        print(f"{r+1:2} |" + "".join(row_cells) + " |")
+    print(sep)
+
+# ---------- Découverte en cascade ----------
+def flood_fill(board: List[List[int]], start_r:int, start_c:int, rows:int, cols:int, revealed: Set[Tuple[int,int]]):
+    stack = [(start_r, start_c)]
+    while stack:
+        r, c = stack.pop()
+        if (r,c) in revealed:
+            continue
+        revealed.add((r,c))
+        if board[r][c] == 0:
+            for dr in (-1, 0, 1):
+                for dc in (-1, 0, 1):
+                    nr, nc = r + dr, c + dc
+                    if 0 <= nr < rows and 0 <= nc < cols and (nr,nc) not in revealed:
+                        if board[nr][nc] != -1:
+                            stack.append((nr,nc))
+
+# ---------- Vérifications de victoire ----------
+def check_victory(rows:int, cols:int, mines:int, revealed:Set[Tuple[int,int]]):
+    # victoire si toutes les cases non-mines sont révélées
+    return len(revealed) == rows*cols - mines
+
+# ---------- Analyse entrée utilisateur ----------
+def parse_command(s: str):
+    parts = s.strip().split()
+    if len(parts) != 3:
+        return None
+    cmd = parts[0].lower()
+    if cmd not in ("r", "f"):
+        return None
+    try:
+        i = int(parts[1])
+        j = int(parts[2])
+        return (cmd, i, j)
+    except ValueError:
+        return None
+
+# ---------- Jeu principal ----------
+def run_game(rows:int, cols:int, mines:int):
+    board, mine_positions = create_board(rows, cols, mines)
+    revealed: Set[Tuple[int,int]] = set()
+    flags: Set[Tuple[int,int]] = set()
+    lost = False
+
+    print(f"\nBienvenue au Démineur ! {rows}x{cols}, mines: {mines}")
+    print("Commandes: 'r i j' pour révéler, 'f i j' pour poser/retirer un drapeau. Coordonnées 1-based (ex: r 3 4).")
+    while True:
+        display(rows, cols, revealed, flags, board if lost else False)
+        if lost:
+            print("💥 BOOM ! Vous avez touché une mine. Partie terminée.")
+            display(rows, cols, revealed.union(mine_positions), flags, board, show_mines=True)
+            break
+        if check_victory(rows, cols, mines, revealed):
+            print("🎉 Félicitations — vous avez gagné ! Toutes les cases sûres ont été révélées.")
+            display(rows, cols, revealed, flags, board, show_mines=True)
+            break
+
+        s = input("Entrée (r/f i j) > ").strip()
+        if s.lower() in ("quit", "exit", "q"):
+            print("Au revoir !")
+            break
+        parsed = parse_command(s)
+        if not parsed:
+            print("Commande invalide — ex: 'r 3 4' ou 'f 2 1'.")
+            continue
+        cmd, i, j = parsed
+        # convertir en 0-based
+        r, c = i - 1, j - 1
+        if not (0 <= r < rows and 0 <= c < cols):
+            print("Coordonnées hors plage.")
+            continue
+        pos = (r, c)
+        if cmd == "f":
+            if pos in revealed:
+                print("Impossible de poser un drapeau sur une case déjà révélée.")
+            else:
+                if pos in flags:
+                    flags.remove(pos)
+                    print(f"Drapeau retiré en ({i},{j}).")
+                else:
+                    flags.add(pos)
+                    print(f"Drapeau posé en ({i},{j}).")
+        elif cmd == "r":
+            if pos in flags:
+                print("Case marquée d'un drapeau — retirez le drapeau avant de révéler.")
+                continue
+            if pos in revealed:
+                print("Case déjà révélée.")
+                continue
+            if board[r][c] == -1:
+                # perdu
+                lost = True
+                revealed.add(pos)
+                continue
+            # si case sans voisins, on fait flood fill, sinon on révèle uniquement
+            if board[r][c] == 0:
+                flood_fill(board, r, c, rows, cols, revealed)
+            else:
+                revealed.add(pos)
+
+# ---------- Interface simple pour lancer ----------
+def main():
+    # possibilité de passer dimensions en argument: python demineur.py rows cols mines
+    rows = DEFAULT_ROWS
+    cols = DEFAULT_COLS
+    mines = DEFAULT_MINES
+    if len(sys.argv) >= 4:
+        try:
+            rows = int(sys.argv[1])
+            cols = int(sys.argv[2])
+            mines = int(sys.argv[3])
+        except Exception:
+            print("Usage: python demineur.py [rows cols mines]")
+            return
+    elif len(sys.argv) == 2:
+        # si un seul argument, on l'interprète comme taille carrée
+        try:
+            rows = cols = int(sys.argv[1])
+        except Exception:
+            print("Usage: python demineur.py [rows cols mines]")
+            return
+
+    # borne simple
+    if rows <= 0 or cols <= 0 or mines <= 0:
+        print("Les valeurs doivent être positives.")
+        return
+    if mines >= rows*cols:
+        print("Trop de mines pour la taille de la grille.")
+        return
+
+    run_game(rows, cols, mines)
+
+if __name__ == "__main__":
+    main()