From 385e201e3f167925f4c755113e6aba5ab2174362 Mon Sep 17 00:00:00 2001 From: Tajeddine Date: Sat, 11 Apr 2026 21:18:10 +0200 Subject: [PATCH] java doc et reglage probleme win/lose --- ActionCase.java | 34 ++++-- ActionDemarrer.java | 49 ++++---- ActionFermerFenetre.java | 50 ++++++++ ActionReprendre.java | 14 ++- ActionRetourMenu.java | 11 ++ ActionSauverQuitter.java | 45 ++++--- Case.java | 48 ++++++-- Demineur.java | 11 +- FenetreJeu.java | 252 +++++++++++++++++++++++---------------- Grille.java | 132 ++++++++++++-------- Makefile | 4 +- Menu.java | 75 ++++++------ NouvellePartie.java | 66 +++++----- Quitter.java | 11 +- sauvegarde.ser | Bin 2136 -> 0 bytes 15 files changed, 516 insertions(+), 286 deletions(-) create mode 100644 ActionFermerFenetre.java delete mode 100644 sauvegarde.ser diff --git a/ActionCase.java b/ActionCase.java index 5585b90..192ab46 100644 --- a/ActionCase.java +++ b/ActionCase.java @@ -2,27 +2,38 @@ 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; + 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); - } - // clic gauche - else if (SwingUtilities.isLeftMouseButton(e)) { - fenetreJeu.clicGauche(ligne, colonne); - } + if (SwingUtilities.isRightMouseButton(e)) { + fenetreJeu.clicDroit(ligne, colonne); + } else if (SwingUtilities.isLeftMouseButton(e)) { + fenetreJeu.clicGauche(ligne, colonne); + } } public void mousePressed(MouseEvent e) {} @@ -30,4 +41,3 @@ public class ActionCase implements MouseListener { public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} } - diff --git a/ActionDemarrer.java b/ActionDemarrer.java index b4f6f11..70769e8 100644 --- a/ActionDemarrer.java +++ b/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,34 +14,40 @@ public class ActionDemarrer implements ActionListener { private JFrame cible; private Menu menuPrincipal; - - 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; - + /** + * 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(); - String sMines = champMines.getText(); - - try { + String sLignes = champLignes.getText(); + String sColonnes = champColonnes.getText(); + String sMines = champMines.getText(); + + try { int l = Integer.parseInt(sLignes); 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; @@ -49,8 +58,7 @@ public class ActionDemarrer implements ActionListener { g.calculerToutesLesMines(); 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"); } } - } diff --git a/ActionFermerFenetre.java b/ActionFermerFenetre.java new file mode 100644 index 0000000..2b4d6ed --- /dev/null +++ b/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) {} +} diff --git a/ActionReprendre.java b/ActionReprendre.java index e31a8b4..4720edd 100644 --- a/ActionReprendre.java +++ b/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) { diff --git a/ActionRetourMenu.java b/ActionRetourMenu.java index f38c69f..4552059 100644 --- a/ActionRetourMenu.java +++ b/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(); diff --git a/ActionSauverQuitter.java b/ActionSauverQuitter.java index 8f9214d..d1f9f9c 100644 --- a/ActionSauverQuitter.java +++ b/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) { - try { - FileOutputStream fichier = new FileOutputStream("sauvegarde.ser"); - ObjectOutputStream flux = new ObjectOutputStream(fichier); - - 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()); + 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 avec succès !"); + } catch (IOException ex) { + System.out.println("Erreur lors de la sauvegarde : " + ex.getMessage()); + } } + System.exit(0); } } diff --git a/Case.java b/Case.java index 95882fa..0526801 100644 --- a/Case.java +++ b/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,32 +12,52 @@ 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; - this.marqueur = 0; - this.nbMinesautour = 0; + this.estMinee = false; + this.estMineFatale = false; + this.estRevelee = false; + this.marqueur = 0; + 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; } - public boolean getEstMineFatale() {return estMineFatale; } - public void setEstMineFatale(boolean b) {this.estMineFatale = b;} + /** @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) - } + if (!estRevelee) { + marqueur = (marqueur + 1) % 3; + } } + /** @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; } } diff --git a/Demineur.java b/Demineur.java index 8b05b2b..f1c902a 100644 --- a/Demineur.java +++ b/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(); - + Menu menu = new Menu(); } } diff --git a/FenetreJeu.java b/FenetreJeu.java index a43fc5b..d39c1f0 100644 --- a/FenetreJeu.java +++ b/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,67 +13,72 @@ 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(); + this.grille = g; + int l = grille.getLigne(); + int c = grille.getColonne(); - fenetre = new JFrame("Demineur"); - fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + fenetre = new JFrame("Demineur"); + 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]; + 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)); + boutons[i][j].addMouseListener(new ActionCase(this, i, j)); + panneauGrille.add(boutons[i][j]); + } + } - 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]); - } - } - - fenetre.setLayout(new BorderLayout()); + fenetre.setLayout(new BorderLayout()); fenetre.add(panneauGrille, BorderLayout.CENTER); - // Panneau de contrôle en bas + // Panneau de contrôle en bas JPanel panneauBas = new JPanel(); panneauBas.setLayout(new BorderLayout()); 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.addActionListener(new ActionSauverQuitter(grille)); + boutonSauver = new JButton("Sauver et Quitter"); + boutonSauver.addActionListener(new ActionSauverQuitter(this)); conteneurBoutons.add(boutonMenu); conteneurBoutons.add(boutonSauver); panneauBas.add(labelStatut, BorderLayout.NORTH); panneauBas.add(conteneurBoutons, BorderLayout.SOUTH); - - fenetre.add(panneauBas, BorderLayout.SOUTH); - + + fenetre.add(panneauBas, BorderLayout.SOUTH); + fenetre.pack(); fenetre.setLocationRelativeTo(null); fenetre.setVisible(true); 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,113 +93,151 @@ 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++){ - int vL = l + i; - int vC = c + j; - revelerCaseProche(vL,vC); - } - } - - } + 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++){ + int vL = l + i; + int vC = c + j; + 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(){ - for(int i =0; i 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)"); + } } - - - - - - - - - } - diff --git a/Grille.java b/Grille.java index 63b654e..aba6600 100644 --- a/Grille.java +++ b/Grille.java @@ -1,70 +1,102 @@ 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 int ligne, colonne; private Random generateur = new Random(); + private int nbMinesTotales; - public Grille(int ligne,int colonne) { - this.ligne = ligne; + /** + * 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; - this.grille = new Case[ligne][colonne]; - for(int i =0;i= 0 && vL < ligne && vC >= 0 && vC < colonne){ - if (grille[vL][vC].getEstMinee()) { - compteur++; - } - - } - - + this.grille = new Case[ligne][colonne]; + for(int i = 0; i < ligne; i++) { + for(int j = 0; j < colonne; j++) { + this.grille[i][j] = new Case(); } } - grille[l][c].setNbMinesautour(compteur); } - public void calculerToutesLesMines(){ - for(int i =0;i= 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. */ public int getLigne() { return ligne; } + + /** @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]; } - } diff --git a/Makefile b/Makefile index a9932ab..e7c483a 100644 --- a/Makefile +++ b/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 - javac -implicit:none Menu.java NouvellePartie.java ActionDemarrer.java FenetreJeu.java ActionCase.java ActionRetourMenu.java ActionSauverQuitter.java ActionReprendre.java +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 ActionFermerFenetre.java Demineur.class : Demineur.java Menu.class javac -implicit:none Demineur.java diff --git a/Menu.java b/Menu.java index 67063f0..aadf7b5 100644 --- a/Menu.java +++ b/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,43 +15,46 @@ 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); - fenetre.setLocation(100,100); - fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - - panneauMenu = new JPanel(); - panneauMenu.setBorder(BorderFactory.createEmptyBorder(50, 50, 50, 50)); - gestionnaire= new GridLayout(3, 1,0,20); - panneauMenu.setLayout(gestionnaire); - + fenetre = new JFrame(); + fenetre.setSize(300,300); + fenetre.setLocation(100,100); + fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + panneauMenu = new JPanel(); + panneauMenu.setBorder(BorderFactory.createEmptyBorder(50, 50, 50, 50)); + gestionnaire= new GridLayout(3, 1,0,20); + panneauMenu.setLayout(gestionnaire); + + // Les boutons 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()) { + boutonReprendre.addActionListener(new ActionReprendre(this)); + } else { + boutonReprendre.setEnabled(false); + } + panneauMenu.add(boutonReprendre); + + boutonQuitter = new JButton("Quitter"); + boutonQuitter.addActionListener(new Quitter()); + panneauMenu.add(boutonQuitter); - // 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()) { - boutonReprendre.addActionListener(new ActionReprendre(this)); - }else { - 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); - - + 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; } } diff --git a/NouvellePartie.java b/NouvellePartie.java index d22000d..a2414fb 100644 --- a/NouvellePartie.java +++ b/NouvellePartie.java @@ -3,41 +3,51 @@ 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; + 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"); - JButton demarrer = new JButton("Démarrer"); - - fenetreConfig.add(new JLabel("Ligne")); - fenetreConfig.add(champLignes); - fenetreConfig.add(new JLabel("Colonne")); - fenetreConfig.add(champColonnes); - fenetreConfig.add(new JLabel("Nb Mine")); - fenetreConfig.add(champMines); - fenetreConfig.add(new JLabel(" ")); - fenetreConfig.add(demarrer); - - demarrer.addActionListener(new ActionDemarrer(champLignes, champColonnes, champMines, fenetreConfig, menu)); - - fenetreConfig.setVisible(true); - + JFrame fenetreConfig = new JFrame(); + fenetreConfig.setSize(300, 250); + fenetreConfig.setLocation(100, 100); + fenetreConfig.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); + + GridLayout g = new GridLayout(4, 2); + fenetreConfig.setLayout(g); + + JTextField champLignes = new JTextField("10"); + JTextField champColonnes = new JTextField("10"); + JTextField champMines = new JTextField("10"); + JButton demarrer = new JButton("Démarrer"); + + fenetreConfig.add(new JLabel("Ligne")); + fenetreConfig.add(champLignes); + fenetreConfig.add(new JLabel("Colonne")); + fenetreConfig.add(champColonnes); + fenetreConfig.add(new JLabel("Nb Mine")); + fenetreConfig.add(champMines); + fenetreConfig.add(new JLabel(" ")); + fenetreConfig.add(demarrer); + + demarrer.addActionListener(new ActionDemarrer(champLignes, champColonnes, champMines, fenetreConfig, menu)); + + fenetreConfig.setVisible(true); } } diff --git a/Quitter.java b/Quitter.java index ffcebea..7a64af9 100644 --- a/Quitter.java +++ b/Quitter.java @@ -1,11 +1,16 @@ 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); + System.exit(0); } } diff --git a/sauvegarde.ser b/sauvegarde.ser deleted file mode 100644 index 5ac8bc8e9ba364d338c22ecd7c201db5a29fc5a7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2136 zcmZ4UmVvdnh=I+$C^IJ~l{>+4Y02(?kC_-)JQ>)N^KFfed| zaB&fX07#1-NQ)jsia5LO64C7&L#&i)(4@?DaUtt(ZgcH$oDV974a{z|% za2LT;U