java doc et reglage probleme win/lose

ActionCase.java

@@ -2,25 +2,36 @@ import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
 import javax.swing.SwingUtilities;
 
+/**
+ * Écouteur d'événements de souris associé à chaque bouton de la grille.
+ * Détecte si le joueur effectue un clic gauche (révéler) ou un clic droit (marqueur).
+ */
 public class ActionCase implements MouseListener {
 
     private FenetreJeu fenetreJeu;
     private int ligne;
     private int colonne;
 
+    /**
+     * Constructeur de l'action de case.
+     * @param f La fenêtre de jeu principale pour interagir avec sa logique.
+     * @param l L'index de la ligne de cette case.
+     * @param c L'index de la colonne de cette case.
+     */
     public ActionCase(FenetreJeu f, int l, int c) {
         this.fenetreJeu = f;
         this.ligne = l;
         this.colonne = c;
     }
 
+    /**
+     * Méthode déclenchée lors du clic sur le bouton de la case.
+     * @param e L'événement de la souris.
+     */
     public void mouseClicked(MouseEvent e) {
-	// Clic droit
         if (SwingUtilities.isRightMouseButton(e)) {
             fenetreJeu.clicDroit(ligne, colonne);
-	}
+        } else if (SwingUtilities.isLeftMouseButton(e)) {
-	// clic gauche
-	else if (SwingUtilities.isLeftMouseButton(e)) {
             fenetreJeu.clicGauche(ligne, colonne);
         }
     }
@@ -30,4 +41,3 @@ public class ActionCase implements MouseListener {
     public void mouseEntered(MouseEvent e) {}
     public void mouseExited(MouseEvent e) {}
 }
-

ActionDemarrer.java

@@ -1,8 +1,11 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import javax.swing.*;
-import java.awt.*;
 
+/**
+ * Action déclenchée pour valider les paramètres et générer la grille de jeu.
+ * Vérifie que les entrées du joueur respectent les règles (entre 4 et 30 cases, etc.).
+ */
 public class ActionDemarrer implements ActionListener {
     
     private JTextField champLignes;
@@ -11,17 +14,26 @@ public class ActionDemarrer implements ActionListener {
     private JFrame cible;
     private Menu menuPrincipal;
     
-    
+    /**
+     * Constructeur de l'action de démarrage.
+     * @param champL Le champ de texte contenant le nombre de lignes.
+     * @param champC Le champ de texte contenant le nombre de colonnes.
+     * @param champM Le champ de texte contenant le nombre de mines.
+     * @param cible La fenêtre de configuration à fermer.
+     * @param menu Le menu principal à fermer.
+     */
     public ActionDemarrer(JTextField champL, JTextField champC, JTextField champM, JFrame cible, Menu menu) {
         this.champLignes = champL;
         this.champColonnes = champC;
         this.champMines = champM;
         this.cible = cible;
         this.menuPrincipal = menu;
-	
     }
     
-    
+    /**
+     * Récupère les saisies, les valide et lance la fenêtre de jeu si tout est correct.
+     * @param e L'événement du clic.
+     */
     public void actionPerformed(ActionEvent e) {
         String sLignes = champLignes.getText();
         String sColonnes = champColonnes.getText();
@@ -32,13 +44,10 @@ public class ActionDemarrer implements ActionListener {
             int c = Integer.parseInt(sColonnes);
             int m = Integer.parseInt(sMines);
             
-            // Vérife entre 4 et 30 ligne/colonne
             if (l < 4 || l > 30 || c < 4 || c > 30) {
                 System.out.println("Erreur : Les dimensions doivent être comprises entre 4 et 30");
                 return; 
             }
-	    
-            // Véérife nb Mines
             if (m >= (l * c)) {
                 System.out.println("Erreur : Le nombre de mines doit être inférieur au nombre de cases !");
                 return;
@@ -50,7 +59,6 @@ public class ActionDemarrer implements ActionListener {
             
             new FenetreJeu(g);
             
-            // On ferme les deux fenêtres
             cible.dispose(); 
             menuPrincipal.getFenetre().dispose(); 
             
@@ -58,5 +66,4 @@ public class ActionDemarrer implements ActionListener {
             System.out.println("Erreur : Veuillez entrer des nombres entiers valides");
         }
     }
-    
 }

ActionFermerFenetre.java

@@ -0,0 +1,50 @@
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.io.FileOutputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
+
+/**
+ * Écouteur lié à la croix de fermeture de la fenêtre de jeu.
+ * Permet de déclencher une sauvegarde automatique avant de quitter.
+ */
+public class ActionFermerFenetre implements WindowListener {
+    
+    private FenetreJeu jeu; 
+
+    /**
+     * Constructeur de l'écouteur de la fenêtre.
+     * @param j La fenêtre de jeu.
+     */
+    public ActionFermerFenetre(FenetreJeu j) {
+        this.jeu = j;
+    }
+
+    /**
+     * Méthode exécutée lorsque le joueur clique sur la croix de la fenêtre.
+     * Sérialise la partie en cours avant de fermer.
+     * @param e L'événement de la fenêtre.
+     */
+    public void windowClosing(WindowEvent e) {
+        if (!jeu.isPartieTerminee()) {
+            try {
+                FileOutputStream fichier = new FileOutputStream("sauvegarde.ser");
+                ObjectOutputStream flux = new ObjectOutputStream(fichier);
+                flux.writeObject(jeu.getGrille());
+                flux.close();
+                fichier.close();
+                System.out.println("Partie sauvegardée depuis la croix");
+            } catch (IOException ex) {
+                System.out.println("Erreur : " + ex.getMessage());
+            }
+        }
+        System.exit(0);
+    }
+
+    public void windowOpened(WindowEvent e) {}
+    public void windowClosed(WindowEvent e) {}
+    public void windowIconified(WindowEvent e) {}
+    public void windowDeiconified(WindowEvent e) {}
+    public void windowActivated(WindowEvent e) {}
+    public void windowDeactivated(WindowEvent e) {}
+}

ActionReprendre.java

@@ -3,15 +3,26 @@ import java.awt.event.ActionListener;
 import java.io.FileInputStream;
 import java.io.ObjectInputStream;
 import java.io.IOException;
-import java.io.File;
 
+/**
+ * Action déclenchée depuis le menu pour recharger une partie sauvegardée.
+ * Utilise la désérialisation pour récupérer l'objet Grille depuis un fichier.
+ */
 public class ActionReprendre implements ActionListener {
     private Menu menu;
 
+    /**
+     * Constructeur de l'action reprendre.
+     * @param m Le menu principal à fermer après le chargement.
+     */
     public ActionReprendre(Menu m) {
         this.menu = m;
     }
 
+    /**
+     * Lit le fichier de sauvegarde et relance la fenêtre de jeu.
+     * @param e L'événement du clic.
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
         try {
@@ -24,7 +35,6 @@ public class ActionReprendre implements ActionListener {
             fichier.close();
             
             new FenetreJeu(g);
-            
             menu.getFenetre().dispose();
             
         } catch (IOException | ClassNotFoundException ex) {

ActionRetourMenu.java

@@ -2,14 +2,25 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import javax.swing.JFrame;
 
+/**
+ * Action permettant de quitter la partie en cours pour revenir au menu principal.
+ */
 public class ActionRetourMenu implements ActionListener {
     
     private JFrame fenetreJeu;
 
+    /**
+     * Constructeur du retour au menu.
+     * @param f La fenêtre de jeu actuelle à fermer.
+     */
     public ActionRetourMenu(JFrame f) {
         this.fenetreJeu = f;
     }
 
+    /**
+     * Ferme la fenêtre en cours et instancie un nouveau menu.
+     * @param e L'événement du clic.
+     */
     public void actionPerformed(ActionEvent e) {
         fenetreJeu.dispose();
         new Menu();

ActionSauverQuitter.java

@@ -4,30 +4,39 @@ import java.io.FileOutputStream;
 import java.io.ObjectOutputStream;
 import java.io.IOException;
 
+/**
+ * Action déclenchée par le bouton pour sauvegarder l'état actuel et fermer le jeu.
+ * Utilise la sérialisation pour écrire l'objet Grille dans un fichier.
+ */
 public class ActionSauverQuitter implements ActionListener {
     
-    private Grille grilleASauver;
+    private FenetreJeu jeu; 
 
-    public ActionSauverQuitter(Grille g) {
+    /**
-        this.grilleASauver = g;
+     * Constructeur de l'action de sauvegarde.
+     * @param j La fenêtre de jeu contenant la grille à sauvegarder.
+     */
+    public ActionSauverQuitter(FenetreJeu j) {
+        this.jeu = j;
     }
 
+    /**
+     * Sérialise la grille si la partie n'est pas terminée, puis quitte le programme.
+     * @param e L'événement du clic.
+     */
     public void actionPerformed(ActionEvent e) {
+        if (!jeu.isPartieTerminee()) {
             try {
                 FileOutputStream fichier = new FileOutputStream("sauvegarde.ser");
                 ObjectOutputStream flux = new ObjectOutputStream(fichier);
-            
+                flux.writeObject(jeu.getGrille());
-            flux.writeObject(grilleASauver);
-            
                 flux.close();
                 fichier.close();
-            
                 System.out.println("Partie sauvegardée avec succès !");
-            
-            System.exit(0);
-            
             } catch (IOException ex) {
                 System.out.println("Erreur lors de la sauvegarde : " + ex.getMessage());
             }
         }
+        System.exit(0);
+    }
 }

Case.java

@@ -1,5 +1,9 @@
 import java.io.Serializable;
 
+/**
+ * Représente une case individuelle de la grille de Démineur.
+ * Chaque case mémorise son état (minée, révélée, marqueur,..).
+ */
 public class Case implements Serializable {
 
     private boolean estMinee;
@@ -8,8 +12,11 @@ public class Case implements Serializable {
     private int marqueur;
     private int nbMinesautour;
 
+    /**
+     * Constructeur par défaut.
+     * Initialise une case vide, cachée et sans marqueur.
+     */
     public Case() {
-
         this.estMinee = false;
         this.estMineFatale = false;
         this.estRevelee = false;
@@ -17,23 +24,40 @@ public class Case implements Serializable {
         this.nbMinesautour = 0;
     }
 
+    /** @return true si la case contient une mine, false sinon. */
     public boolean getEstMinee() { return estMinee; }
+    
+    /** @param min true pour placer une mine sur cette case. */
     public void setEstMinee(boolean min) { this.estMinee = min; }
 
+    /** @return true si cette mine a causé la défaite du joueur. */
     public boolean getEstMineFatale() { return estMineFatale; }
+    
+    /** @param b true si cette case est la mine qui a explosé. */
     public void setEstMineFatale(boolean b) { this.estMineFatale = b; }
 
+    /** @return true si la case a été cliquée ou révélée, false si elle est cachée. */
     public boolean getEstRevelee() { return estRevelee; }
+    
+    /** @param rev true pour révéler la case, false pour la cacher. */
     public void setEstRevelee(boolean rev) { this.estRevelee = rev; }
 
+    /** @return 0 pour vide, 1 pour étoile (★), 2 pour doute (?). */
     public int getMarqueur() { return marqueur; }
+    
+    /**
+     * Fait tourner le marqueur en boucle (Vide -> ★ -> ? -> Vide).
+     * N'a aucun effet si la case est déjà révélée.
+     */
     public void boucleMarqueur() {
         if (!estRevelee) {
             marqueur = (marqueur + 1) % 3;
-	    // permet de faire tourner le marqueur en boucle a chaque clic droit et modulo 3 comme ca le resultat est forcé de rester entre 0 et 2 (en gros les 3 solutions possible)
         }
     }
 
+    /** @return Le nombre de mines présentes dans les 8 cases adjacentes. */
     public int getNbMinesautour() { return nbMinesautour; }
+    
+    /** @param nb Le nombre de mines adjacentes calculé. */
     public void setNbMinesautour(int nb) { this.nbMinesautour = nb; }
 }

Demineur.java

@@ -1,6 +1,13 @@
+/**
+ * Classe principale de l'application.
+ * Contient la méthode main permettant de lancer le jeu.
+ */
 public class Demineur {
+    /**
+     * Instancie le menu principal.
+     * @param args Les arguments de la ligne de commande (non utilisés ici).
+     */
     public static void main(String[] args){
         Menu menu = new Menu();
-
     }
 }

FenetreJeu.java

@@ -1,8 +1,10 @@
 import javax.swing.*;
 import java.awt.*;
 
-// Fenetre principal du jeu (ou il y a la grille de boutons)
+/**
-
+ * Fenêtre principale du jeu.
+ * Gère l'interface de la partie en cours, la grille de boutons, les clics et les conditions de fin de partie.
+ */
 public class FenetreJeu {
 
     private JFrame fenetre;
@@ -11,27 +13,31 @@ public class FenetreJeu {
     private Grille grille;
     private boolean partieTerminee = false;
     private JLabel labelStatut;
+    private JButton boutonSauver;
 
+    /**
+     * Constructeur de la fenêtre de jeu.
+     * @param g La grille contenant les données des cases et des mines.
+     */
     public FenetreJeu(Grille g) {
         this.grille = g;
         int l = grille.getLigne();
         int c = grille.getColonne();
 
         fenetre = new JFrame("Demineur");
-	fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        fenetre.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); 
+        fenetre.addWindowListener(new ActionFermerFenetre(this));
 
         panneauGrille = new JPanel();
         panneauGrille.setLayout(new GridLayout(l, c));
         boutons = new JButton [l][c];
 
-	// creation de tous les boutons de la grille
+        // Création de tous les boutons de la grille
-
         for (int i = 0; i < l; i++) {
             for (int j = 0; j < c; j++) {
                 boutons[i][j] = new JButton();
                 boutons[i][j].setPreferredSize(new Dimension(45, 45));
                 boutons[i][j].setFont(new Font("Arial", Font.BOLD, 16));
-		// ecouteur de clics
                 boutons[i][j].addMouseListener(new ActionCase(this, i, j));
                 panneauGrille.add(boutons[i][j]);
             }
@@ -47,14 +53,13 @@ public class FenetreJeu {
         labelStatut = new JLabel("Partie en cours...", SwingConstants.CENTER);
         labelStatut.setFont(new Font("Arial", Font.BOLD, 14));
         
-        // pour aligner les boutons horizontalement
         JPanel conteneurBoutons = new JPanel();
         
         JButton boutonMenu = new JButton("Menu Principal");
         boutonMenu.addActionListener(new ActionRetourMenu(fenetre));
         
-        JButton boutonSauver = new JButton("Sauver et Quitter");
+        boutonSauver = new JButton("Sauver et Quitter");
-        boutonSauver.addActionListener(new ActionSauverQuitter(grille));
+        boutonSauver.addActionListener(new ActionSauverQuitter(this));
 
         conteneurBoutons.add(boutonMenu);
         conteneurBoutons.add(boutonSauver);
@@ -70,8 +75,10 @@ public class FenetreJeu {
         actualiserAffichage();
     }
     
-
+    /**
-
+     * Vérifie si toutes les cases sans mine ont été révélées.
+     * Si c'est le cas, déclenche l'état de victoire.
+     */
     public void verifierVictoire() {
         int casesAReveler = (grille.getLigne() * grille.getColonne());
         int nbMines = 0;
@@ -86,15 +93,27 @@ public class FenetreJeu {
 
         if (nbRevelees == (casesAReveler - nbMines)) {
             partieTerminee = true;
+            bloquerSauvegarde();
             System.out.println("Vous avez gagné !");
+            labelStatut.setFont(new Font("Arial", Font.BOLD, 24));
+            labelStatut.setForeground(new Color(0, 150, 0));
+            labelStatut.setText(" VICTOIRE ! Bien joué !");
         }
     }
     
+    /**
+     * Révèle les cases adjacentes en cascade si la case actuelle n'a aucune mine autour.
+     * Cette méthode est récursive.
+     * @param l L'index de la ligne de la case actuelle.
+     * @param c L'index de la colonne de la case actuelle.
+     */
     public void revelerCaseProche(int l, int c){
         if (l < 0 || l >= grille.getLigne() || c < 0 || c >= grille.getColonne() ) return;
         Case caseActuelle = grille.getCase(l, c);
         if (caseActuelle.getMarqueur() !=  0 || caseActuelle.getEstRevelee() == true ) return;
+        
         caseActuelle.setEstRevelee(true);
+        
         if(caseActuelle.getNbMinesautour() == 0){
             for(int i = -1; i <= 1; i++){
                 for(int j = -1; j <= 1; j++){
@@ -103,13 +122,36 @@ public class FenetreJeu {
                     revelerCaseProche(vL,vC);
                 }
             }
-	    
         }
     }
 
+    /**
+     * Désactive le bouton de sauvegarde et supprime le fichier de sauvegarde existant.
+     * Appelée lorsque la partie est terminée (victoire ou défaite).
+     */
+    public void bloquerSauvegarde() {
+        boutonSauver.setEnabled(false); 
+        java.io.File fichier = new java.io.File("sauvegarde.ser");
+        if (fichier.exists()) {
+            fichier.delete(); 
+        }
+    }
     
+    /** @return true si la partie est terminée, false sinon. */
+    public boolean isPartieTerminee() { return partieTerminee; }
     
+    /** @return La grille logique manipulée par cette fenêtre. */
+    public Grille getGrille() { return grille; }
+    
+    /**
+     * Gère les événements de défaite.
+     * Affiche le message de défaite et révèle toutes les mines et erreurs de la grille.
+     */
     public void partiePerdu(){
+        bloquerSauvegarde();
+        labelStatut.setFont(new Font("Arial", Font.BOLD, 24));
+        labelStatut.setForeground(Color.RED);
+        labelStatut.setText(" DÉFAITE !");
         for(int i =0; i<grille.getLigne(); i++){
             for(int j=0;j < grille.getColonne();j++){
                 Case currentCase = grille.getCase(i, j);
@@ -120,8 +162,12 @@ public class FenetreJeu {
         }
     }
     
-    
+    /**
-    // logique du clic droit
+     * Logique exécutée lors d'un clic droit sur la grille.
+     * Modifie le marqueur de la case (Doute, Mine, Vide).
+     * @param l L'index de la ligne cliquée.
+     * @param c L'index de la colonne cliquée.
+     */
     public void clicDroit(int l, int c) {
         if (partieTerminee) return;
         Case caseCliquee = grille.getCase(l, c);
@@ -129,13 +175,17 @@ public class FenetreJeu {
         actualiserAffichage();
     }
 
-    // logique clic gauche
+    /**
+     * Logique exécutée lors d'un clic gauche sur la grille.
+     * Révèle la case, déclenche une cascade ou provoque la défaite si c'est une mine.
+     * @param l L'index de la ligne cliquée.
+     * @param c L'index de la colonne cliquée.
+     */
     public void clicGauche(int l, int c) {
         if (partieTerminee) return;
         Case caseCliquee = grille.getCase(l, c);
 
-	// secu on ne peut pas cliquer une une case avec un marqueur etoile ou ?
+        // sécurité: on ne peut pas cliquer sur une case avec un marqueur étoile ou ?
-
         if (caseCliquee.getMarqueur() != 0) return;
 
         if (caseCliquee.getEstMinee()) {
@@ -144,15 +194,17 @@ public class FenetreJeu {
             caseCliquee.setEstRevelee(true);
             partieTerminee = true;
             partiePerdu();
-
         } else {
             revelerCaseProche(l,c);
+            verifierVictoire();
         }
         actualiserAffichage();
     }
  
-
+    /**
-    // mise à jour du texte et couleurs de tous les boutons
+     * Met à jour l'apparence de tous les boutons de la grille en fonction de l'état des cases.
+     * Met également à jour le compteur de mines restantes en bas de la fenêtre.
+     */
     public void actualiserAffichage() {
         int l = grille.getLigne();
         int c = grille.getColonne();
@@ -163,36 +215,29 @@ public class FenetreJeu {
                 JButton btn = boutons[i][j];
                 
                 if (currentCase.getEstRevelee()) {
-                    btn.setEnabled(false); // pour rendre le bouton incliquable
+                    btn.setEnabled(false); 
                     
                     if (currentCase.getEstMinee()) {
-                        // C'est une vraie mine
                         btn.setText("¤");
                         if (currentCase.getEstMineFatale()) {
                             btn.setBackground(Color.RED);
                         } else {
                             btn.setBackground(Color.ORANGE);
                         }
-                        
                     } else {
-                        // Ce n'est pas une mine
                         if (currentCase.getMarqueur() == 1) {
-                            // Erreur si le joueur a mis une fausse étoile
                             btn.setText("X");
                             btn.setBackground(Color.YELLOW);
                         } else {
-                            // on affiche le chiffre ou rien
                             int nb = currentCase.getNbMinesautour();
                             if (nb > 0) {
                                 btn.setText(String.valueOf(nb));
                             } else {
-                                btn.setText(""); // case vide
+                                btn.setText(""); 
                             }
                         }
                     }
-                    
                 } else {
-                    // La case est encore cachée
                     btn.setEnabled(true);
                     int mq = currentCase.getMarqueur();
                     if (mq == 1) btn.setText("★");
@@ -201,15 +246,18 @@ public class FenetreJeu {
                 }
             }
         }
+        
+        if (!partieTerminee) {
+            int nbEtoiles = 0;
+            for (int i = 0; i < l; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (grille.getCase(i, j).getMarqueur() == 1) {
+                        nbEtoiles++;
+                    }
+                }
+            }
+            int progression = grille.getNbMinesTotales() - nbEtoiles;
+            labelStatut.setText("Progression : " + progression + " mine(s) restante(s)");
+        }
     }
-    
-    
-    
-    
-    
-    
-    
-    
-    
 }
-	

Grille.java

@@ -1,12 +1,22 @@
 import java.util.Random;
 import java.io.Serializable;
 
+/**
+ * Représente la grille complète du jeu de Démineur.
+ * Gère le placement aléatoire des mines et le calcul des cases voisines.
+ */
 public class Grille implements Serializable {
     
     private Case[][] grille;
     private int ligne, colonne;
     private Random generateur = new Random();
+    private int nbMinesTotales;
     
+    /**
+     * Construit une nouvelle grille vide avec les dimensions spécifiées.
+     * @param ligne Le nombre de lignes de la grille.
+     * @param colonne Le nombre de colonnes de la grille.
+     */
     public Grille(int ligne, int colonne) {
         this.ligne = ligne; 
         this.colonne = colonne;
@@ -18,53 +28,75 @@ public class Grille implements Serializable {
         }
     }
 
-
+    /**
+     * Place un nombre de mines aléatoirement dans la grille.
+     * @param nbMines Le nombre total de mines à cacher.
+     */
     public void placerMines(int nbMines) {
+        this.nbMinesTotales = nbMines;
         int randomLigne, randomColonne;
         for(int i = 0; i < nbMines; i++) {
             randomLigne = generateur.nextInt(ligne);
             randomColonne = generateur.nextInt(colonne);
             if (grille[randomLigne][randomColonne].getEstMinee() == true) {
-	    i--; } else {
+                i--; // On recommence si la case a déjà une mine
+            } else {
                 grille[randomLigne][randomColonne].setEstMinee(true);
             }
         }
     }
 
+    /**
+     * @return Le nombre total de mines présentes dans la grille.
+     */
+    public int getNbMinesTotales() {
+        return nbMinesTotales;
+    }
+
+    /**
+     * Compte le nombre de mines autour d'une case spécifique et met à jour cette case.
+     * @param l L'index de la ligne de la case.
+     * @param c L'index de la colonne de la case.
+     */
     public void compterMinesVoisines(int l, int c) {
         int compteur = 0;
         for(int i = -1; i <= 1; i++) {
             for(int j = -1; j <= 1; j++) {
                 int vL = l + i;
                 int vC = c + j;
+                // Vérifie que l'on ne sort pas des limites du tableau
                 if(vL >= 0 && vL < ligne && vC >= 0 && vC < colonne) {
                     if (grille[vL][vC].getEstMinee()) {
                         compteur++;
                     }
-
                 }
-		
-                
             }
         }
         grille[l][c].setNbMinesautour(compteur);
     }
 
+    /**
+     * Parcourt toute la grille pour calculer les mines voisines de chaque case.
+     */
     public void calculerToutesLesMines() {
         for(int i = 0; i < ligne; i++) {
             for(int j = 0; j < colonne; j++) {
                 compterMinesVoisines(i, j);
-	    
+            }
         }
     }
 
-
+    /** @return Le nombre de lignes de la grille. */
-    }
-
-    // interface graphique
-
     public int getLigne() { return ligne; }
-    public int getColonne() { return colonne; }
-    public Case getCase(int l, int c) { return grille[l][c]; }
     
+    /** @return Le nombre de colonnes de la grille. */
+    public int getColonne() { return colonne; }
+    
+    /**
+     * Récupère l'objet Case à une position spécifique.
+     * @param l L'index de la ligne.
+     * @param c L'index de la colonne.
+     * @return L'objet Case correspondant.
+     */
+    public Case getCase(int l, int c) { return grille[l][c]; }
 }

Makefile

@@ -7,8 +7,8 @@ Grille.class : Grille.java Case.class
 Quitter.class : Quitter.java
 	javac -implicit:none Quitter.java
 
-Menu.class NouvellePartie.class ActionDemarrer.class FenetreJeu.class ActionCase.class ActionRetourMenu.class ActionSauverQuitter.class ActionReprendre.class : Menu.java NouvellePartie.java ActionDemarrer.java FenetreJeu.java ActionCase.java ActionRetourMenu.java ActionSauverQuitter.java ActionReprendre.java Grille.class Quitter.class
+Menu.class NouvellePartie.class ActionDemarrer.class FenetreJeu.class ActionCase.class ActionRetourMenu.class ActionSauverQuitter.class ActionReprendre.class ActionFermerFenetre.class : Menu.java NouvellePartie.java ActionDemarrer.java FenetreJeu.java ActionCase.java ActionRetourMenu.java ActionSauverQuitter.java ActionReprendre.java ActionFermerFenetre.java Grille.class Quitter.class
-	javac -implicit:none Menu.java NouvellePartie.java ActionDemarrer.java FenetreJeu.java ActionCase.java ActionRetourMenu.java ActionSauverQuitter.java ActionReprendre.java
+	javac -implicit:none Menu.java NouvellePartie.java ActionDemarrer.java FenetreJeu.java ActionCase.java ActionRetourMenu.java ActionSauverQuitter.java ActionReprendre.java ActionFermerFenetre.java
 
 Demineur.class : Demineur.java Menu.class
 	javac -implicit:none Demineur.java

Menu.java

@@ -2,6 +2,10 @@ import javax.swing.*;
 import java.awt.*;
 import java.io.File;
 
+/**
+ * Menu principal de l'application Démineur.
+ * Permet au joueur de lancer une nouvelle partie, de reprendre une partie sauvegardée ou de quitter.
+ */
 public class Menu {
 
     private JFrame fenetre;
@@ -11,7 +15,10 @@ public class Menu {
     private JButton boutonQuitter;
     private GridLayout gestionnaire;
 
-
+    /**
+     * Constructeur du Menu.
+     * Initialise la fenêtre, le panneau et les différents boutons.
+     */
     public Menu() {
         fenetre = new JFrame();
         fenetre.setSize(300,300);
@@ -23,11 +30,11 @@ public class Menu {
         gestionnaire= new GridLayout(3, 1,0,20);
         panneauMenu.setLayout(gestionnaire);
         
-
+        // Les boutons du Menu
-	// Les bouton du Menu
         boutonNouvellePartie = new JButton("Nouvelle partie");
         boutonNouvellePartie.addActionListener(new NouvellePartie(this));
         panneauMenu.add(boutonNouvellePartie);
+        
         boutonReprendre = new JButton("Reprendre");
         File f = new File("sauvegarde.ser");
         if (f.exists()) {
@@ -36,18 +43,18 @@ public class Menu {
             boutonReprendre.setEnabled(false); 
         }
         panneauMenu.add(boutonReprendre);
+        
         boutonQuitter = new JButton("Quitter");
         boutonQuitter.addActionListener(new Quitter());
         panneauMenu.add(boutonQuitter);
 
         fenetre.add(panneauMenu, BorderLayout.CENTER);
-
         fenetre.setVisible(true);
-   
-	
     }
 
-    // cacher le menu quand on lance le jeu
+    /**
-
+     * Permet de récupérer la fenêtre principale du menu pour la masquer/fermer depuis une autre classe.
+     * @return Le JFrame contenant le menu.
+     */
     public JFrame getFenetre() { return fenetre; }
 }

NouvellePartie.java

@@ -3,24 +3,35 @@ import java.awt.event.ActionListener;
 import javax.swing.*;
 import java.awt.*;
 
-// Action pour lance une nouvelle partie
+/**
-
+ * Action déclenchée pour paramétrer une nouvelle partie.
+ * Ouvre une fenêtre demandant au joueur le nombre de lignes, de colonnes et de mines.
+ */
 public class NouvellePartie implements ActionListener {
 
     private Menu menu;
 
+    /**
+     * Constructeur de l'action.
+     * @param m Le menu principal pour pouvoir le fermer par la suite.
+     */
     public NouvellePartie(Menu m) {
         this.menu = m;
     }
 
+    /**
+     * Crée et affiche la fenêtre de configuration.
+     * @param e L'événement du clic.
+     */
     public void actionPerformed(ActionEvent e) {
         JFrame fenetreConfig = new JFrame();
         fenetreConfig.setSize(300, 250);
         fenetreConfig.setLocation(100, 100);
         fenetreConfig.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-	fenetreConfig.setVisible(true);
+        
         GridLayout g = new GridLayout(4, 2);
         fenetreConfig.setLayout(g);
+        
         JTextField champLignes = new JTextField("10");
         JTextField champColonnes = new JTextField("10");
         JTextField champMines = new JTextField("10");
@@ -38,6 +49,5 @@ public class NouvellePartie implements ActionListener {
         demarrer.addActionListener(new ActionDemarrer(champLignes, champColonnes, champMines, fenetreConfig, menu));
         
         fenetreConfig.setVisible(true);
-
     }
 }

Quitter.java

@@ -1,10 +1,15 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
-// Action pour quitter le jeu
+/**
-
+ * Action déclenchée par le bouton "Quitter" du menu principal.
+ */
 public class Quitter implements ActionListener {
 
+    /**
+     * Termine immédiatement l'exécution de l'application.
+     * @param e L'événement du clic.
+     */
     public void actionPerformed(ActionEvent e) {
         System.exit(0);
     }