Petit dictionnaire

Reviewed-on: #6

Makefile

@@ -12,14 +12,26 @@ OUT = bin/
 JC = javac
 JCFLAGS = -encoding UTF-8 -implicit:none -cp $(OUT) -d $(OUT)
 
-CLASSFILES = Pendu.class # \
+CLASSFILES = Pendu.class \
-
+	Partie.class \
+	Fenetre.class \
+	Dessin.class
 
 # Dépendances
-$(OUT)Pendu.class : $(IN)Pendu.java # $(OUT)Fichier.class $(OUT)Cible.class $(OUT)Systeme.class
+$(OUT)Pendu.class : $(IN)Pendu.java $(OUT)Partie.class $(OUT)Fenetre.class
 	$(JC) $(JCFLAGS) $<
 
+$(OUT)Partie.class : $(IN)Partie.java $(OUT)Mots.class
+	$(JC) $(JCFLAGS) $<
 
+$(OUT)Fenetre.class : $(IN)Fenetre.java $(OUT)Partie.class $(OUT)Dessin.class
+	$(JC) $(JCFLAGS) $<
+
+$(OUT)Dessin.class : $(IN)Dessin.java
+	$(JC) $(JCFLAGS) $<
+
+$(OUT)Mots.class : $(IN)Mots.java
+	$(JC) $(JCFLAGS) $<
 
 # Commandes
 Pendu : $(OUT)Pendu.class

src/Dessin.java

@@ -1,23 +1,88 @@
+import javax.swing.*;
+import java.awt.*;
 
 /**
-* La classe <code>Dessin</code>
+* La classe <code>Dessin</code> gère uniquement le dessin du pendu
 *
-* @version
+* @version 1.0
-* @author
+* @author Adrien
-* Date :
+* Date : 08-10-2025
 * Licence :
 */
