suppression fichier inutil

Makefile

@@ -0,0 +1,27 @@
+# === Configuration ===
+SRC_DIR = src
+OUT_DIR = out
+PACKAGE = fr/iut/Projet
+MAIN_CLASS = fr.iut.Projet.Random_word
+
+# === Règle principale ===
+all: compile run
+
+# === Compilation ===
+compile:
+	@echo "Compilation du projet..."
+	@mkdir -p $(OUT_DIR)
+	@javac -d $(OUT_DIR) $(SRC_DIR)/$(PACKAGE)/Random_word.java
+	@cp $(SRC_DIR)/$(PACKAGE)/Word.txt $(OUT_DIR)/$(PACKAGE)/
+	@echo "Compilation terminée."
+
+# === Exécution ===
+run:
+	@echo "Exécution du programme..."
+	@java -cp $(OUT_DIR) $(MAIN_CLASS)
+
+# === Nettoyage ===
+clean:
+	@echo "Suppression des fichiers compilés..."
+	@rm -rf $(OUT_DIR)
+	@echo "Nettoyage terminé."

src/fr/iut/Projet/Action.java

@@ -0,0 +1,31 @@
+package fr.iut.Projet;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Classe Action représentant la fenêtre principale du jeu "Hanging Man".
+ * Affiche un message de bienvenue.
+ */
+public class Action {
+
+    /**
+     * Constructeur. Crée et affiche la fenêtre du jeu avec un message.
+     */
+    public Action() {
+        // Création de la fenêtre du jeu
+        JFrame gameFrame = new JFrame("Hanging Man");
+        gameFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        gameFrame.setSize(1040, 1000);
+        gameFrame.setLayout(new BorderLayout());
+
+        // Label de bienvenue
+        JLabel label = new JLabel("Bienvenue dans le jeu !");
+        label.setFont(new Font("Arial", Font.BOLD, 28));
+        label.setHorizontalAlignment(SwingConstants.CENTER);
+
+        // Ajouter le label et afficher la fenêtre
+        gameFrame.add(label, BorderLayout.CENTER);
+        gameFrame.setVisible(true);
+    }
+}

src/fr/iut/Projet/Display.java

@@ -0,0 +1,48 @@
+package fr.iut.Projet;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Classe Display représentant le menu principal du jeu "Hanging Man".
+ * Elle affiche le titre et le bouton Play.
+ */
+public class Display {
+
+    /**
+     * Méthode principale. Crée et affiche la fenêtre du menu principal.
+     * @param args Arguments de la ligne de commande (non utilisés)
+     */
+    public static void main(String[] args) {
+        // Création de la fenêtre principale
+        JFrame frame = new JFrame("Hanging Man");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setSize(1040, 1000);
+        frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));
+
+        // Titre du jeu
+        JLabel text = new JLabel("Hanging Man");
+        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));
+
+        // Listener séparé pour gérer le clic sur Play
+        play.addActionListener(new PlayButtonListener(frame));
+
+        // Ajouter les composants avec de l'espace
+        frame.add(Box.createVerticalGlue());
+        frame.add(text);
+        frame.add(Box.createVerticalStrut(30));
+        frame.add(play);
+        frame.add(Box.createVerticalGlue());
+
+        // Affichage de la fenêtre
+        frame.setVisible(true);
+    }
+}

src/fr/iut/Projet/PlayButtonListener.java

