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/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);
+    }
+}