-public class Dessin {
+public class Dessin extends JPanel {
-   //Attributs
 
-   //Constructeur
+    // --- Constructeur ---
     public Dessin() {
-
+        // Taille préférée pour s'intégrer dans Fenetre
+        setPreferredSize(new Dimension(600, 350));
+        setBackground(new Color(245, 245, 245));
     }
-   //Méthodes
 
-   //Affichage
+    // --- Dessin principal ---
+    @Override
+    protected void paintComponent(Graphics graphics) {
+        super.paintComponent(graphics);
+
+        // Anti-aliasing pour des traits plus doux
+        Graphics2D graphics2D = (Graphics2D) graphics.create();
+        graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        graphics2D.setStroke(new BasicStroke(3f));
+        graphics2D.setColor(Color.DARK_GRAY);
+
+        // Repères et proportions
+        int width = getWidth();
+        int height = getHeight();
+        int marginPixels = Math.min(width, height) / 12; // marge proportionnelle
+
+        // Potence : socle
+        int baseYCoordinate = height - marginPixels;
+        graphics2D.drawLine(marginPixels, baseYCoordinate, width / 2, baseYCoordinate);
+
+        // Montant vertical
+        int postXCoordinate = marginPixels + (width / 12);
+        graphics2D.drawLine(postXCoordinate, baseYCoordinate, postXCoordinate, marginPixels);
+
+        // Traverse horizontale
+        int beamLength = width / 3;
+        graphics2D.drawLine(postXCoordinate, marginPixels, postXCoordinate + beamLength, marginPixels);
+
+        // Renfort diagonal
+        graphics2D.drawLine(postXCoordinate, marginPixels + height / 10, postXCoordinate + width / 12, marginPixels);
+
+        // Corde
+        int ropeXCoordinate = postXCoordinate + beamLength;
+        int ropeTopYCoordinate = marginPixels;
+        int ropeBottomYCoordinate = marginPixels + height / 12;
+        graphics2D.drawLine(ropeXCoordinate, ropeTopYCoordinate, ropeXCoordinate, ropeBottomYCoordinate);
+
+        // Personnage : tête
+        int headRadiusPixels = Math.min(width, height) / 16;
+        int headCenterX = ropeXCoordinate;
+        int headCenterY = ropeBottomYCoordinate + headRadiusPixels;
+        graphics2D.drawOval(headCenterX - headRadiusPixels, headCenterY - headRadiusPixels, headRadiusPixels * 2, headRadiusPixels * 2);
+
+        // Corps
+        int bodyTopYCoordinate = headCenterY + headRadiusPixels;
+        int bodyBottomYCoordinate = bodyTopYCoordinate + height / 6;
+        graphics2D.drawLine(headCenterX, bodyTopYCoordinate, headCenterX, bodyBottomYCoordinate);
+
+        // Bras
+        int armSpanPixels = width / 10;
+        int shouldersYCoordinate = bodyTopYCoordinate + height / 24;
+        graphics2D.drawLine(headCenterX, shouldersYCoordinate, headCenterX - armSpanPixels, shouldersYCoordinate + height / 20);
+        graphics2D.drawLine(headCenterX, shouldersYCoordinate, headCenterX + armSpanPixels, shouldersYCoordinate + height / 20);
+
+        // Jambes
+        int legSpanPixels = width / 12;
+        graphics2D.drawLine(headCenterX, bodyBottomYCoordinate, headCenterX - legSpanPixels, bodyBottomYCoordinate + height / 8);
+        graphics2D.drawLine(headCenterX, bodyBottomYCoordinate, headCenterX + legSpanPixels, bodyBottomYCoordinate + height / 8);
+
+        graphics2D.dispose();
+    }
+
+    // Affichage
+    @Override
     public String toString() {
-      return "" ;
+        return "";
     }
 }

src/Event.java

@@ -0,0 +1,62 @@
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.function.Consumer;
+
+/**
+ * La classe <code>Event</code> regroupe et branche tous les listeners liés à Fenetre.
+ * - Validation de la saisie (1 lettre A-Z, majuscule)
+ * - Action sur Entrée ou clic bouton
+ * - Notification du handler externe (fourni au constructeur)
+ * Aucune logique de jeu ici.
+ * @version 1.3
+ * author Adrien
+ * Date : 08-10-2025
+ */
+public class Event implements ActionListener {
+
+    private final Fenetre window;
+    private final Consumer<Character> onLetterSubmitted;
+
+    /** Constructeur : conserve les références et branche les événements. */
+    public Event(Fenetre window, Consumer<Character> onLetterSubmitted) {
+        this.window = window;
+        this.onLetterSubmitted = onLetterSubmitted;
+        wireEvents();
+    }
+
+    /** Branche les listeners sur les composants de Fenetre. */
+    private void wireEvents() {
+        JTextField letterInput = window.getLetterInput();
+        JButton sendButton = window.getSendButton();
+
+        // Même listener (this) pour Entrée et clic bouton
+        sendButton.addActionListener(this);
+        letterInput.addActionListener(this);
+
+        // 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. */
+    @Override
+    public void actionPerformed(ActionEvent actionEvent) {
+        JTextField letterInput = window.getLetterInput();
+
+        String inputText = letterInput.getText().trim().toUpperCase();
+        letterInput.setText(""); // reset du champ après tentative
+
+        // Validation : exactement une lettre A–Z
+        if (inputText.length() != 1 || !inputText.matches("[A-Z]")) {
+            JOptionPane.showMessageDialog(window.getWindow(), "Veuillez entrer une seule lettre (A-Z).");
+            return;
+        }
+
+        // Notification du handler externe, sinon placeholder
+        if (onLetterSubmitted != null) {
+            onLetterSubmitted.accept(inputText.charAt(0));
+        } else {
+            JOptionPane.showMessageDialog(window.getWindow(),
+                    "Lettre soumise (placeholder) : " + inputText);
+        }
+    }
+}

src/Fenetre.java

@@ -1,23 +1,98 @@
+import javax.swing.*;
+import java.awt.*;
+import java.util.function.Consumer;
 
 /**
-* La classe <code>Fenetre</code>
+* La classe <code>Fenetre</code> gère uniquement l'interface graphique :
+* - zone de dessin (assurée par la classe Dessin)
+* - affichage du mot masqué
+* - saisie d'une lettre (les événements sont gérés dans Event)
 *
-* @version
+* Aucune logique de jeu ici.
-* @author
+* @version 1.5
-* Date :
+* @author Adrien
+* Date : 08-10-2025
 * Licence :
 */
+
 public class Fenetre {
-   //Attributs
 
-   //Constructeur
+    // --- Composants de l'interface ---
+    private JFrame window;
+    private JLabel wordLabel;
+    private JTextField letterInput;
+    private JButton sendButton;
+    private JPanel drawZone; // instance de Dessin
+
+    // --- Constructeur ---
     public Fenetre() {
+        setupWindow();
 
+        JPanel root = new JPanel();
+        root.setLayout(new BoxLayout(root, BoxLayout.Y_AXIS));
+        window.setContentPane(root);
+
+        drawZone = new Dessin();
+        root.add(drawZone);
+
+        wordLabel = createWordLabel();
+        root.add(wordLabel);
+
+        JPanel inputPanel = createInputPanel();
+        root.add(inputPanel);
+
+        window.setVisible(true);
+        letterInput.requestFocusInWindow();
     }
-   //Méthodes
 
-   //Affichage
+    // --- Initialisation fenêtre ---
-   public String toString() {
+    private void setupWindow() {
-      return "" ;
+        window = new JFrame("Jeu du Pendu");
+        window.setSize(600, 600);
+        window.setLocationRelativeTo(null);
+        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    }
+
+    // --- Sous-composants UI ---
+    private JLabel createWordLabel() {
+        JLabel label = new JLabel("_ _ _ _ _", SwingConstants.CENTER);
+        label.setFont(new Font("Segoe UI", Font.BOLD, 32));
+        label.setBorder(BorderFactory.createEmptyBorder(20, 10, 20, 10));
+        label.setAlignmentX(Component.CENTER_ALIGNMENT);
+        return label;
+    }
+
+    private JPanel createInputPanel() {
+        JPanel inputPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 10, 10));
+        JLabel prompt = new JLabel("Entrez une lettre :");
+
+        letterInput = new JTextField(2);
+        letterInput.setHorizontalAlignment(JTextField.CENTER);
+        letterInput.setFont(new Font("Segoe UI", Font.BOLD, 24));
+
+        sendButton = new JButton("Envoyer");
+
+        inputPanel.add(prompt);
+        inputPanel.add(letterInput);
+        inputPanel.add(sendButton);
+        return inputPanel;
+    }
+
+    // --- Getters pour Event ---
+    public JFrame getWindow() { return window; }
+    public JTextField getLetterInput() { return letterInput; }
+    public JButton getSendButton() { return sendButton; }
+    public JLabel getWordLabel() { return wordLabel; }
+    public JPanel getDrawZone() { return drawZone; }
+
+    // --- Méthode principale de test ---
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(() -> {
+            Fenetre f = new Fenetre();
+            // On passe le handler directement ici (pas de setOnLetterSubmitted)
+            new Event(f, ch ->
+                JOptionPane.showMessageDialog(f.getWindow(), "Lettre reçue : " + ch + " (sans logique de jeu)")
+            );
+        });
     }
 }

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
+* @version 0.2
-* @author
+* @author Aurélien
-* Date :
+* 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());
+   }
 }