@@ -0,0 +1,35 @@
+package fr.iut.Projet;
+
+import javax.swing.*;
+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
+ * et ferme la fenêtre principale.
+ */
+public class PlayButtonListener implements ActionListener {
+
+    /** Référence à la fenêtre principale du menu */
+    private JFrame parentFrame;
+
+    /**
+     * Constructeur de PlayButtonListener.
+     * @param frame La fenêtre principale à fermer après ouverture du jeu
+     */
+    public PlayButtonListener(JFrame frame) {
+        this.parentFrame = frame;
+    }
+
+    /**
+     * Méthode appelée lorsque le bouton est cliqué.
+     * Ouvre la fenêtre du jeu 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
+    }
+}

src/fr/iut/Projet/Random_word.java

@@ -0,0 +1,136 @@
+package fr.iut.Projet;
+
+import java.io.*;
+import java.util.*;
+
+public class Random_word {
+
+    public static void main(String[] args) {
+        // Récupère un mot aléatoire depuis le fichier Word.txt
+        String randomword = getRandomWord();
+
+        if (randomword == null) {
+            System.err.println("Impossible de choisir un mot aléatoire !");
+            return;
+        }
+
+        // Démarre le jeu avec le mot choisi
+        play(randomword);
+    }
+
+    /**
+     * Lit les mots dans "Word.txt" et retourne un mot aléatoire.
+     * @return un mot aléatoire en minuscules, ou null si le fichier est introuvable ou vide
+     */
+    public static String getRandomWord() {
+        // Charge le fichier Word.txt depuis le package
+        InputStream is = Random_word.class.getResourceAsStream("Word.txt");
+
+        if (is == null) {
+            System.err.println("Le fichier 'Word.txt' est introuvable dans le package !");
+            return null;
+        }
+
+        String randomWord = null;
+        Random random = new Random();
+
+        try (BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(is))) {
+            String line;
+            int count = 0;
+            // Parcourt chaque ligne du fichier
+            while ((line = bufferedreader.readLine()) != null) {
+                line = line.trim();
+                if (!line.isEmpty()) {
+                    count++;
+                    // Sélection aléatoire d'un mot (méthode reservoir sampling)
+                    if (random.nextInt(count) == 0) {
+                        randomWord = line;
+                    }
+                }
+            }
+        } catch (IOException e) {
+            System.err.println("Erreur lors de la lecture du fichier : " + e.getMessage());
+        }
+
+        return randomWord != null ? randomWord.toLowerCase() : null;
+    }
+
+    /**
+     * Affiche l'état actuel du mot et les lettres incorrectes.
+     * @param hiddenWord le mot masqué avec les lettres découvertes
+     * @param incorrectLetters les lettres déjà essayées mais incorrectes
+     */
+    private static void showwordstatus(char[] hiddenWord, Set<Character> incorrectLetters) {
+        System.out.print("\nMot actuel : ");
+        for (char Character : hiddenWord) {
+            System.out.print(Character + " ");
+        }
+        System.out.println();
+        System.out.println("Lettres incorrectes : " + incorrectLetters);
+    }
+
+    /**
+     * Logique principale du jeu : gère les essais, met à jour l'état du mot,
+     * suit le nombre de vies restantes, et détermine la victoire ou la défaite.
+     * @param secretWord le mot que le joueur doit deviner
+     */
+    public static void play(String secretWord) {
+        Scanner scanner = new Scanner(System.in);
+        Set<Character> lettersGuessed = new HashSet<>();
+        Set<Character> incorrectLetters = new HashSet<>();
+        int lives = 8; // nombre d'essais
+
+        char[] hiddenWord = new char[secretWord.length()];
+        Arrays.fill(hiddenWord, '_');
+
+        System.out.println("Bienvenue dans le jeu du mot mystère !");
+        System.out.println("Le mot contient " + secretWord.length() + " lettres.");
+
+        while (lives > 0) {
+            // Affiche le mot actuel et les lettres incorrectes
+            showwordstatus(hiddenWord, incorrectLetters);
+
+            System.out.print("Entrez une lettre : ");
+            String input = scanner.nextLine().toLowerCase();
+
+            // Vérifie que l'entrée est valide
+            if (input.length() != 1 || !Character.isLetter(input.charAt(0))) {
+                System.out.println("Entrez une seule lettre !");
+                continue;
+            }
+
+            char letter = input.charAt(0);
+
+            // Vérifie si la lettre a déjà été essayée
+            if (lettersGuessed.contains(letter) || incorrectLetters.contains(letter)) {
+                System.out.println("Vous avez déjà essayé cette lettre !");
+                continue;
+            }
+
+            // Vérifie si la lettre fait partie du mot secret
+            if (secretWord.indexOf(letter) >= 0) {
+                lettersGuessed.add(letter);
+                for (int i = 0; i < secretWord.length(); i++) {
+                    if (secretWord.charAt(i) == letter) {
+                        hiddenWord[i] = letter;
+                    }
+                }
+                System.out.println("Bien joué !");
+            } else {
+                // Lettre incorrecte : décrémente le nombre de vies
+                incorrectLetters.add(letter);
+                lives--;
+                System.out.println("Mauvaise lettre ! Il vous reste " + lives + " vies.");
+            }
+
+            // Vérifie si le mot complet a été trouvé
+            if (String.valueOf(hiddenWord).equals(secretWord)) {
+                System.out.println("\nFélicitations ! Vous avez trouvé le mot : " + secretWord);
+                return;
+            }
+        }
+
+        // Le joueur a perdu
+        System.out.println("\nVous avez perdu ! Le mot était : " + secretWord);
+    }
+}