Petit dictionnaire

Reviewed-on: #6

Makefile

@@ -21,7 +21,7 @@ CLASSFILES = Pendu.class \
 $(OUT)Pendu.class : $(IN)Pendu.java $(OUT)Partie.class $(OUT)Fenetre.class
 	$(JC) $(JCFLAGS) $<
 
-$(OUT)Partie.class : $(IN)Partie.java
+$(OUT)Partie.class : $(IN)Partie.java $(OUT)Mots.class
 	$(JC) $(JCFLAGS) $<
 
 $(OUT)Fenetre.class : $(IN)Fenetre.java $(OUT)Partie.class $(OUT)Dessin.class
@@ -30,6 +30,9 @@ $(OUT)Fenetre.class : $(IN)Fenetre.java $(OUT)Partie.class $(OUT)Dessin.class
 $(OUT)Dessin.class : $(IN)Dessin.java
 	$(JC) $(JCFLAGS) $<
 
+$(OUT)Mots.class : $(IN)Mots.java
+	$(JC) $(JCFLAGS) $<
+
 # Commandes
 Pendu : $(OUT)Pendu.class
 

src/Event.java

@@ -24,7 +24,7 @@ public class Event implements ActionListener {
         wireEvents();
     }
 
-    /** Branche les listeners sur les composants de Fenetre.*/
+    /** Branche les listeners sur les composants de Fenetre. */
     private void wireEvents() {
         JTextField letterInput = window.getLetterInput();
         JButton sendButton = window.getSendButton();
@@ -33,18 +33,8 @@ public class Event implements ActionListener {
         sendButton.addActionListener(this);
         letterInput.addActionListener(this);
 
-        // UX : limiter à une seule lettre et forcer la majuscule
-        letterInput.addKeyListener(new KeyAdapter() {
-            @Override
-            public void keyTyped(KeyEvent keyEvent) {
-                char typedChar = keyEvent.getKeyChar();
-                if (!Character.isLetter(typedChar) || letterInput.getText().length() >= 1) {
-                    keyEvent.consume();
-                } else {
-                    keyEvent.setKeyChar(Character.toUpperCase(typedChar));
-                }
-            }
-        });
+        // UX : limiter à une seule lettre et forcer la majuscule (classe dédiée)
+        letterInput.addKeyListener(new LetterInputFilter(letterInput));
     }
 
     /** Réagit à Entrée ou au clic bouton : récupère, valide et transmet la lettre. */

src/LetterInputFilter.java

@@ -0,0 +1,47 @@
+import javax.swing.*;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+
+/**
+ * La classe <code>LetterInputFilter</code> limite la saisie d'un champ texte
+ * à une seule lettre de l'alphabet (A–Z), en forçant automatiquement
+ * la majuscule. Toute autre frappe est ignorée.
+ *
+ * @version 1.0
+ * @author Adrien
+ * Date : 08-10-2025
+ * Licence :
+ */
+public class LetterInputFilter extends KeyAdapter {
+
+    /** Référence vers le champ de saisie à filtrer. */
+    private final JTextField letterInput;
+
+    //Constructeur.
+    public LetterInputFilter(JTextField letterInput) {
+        if (letterInput == null) {
+            throw new NullPointerException("letterInput ne doit pas être null");
+        }
+        this.letterInput = letterInput;
+    }
+
+    /**
+     * Intercepte les frappes clavier et applique les règles suivantes :
+     * - n'accepte que les lettres (A–Z) 
+     * - limite la saisie à un seul caractère 
+     * - force la majuscule sur le caractère saisi.
+     */
+    @Override
+    public void keyTyped(KeyEvent keyEvent) {
+        char typedChar = keyEvent.getKeyChar();
+
+        // Refuse tout caractère non alphabétique ou une saisie > 1 caractère.
+        if (!Character.isLetter(typedChar) || letterInput.getText().length() >= 1) {
+            keyEvent.consume(); // ignore la frappe
+            return;
+        }
+
+        // Force la majuscule.
+        keyEvent.setKeyChar(Character.toUpperCase(typedChar));
+    }
+}

src/Mots.java

@@ -0,0 +1,58 @@
+
+/**
+* La classe <code>Mots</code>
+*
+* @version 1.0
+* @author Aurélien
+* Date : 08-10-25
+* Licence :
+*/
+public final class Mots {
+   //Attributs
+   public static final short dictionarysize = 32 ;
+   public static final String[] dictionary = {
+      "Magnifique",
+      "Etoile",
+      "Voyage",
+      "Biscuit",
+      "Refrigerateur",
+      "Courage",
+      "Avion",
+      "Explorateur",
+      "Montagne",
+      "Philosophie",
+      "Lumiere",
+      "Ethernet",
+      "Architecture",
+      "Ocean",
+      "Liberte",
+      "Aventure",
+      "Cerise",
+      "Harmonieux",
+      "Informatique",
+      "Pluie",
+      "Equilibriste",
+      "Papillon",
+      "Saisons",
+      "Liberte",
+      "Alphabet",
+      "Musique",
+      "Translucent",
+      "Passion",
+      "Etreindre",
+      "Poetique",
+      "Serenite",
+      "Révolution"
+   };
+
+   //Constructeur
+   private Mots() {  //N'a pas pour but d'être instanciée
+      throw new UnsupportedOperationException("The \"Fichier\" class cannot be instanced !");
+   }
+   //Méthodes
+
+   //Affichage
+   public String toString() {
+      return "" ;
+   }
+}

src/Partie.java

@@ -1,23 +1,135 @@
+import java.util.Random;
 
 /**
 * La classe <code>Partie</code>
 *
-* @version
-* @author
-* Date :
+* @version 0.2
+* @author Aurélien
+* Date : 08-10-25
 * Licence :
 */
 public class Partie {
+   //Contantes
+   private static final byte REMAININGTRY = 11 ;
+   private static final byte CARACTERCODESHIFT = 65 ;  //Décalage ASCI > 'A'
+
    //Attributs
+   private char[] secretword ;
+   private byte wordsize ;
+   private boolean[] foundletters ;
+   private boolean[] entriesletters = new boolean[26] ;  //Pseudo Alphabée
+   private byte remainingtry = REMAININGTRY ;
 
    //Constructeur
    public Partie() {
-
+      this.secretword = generateSecretWord() ;
+      this.wordsize = (byte) secretword.length ;
+      this.foundletters = new boolean[wordsize] ;
    }
    //Méthodes
+   public char[] getSecretWord() {
+      return this.secretword ;
+   }
+
+   public boolean[] getFoundLetters() {
+      return this.foundletters ;
+   }
+
+   public byte getRemainingTry() {
+      return this.remainingtry ;
+   }
+
+
+   /**
+    * Vérifie l'état de la partie en cours.
+    * 
+    * @return true si le jeu est fini.
+    */
+   public boolean gameIsEnding() {
+      if(this.remainingtry <= 0){
+         return true ;
+      }else if(wordIsFound()){
+         return true ;
+      }else{
+         return false ;
+      }
+   }
+
+   /**
+    * Vérifie si la lettre reçu n'a pas déjà été joué puis, met à jour le tableau "entriesletters" et
+    * "foundletters" le cas échéant.
+    * 
+    * @return true si la lettre était déjà présente.
+    */
+   public boolean isAlreadyEntries(char letter) {
+      short caractercode = (short) letter ;  //Récupération du code du caractère
+      if(this.entriesletters[caractercode-CARACTERCODESHIFT]){
+         this.remainingtry-- ;  //Décrément des essais
+         return true ;
+      }else{
+         boolean isfind = false ;
+         for(byte i = 0 ; i < this.wordsize ; i++){  //Parcours du "secretword"
+            if(this.secretword[i] == letter){
+               this.foundletters[i] = true ;
+               isfind = true ;
+            }
+         }
+         if(isfind == false){
+            this.remainingtry-- ;  //Décrément des essais
+         }
+         this.entriesletters[caractercode-CARACTERCODESHIFT] = true ;  //Ajout au tableau des lettres jouées
+         return false ;
+      }
+   }
+
+   /**
+    * Génère un mot à partir d'un grand dictionnaire (enfin en principe).
+    * 
+    * @return le mot généré.
+    */
+   private char[] generateSecretWord() {
+      Random random = new Random();
+      byte grain = (byte) random.nextInt(Mots.dictionarysize);
+      char[] word = Mots.dictionary[grain].toUpperCase().toCharArray();
+      return word ;
+   }
+
+   private boolean wordIsFound() {
+      for(byte i = 0 ; i < this.wordsize ; i++){  //Parcours du "secretword"
+         if(!this.foundletters[i]){  //Si une lettre n'est pas trouvé
+            return false ;
+         }
+      }
+      return true ;
+   }
+
 
    //Affichage
    public String toString() {
       return "" ;
    }
+
+   //Tests
+   public static void main(String[] args){
+      char[] test = {'E','O','M','I','E','D','A','Z','N','L','C','R','P','H','T','S'};
+      byte size = (byte) test.length ;
+      boolean status ;
+
+      Partie game = new Partie();
+      System.out.println("Trick > " + String.valueOf(game.secretword) + "\n");
+      for(byte i = 0 ; i < size && !game.gameIsEnding() ; i++){
+         System.out.println("Essais restants : " + game.getRemainingTry());
+         status = game.isAlreadyEntries(test[i]);
+         for(byte l = 0 ; l < game.wordsize ; l++){  //Parcours du "secretword"
+            if(game.foundletters[l] == true){
+               System.out.print(game.getSecretWord()[l] + " ");
+            }else{
+               System.out.print("_ ");
+            }
+         }
+         System.out.println("");  //Lisibilité
+         //System.out.println("Lettres : " + game.entriesletters);
+      }
+      System.out.println("Essais restants : " + game.getRemainingTry());
+   }
 }