mise en place de hell le vrai difficile

Makefile

@@ -1,6 +1,7 @@
 # === Configuration ===
 SRC_DIR = src
 OUT_DIR = out
+Dictionary = fr/iut/Projet/Dictionary
 PACKAGE = fr/iut/Projet
 MAIN_CLASS = fr.iut.Projet.Display
 
@@ -14,7 +15,8 @@ compile:
 	# Compilation de tous les fichiers Java du package
 	@javac -d $(OUT_DIR) $(SRC_DIR)/$(PACKAGE)/*.java
 	# Copier Word.txt dans le dossier de sortie
-	@cp $(SRC_DIR)/$(PACKAGE)/Word.txt $(OUT_DIR)/$(PACKAGE)/
+	@mkdir -p $(OUT_DIR)/$(Dictionary)
+	@cp $(SRC_DIR)/$(Dictionary)/*.txt $(OUT_DIR)/$(Dictionary)/
 	@echo "Compilation terminée."
 
 # === Exécution ===

src/fr/iut/Projet/Action.java

@@ -5,73 +5,92 @@ import java.awt.*;
 
 /**
  * Classe principale qui gère l'interface graphique du jeu du pendu.
- * <p>
- * Cette classe crée la fenêtre du jeu, affiche le mot caché, les lettres incorrectes,
- * le dessin du pendu (via {@link Affiche}), et permet à l'utilisateur de saisir des lettres.
- * Elle gère également la logique de mise à jour et la fin de partie.
- * </p>
- *
- * @author 
- * @version 1.0
+ * 
+ * Cette classe crée la fenêtre du jeu, affiche :
+ *  - le mot caché avec les lettres devinées,
+ *  - les lettres incorrectes,
+ *  - le dessin du pendu (via {@link Affiche}),
+ * et permet à l'utilisateur de saisir des lettres.
+ * Elle gère également la logique de mise à jour, la fin de partie,
+ * le redémarrage et le changement de difficulté en utilisant {@link PlayButtonListener}.
  */
 public class Action {
 
-    /** Fenêtre principale du jeu. */
+    /** Fenêtre principale du jeu */
     private JFrame gameFrame;
 
-    /** Label affichant le mot caché avec les lettres découvertes. */
+    /** Label affichant le mot caché */
     private JLabel wordLabel;
 
-    /** Label affichant la liste des lettres incorrectes. */
+    /** Label affichant les lettres incorrectes */
     private JLabel incorrectLettersLabel;
 
-    /** Champ de texte permettant à l'utilisateur d'entrer une lettre. */
+    /** Champ de texte pour saisir une lettre */
     private JTextField letterInputField;
 
-    /** Instance du jeu, contenant la logique (mot, vies, lettres, etc.). */
+    /** Instance du jeu avec la logique (mot secret, lettres, vies, etc.) */
     private Random_word game;
 
-    /** Composant graphique qui affiche le dessin du pendu. */
+    /** Composant graphique qui dessine le pendu */
     private Affiche affiche;
 
+    /** Niveau de difficulté courant ("facile", "moyen", "difficile") */
+    private String difficulty;
+
     /**
-     * Constructeur de la classe {@code Action}.
-     * <p>
-     * Initialise le jeu, crée les composants graphiques, met en place la mise en page
-     * et affiche la fenêtre du jeu.
-     * </p>
+     * Constructeur de la classe Action.
+     * Initialise le jeu avec la difficulté choisie, crée et dispose les composants.
+     * 
+     * @param difficulty Niveau de difficulté pour le mot à deviner.
      */
-    public Action() {
-        game = new Random_word();
+    public Action(String difficulty) {
+        this.difficulty = difficulty;
+
+        // Création du jeu avec le mot choisi selon la difficulté
+        game = new Random_word(difficulty);
+
+        // Initialisation des composants graphiques
         initializeComponents();
         layoutComponents();
+
+        // Gestion de la saisie utilisateur
         letterInputField.addActionListener(e -> handleGuess());
+
+        // Affiche la fenêtre
         gameFrame.setVisible(true);
     }
 
-    // ==================== Initialisation ====================
+    // ==================== Initialisation des composants ====================
 
     /**
-     * Initialise tous les composants graphiques (labels, champs, boutons...).
+     * Initialise tous les composants graphiques du jeu :
+     * - fenêtre principale
+     * - dessin du pendu
+     * - labels pour le mot et les lettres incorrectes
+     * - champ de saisie
      */
     private void initializeComponents() {
-        gameFrame = new JFrame("Hanging Man");
+        gameFrame = new JFrame("Hanging Man - " + difficulty);
         gameFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         gameFrame.setSize(700, 500);
 
+        // Composant graphique pour le pendu
         affiche = new Affiche();
         affiche.setPreferredSize(new Dimension(350, 400));
         affiche.setBackground(Color.WHITE);
         affiche.setOpaque(true);
 
+        // Label affichant le mot caché
         wordLabel = new JLabel(game.getHiddenWord());
         wordLabel.setFont(new Font("Arial", Font.BOLD, 32));
         wordLabel.setHorizontalAlignment(SwingConstants.CENTER);
 
+        // Label affichant les lettres incorrectes
         incorrectLettersLabel = new JLabel("Incorrect letters: " + game.getIncorrectLetters());
         incorrectLettersLabel.setFont(new Font("Arial", Font.PLAIN, 20));
         incorrectLettersLabel.setHorizontalAlignment(SwingConstants.CENTER);
 
+        // Champ pour saisir une lettre
         letterInputField = new JTextField(3);
         letterInputField.setFont(new Font("Arial", Font.PLAIN, 24));
     }
@@ -79,29 +98,32 @@ public class Action {
     // ==================== Mise en page ====================
 
     /**
-     * Dispose les composants graphiques dans la fenêtre selon un {@link BorderLayout}.
+     * Dispose tous les composants graphiques dans la fenêtre.
+     * Utilise un BorderLayout principal avec :
+     * - panneau gauche pour le dessin du pendu
+     * - panneau droit pour les interactions utilisateur
      */
     private void layoutComponents() {
         JPanel mainPanel = new JPanel(new BorderLayout());
 
-        // --- panneau gauche : dessin du pendu ---
+        // Panneau gauche : dessin du pendu
         JPanel leftPanel = new JPanel(new BorderLayout());
         leftPanel.add(affiche, BorderLayout.CENTER);
         mainPanel.add(leftPanel, BorderLayout.WEST);
 
-        // --- panneau droit : interface du jeu ---
+        // Panneau droit : interface du jeu (mot, lettres, saisie, boutons)
         JPanel rightPanel = new JPanel(new GridBagLayout());
         GridBagConstraints gbc = new GridBagConstraints();
         gbc.gridx = 0;
         gbc.fill = GridBagConstraints.BOTH;
         gbc.insets = new Insets(5, 5, 5, 5);
 
-        // Mot caché
+        // Label du mot caché
         gbc.gridy = 0;
         gbc.weighty = 1.0;
         rightPanel.add(wordLabel, gbc);
 
-        // Lettres incorrectes
+        // Label des lettres incorrectes
         gbc.gridy = 1;
         rightPanel.add(incorrectLettersLabel, gbc);
 
@@ -115,41 +137,48 @@ public class Action {
         // Bouton de redémarrage
         gbc.gridy = 3;
         JButton restartButton = new JButton("Restart");
-        restartButton.addActionListener(new PlayButtonListener(gameFrame));
+        restartButton.addActionListener(e -> restartGame());
         rightPanel.add(restartButton, gbc);
 
+        // Bouton pour changer la difficulté
+        gbc.gridy = 4;
+        JButton changeDifficultyButton = new JButton("Changer la difficulté");
+        changeDifficultyButton.addActionListener(e -> showDifficultyDialog());
+        rightPanel.add(changeDifficultyButton, gbc);
+
         mainPanel.add(rightPanel, BorderLayout.CENTER);
+
+        // Ajout du panneau principal à la fenêtre
         gameFrame.add(mainPanel);
     }
 
     // ==================== Gestion du jeu ====================
 
     /**
-     * Gère la saisie d'une lettre par le joueur.
-     * <p>
-     * Vérifie la validité de la lettre, met à jour le jeu, l'affichage
-     * et teste si la partie est terminée.
-     * </p>
+     * Traite la saisie d'une lettre par l'utilisateur.
+     * Met à jour l'état du jeu et l'affichage.
      */
     private void handleGuess() {
         String inputText = letterInputField.getText();
-        letterInputField.setText("");
+        letterInputField.setText(""); // efface le champ après saisie
 
         if (!isValidInput(inputText)) return;
 
         char guessedLetter = inputText.charAt(0);
         String message = game.guessLetter(guessedLetter);
 
+        // Mise à jour de l'interface
         updateUI();
 
+        // Si la partie est terminée, affiche le résultat
         if (game.isGameOver()) endGame(message);
     }
 
     /**
-     * Vérifie que la saisie de l'utilisateur est une seule lettre valide.
-     *
-     * @param inputText texte saisi dans le champ de saisie
-     * @return {@code true} si la saisie est valide, {@code false} sinon
+     * Vérifie que l'utilisateur a saisi une seule lettre valide.
+     * 
+     * @param inputText texte saisi
+     * @return true si la saisie est valide
      */
     private boolean isValidInput(String inputText) {
         if (inputText.length() != 1 || !Character.isLetter(inputText.charAt(0))) {
@@ -160,12 +189,7 @@ public class Action {
     }
 
     /**
-     * Met à jour les éléments de l'interface graphique :
-     * <ul>
-     *     <li>le mot affiché,</li>
-     *     <li>les lettres incorrectes,</li>
-     *     <li>et le dessin du pendu selon les vies restantes.</li>
-     * </ul>
+     * Met à jour l'affichage du mot caché, des lettres incorrectes et du dessin du pendu.
      */
     private void updateUI() {
         wordLabel.setText(game.getHiddenWord());
@@ -174,10 +198,10 @@ public class Action {
     }
 
     /**
-     * Termine la partie en affichant un message selon le résultat (victoire ou défaite)
-     * et empêche de nouvelles saisies.
-     *
-     * @param message message à afficher dans une boîte de dialogue
+     * Termine la partie et affiche le message de résultat.
+     * Désactive le champ de saisie.
+     * 
+     * @param message message à afficher (victoire/défaite)
      */
     private void endGame(String message) {
         if (game.isWon()) {
@@ -189,4 +213,69 @@ public class Action {
         JOptionPane.showMessageDialog(gameFrame, message);
         letterInputField.setEditable(false);
     }
-}
+
+    // ==================== Redémarrage ====================
+
+    /**
+     * Redémarre le jeu avec la même difficulté en utilisant PlayButtonListener.
+     */
+    private void restartGame() {
+        gameFrame.dispose();  // ferme la fenêtre actuelle
+
+        // Crée un JFrame temporaire pour utiliser PlayButtonListener
+        JFrame tempFrame = new JFrame();
+        new PlayButtonListener(tempFrame, difficulty).actionPerformed(null);
+        // tempFrame ne sera jamais affiché, il sert juste à passer la référence
+    }
+
+    // ==================== Changement de difficulté ====================
+
+    /**
+     * Affiche une boîte de dialogue pour choisir une nouvelle difficulté
+     * et relance une partie avec cette difficulté en utilisant PlayButtonListener.
+     */
+    private void showDifficultyDialog() {
+        String[] options = {"Facile", "Moyen", "Difficile", "Hell"};
+
+        // Boîte de dialogue avec trois options
+        int choice = JOptionPane.showOptionDialog(
+                gameFrame,
+                "Choisissez la difficulté :",
+                "Changer la difficulté",
+                JOptionPane.DEFAULT_OPTION,
+                JOptionPane.QUESTION_MESSAGE,
+                null,
+                options,
+                options[0]
+        );
+
+        // Si l'utilisateur a choisi une option
+        if (choice >= 0) {
+            String newDifficulty;
+            switch (choice) {
+                case 0:
+                    newDifficulty = "facile";
+                    break;
+                case 1:
+                    newDifficulty = "moyen";
+                    break;
+                case 2:
+                    newDifficulty = "difficile";
+                    break;
+                case 3:
+                    newDifficulty = "hell";
+                    break;
+                default:
+                    newDifficulty = "moyen";
+                    break;
+            }
+
+            // Ferme la fenêtre actuelle
+            gameFrame.dispose();
+
+            // Crée un JFrame temporaire pour utiliser PlayButtonListener
+            JFrame tempFrame = new JFrame();
+            new PlayButtonListener(tempFrame, newDifficulty).actionPerformed(null);
+        }
+    }
+}

src/fr/iut/Projet/Display.java

@@ -5,7 +5,7 @@ import java.awt.*;
 
 /**
  * Classe Display représentant le menu principal du jeu "Hanging Man".
- * Elle affiche le titre et le bouton Play.
+ * Elle affiche le titre et trois boutons de difficulté : Facile, Moyen et Difficile.
  */
 public class Display {
 
@@ -25,24 +25,41 @@ public class Display {
         text.setAlignmentX(Component.CENTER_ALIGNMENT);
         text.setFont(new Font("Arial", Font.BOLD, 70));
 
-        // Bouton Play
-        JButton play = new JButton("Play");
-        play.setAlignmentX(Component.CENTER_ALIGNMENT);
-        play.setPreferredSize(new Dimension(300, 100));
-        play.setMaximumSize(new Dimension(300, 150));
-        play.setFont(new Font("Arial", Font.PLAIN, 36));
+        // Création des boutons de difficulté
+        JButton easyButton = new JButton("Facile");
+        JButton mediumButton = new JButton("Moyen");
+        JButton hardButton = new JButton("Difficile");
+        JButton hellButton = new JButton("Hell");
 
-        // Listener séparé pour gérer le clic sur Play
-        play.addActionListener(new PlayButtonListener(frame));
+        // Mise en forme des boutons
+        JButton[] buttons = { easyButton, mediumButton, hardButton, hellButton};
+        for (JButton button : buttons) {
+            button.setAlignmentX(Component.CENTER_ALIGNMENT);
+            button.setPreferredSize(new Dimension(300, 100));
+            button.setMaximumSize(new Dimension(300, 150));
+            button.setFont(new Font("Arial", Font.PLAIN, 36));
+        }
 
-        // Ajouter les composants avec de l'espace
+        // Ajout d'écouteurs (listeners)
+        easyButton.addActionListener(new PlayButtonListener(frame, "facile"));
+        mediumButton.addActionListener(new PlayButtonListener(frame, "moyen"));
+        hardButton.addActionListener(new PlayButtonListener(frame, "difficile"));
+        hellButton.addActionListener(new PlayButtonListener(frame, "hell"));
+
+        // Ajout des composants à la fenêtre
         frame.add(Box.createVerticalGlue());
         frame.add(text);
-        frame.add(Box.createVerticalStrut(30));
-        frame.add(play);
+        frame.add(Box.createVerticalStrut(50));
+        frame.add(easyButton);
+        frame.add(Box.createVerticalStrut(20));
+        frame.add(mediumButton);
+        frame.add(Box.createVerticalStrut(20));
+        frame.add(hardButton);
+        frame.add(Box.createVerticalStrut(20));
+        frame.add(hellButton);
         frame.add(Box.createVerticalGlue());
 
         // Affichage de la fenêtre
         frame.setVisible(true);
     }
-}
+}

src/fr/iut/Projet/PlayButtonListener.java

@@ -5,8 +5,8 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 /**
- * Classe PlayButtonListener qui gère le clic sur le bouton "Play" du menu.
- * Lorsqu'on clique sur le bouton, cette classe ouvre la fenêtre du jeu
+ * Classe PlayButtonListener qui gère le clic sur les boutons de difficulté.
+ * Lorsqu'on clique sur un bouton, elle ouvre la fenêtre du jeu avec le niveau choisi
  * et ferme la fenêtre principale.
  */
 public class PlayButtonListener implements ActionListener {
@@ -14,22 +14,29 @@ public class PlayButtonListener implements ActionListener {
     /** Référence à la fenêtre principale du menu */
     private JFrame parentFrame;
 
+    /** Niveau de difficulté choisi */
+    private String difficulty;
+
     /**
      * Constructeur de PlayButtonListener.
      * @param frame La fenêtre principale à fermer après ouverture du jeu
+     * @param difficulty Le niveau de difficulté choisi ("facile", "moyen" ou "difficile")
      */
-    public PlayButtonListener(JFrame frame) {
+    public PlayButtonListener(JFrame frame, String difficulty) {
         this.parentFrame = frame;
+        this.difficulty = difficulty;
     }
 
     /**
      * Méthode appelée lorsque le bouton est cliqué.
-     * Ouvre la fenêtre du jeu et ferme la fenêtre principale.
+     * Ouvre la fenêtre du jeu avec la difficulté sélectionnée
+     * et ferme la fenêtre principale.
      * @param e L'événement déclenché par le clic
      */
     @Override
     public void actionPerformed(ActionEvent e) {
-        new Action();        // Ouvre la fenêtre du jeu
-        parentFrame.dispose(); // Ferme la fenêtre principale
+        // Passe la difficulté à la classe Action
+        new Action(difficulty);  
+        parentFrame.dispose(); // Ferme le menu principal
     }
-}
+}

src/fr/iut/Projet/Random_word.java

@@ -3,38 +3,105 @@ package fr.iut.Projet;
 import java.io.*;
 import java.util.*;
 
+/**
+ * Classe gérant la logique du jeu du pendu.
+ * 
+ * Cette classe sélectionne un mot (ou une combinaison de mots) aléatoire
+ * selon la difficulté, conserve l'état du jeu (mot secret, lettres devinées,
+ * lettres incorrectes, nombre de vies) et fournit des méthodes pour deviner
+ * des lettres et vérifier l'état du jeu.
+ */
 public class Random_word {
 
+    /** Mot secret que le joueur doit deviner */
     private String secretWord;
+
+    /** Tableau représentant le mot caché avec les lettres découvertes et espaces */
     private char[] hiddenWord;
+
+    /** Lettres correctement devinées par le joueur */
     private Set<Character> lettersGuessed;
+
+    /** Lettres incorrectes devinées par le joueur */
     private Set<Character> incorrectLetters;
+
+    /** Nombre de vies restantes */
     private int lives;
 
     /**
-     * Constructeur : sélectionne un mot aléatoire et initialise le jeu.
+     * Constructeur : sélectionne un mot aléatoire selon la difficulté
+     * et initialise les structures du jeu.
+     * 
+     * @param difficulty Niveau de difficulté ("facile", "moyen", "difficile", "hell")
+     * @throws RuntimeException si aucun mot n'a pu être choisi
      */
-    public Random_word() {
-        this.secretWord = getRandomWord();
+    public Random_word(String difficulty) {
+        if (difficulty.equalsIgnoreCase("hell")) {
+            // En mode Hell, on choisit deux mots faciles et on les concatène avec un espace
+            String firstWord = getRandomWord("facile");
+            String secondWord = getRandomWord("facile");
+
+            if (firstWord == null || secondWord == null) {
+                throw new RuntimeException("Impossible de choisir deux mots pour le mode Hell !");
+            }
+
+            this.secretWord = firstWord + " " + secondWord;
+        } else {
+            // Pour les autres difficultés, on choisit un seul mot correspondant
+            this.secretWord = getRandomWord(difficulty);
+        }
+
         if (this.secretWord == null) {
             throw new RuntimeException("Impossible de choisir un mot aléatoire !");
         }
-        this.lives = 8;
+
+        this.lives = 8; // nombre de vies par défaut
         this.hiddenWord = new char[secretWord.length()];
-        Arrays.fill(this.hiddenWord, '_');
+
+        // Initialise le mot caché : underscore pour les lettres, espace conservé
+        for (int i = 0; i < secretWord.length(); i++) {
+            hiddenWord[i] = (secretWord.charAt(i) == ' ') ? ' ' : '_';
+        }
+
         this.lettersGuessed = new HashSet<>();
         this.incorrectLetters = new HashSet<>();
     }
 
     /**
-     * Lit les mots dans "Word.txt" et retourne un mot aléatoire.
+     * Lit un fichier de mots correspondant à la difficulté et retourne un mot aléatoire.
+     * 
+     * @param difficulty Niveau de difficulté
+     * @return mot aléatoire en minuscules
      */
-    private String getRandomWord() {
-        InputStream is = Random_word.class.getResourceAsStream("Word.txt");
-        if (is == null) return null;
+    private String getRandomWord(String difficulty) {
+        String fileName;
+
+        // Sélection du fichier selon la difficulté
+        switch (difficulty.toLowerCase()) {
+            case "facile":
+                fileName = "/fr/iut/Projet/Dictionary/EASY-FRENCH.txt";
+                break;
+            case "moyen":
+                fileName = "/fr/iut/Projet/Dictionary/MEDIUM-FRENCH.txt";
+                break;
+            case "difficile":
+                fileName = "/fr/iut/Projet/Dictionary/HARD-FRENCH.txt";
+                break;
+            default:
+                System.out.println("Difficulté inconnue, mode 'moyen' utilisé par défaut.");
+                fileName = "/fr/iut/Projet/Dictionary/MEDIUM-FRENCH.txt";
+        }
+
+        // Récupère le fichier dans les ressources
+        InputStream is = Random_word.class.getResourceAsStream(fileName);
+        if (is == null) {
+            System.err.println("Fichier introuvable : " + fileName);
+            return null;
+        }
 
         String randomWord = null;
         Random random = new Random();
+
         try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
             String line;
             int count = 0;
@@ -42,6 +109,7 @@ public class Random_word {
                 line = line.trim();
                 if (!line.isEmpty()) {
                     count++;
+                    // Choix aléatoire d'une ligne avec Reservoir Sampling
                     if (random.nextInt(count) == 0) {
                         randomWord = line;
                     }
@@ -50,57 +118,77 @@ public class Random_word {
         } catch (IOException e) {
             e.printStackTrace();
         }
+
         return randomWord != null ? randomWord.toLowerCase() : null;
     }
 
     /**
-     * Tente une lettre, met à jour l'état du jeu et retourne un message.
+     * Tente une lettre proposée par le joueur.
+     * Met à jour l'état du jeu (mot caché, lettres incorrectes, vies restantes).
+     * 
+     * @param letter lettre proposée
+     * @return message d'information pour le joueur (succès, erreur ou fin de partie)
      */
     public String guessLetter(char letter) {
         letter = Character.toLowerCase(letter);
+
+        // Vérifie si la lettre a déjà été essayée
         if (lettersGuessed.contains(letter) || incorrectLetters.contains(letter)) {
             return "Vous avez déjà essayé cette lettre !";
         }
 
+        // Lettre correcte
         if (secretWord.indexOf(letter) >= 0) {
             lettersGuessed.add(letter);
+
+            // Remplace les underscores par la lettre devinée
             for (int i = 0; i < secretWord.length(); i++) {
                 if (secretWord.charAt(i) == letter) {
                     hiddenWord[i] = letter;
                 }
             }
+
             if (isWon()) {
                 return "Félicitations ! Vous avez trouvé le mot : " + secretWord;
             }
             return "Bien joué !";
+
         } else {
+            // Lettre incorrecte
             incorrectLetters.add(letter);
             lives--;
+
             if (lives <= 0) {
                 return "Vous avez perdu ! Le mot était : " + secretWord;
             }
+
             return "Mauvaise lettre ! Il vous reste " + lives + " vies.";
         }
     }
 
+    /** @return le mot caché avec les lettres découvertes séparées par des espaces */
     public String getHiddenWord() {
         StringBuilder sb = new StringBuilder();
         for (char c : hiddenWord) sb.append(c).append(' ');
         return sb.toString().trim();
     }
 
+    /** @return la liste des lettres incorrectes devinées */
     public String getIncorrectLetters() {
         return incorrectLetters.toString();
     }
 
+    /** @return nombre de vies restantes */
     public int getLives() {
         return lives;
     }
 
+    /** @return true si le jeu est terminé (victoire ou défaite) */
     public boolean isGameOver() {
         return lives <= 0 || isWon();
     }
 
+    /** @return true si le mot est entièrement deviné */
     public boolean isWon() {
         for (char c : hiddenWord) {
             if (c == '_') {
@@ -110,6 +198,7 @@ public class Random_word {
         return true;
     }
 
+    /** @return le mot secret */
     public String getSecretWord() {
         return secretWord;
     }