ajout du score et limite du temps

src/fr/iut/Projet/Action.java

@@ -6,116 +6,100 @@ import java.awt.*;
 /**
  * Classe principale qui gère l'interface graphique du jeu du pendu.
  * 
- * Cette classe crée la fenêtre du jeu et affiche :
+ * Affiche le mot caché, les lettres incorrectes, le dessin du pendu, le timer et le score.
- *  - le mot caché avec les lettres devinées,
+ * Gère également les interactions avec le joueur, la fin de partie et le redémarrage.
- *  - les lettres incorrectes,
- *  - le dessin du pendu (via {@link Affiche}),
- *  - le timer affiché en haut à droite (via {@link GameTimer}),
- * et permet à l'utilisateur de saisir des lettres.
- * Elle gère également :
- *  - la logique de mise à jour de l'interface,
- *  - la fin de partie,
- *  - le redémarrage,
- *  - et le changement de difficulté en utilisant {@link PlayButtonListener}.
  */
 public class Action {
 
-    /** Fenêtre principale du jeu */
+    private Score score;
     private JFrame gameFrame;
-
-    /** Label affichant le mot caché avec les lettres découvertes */
     private JLabel wordLabel;
-
-    /** Label affichant les lettres incorrectes devinées par le joueur */
     private JLabel incorrectLettersLabel;
-
-    /** Champ de texte pour saisir une lettre */
     private JTextField letterInputField;
-
-    /** Instance de la logique du jeu (mot secret, lettres, vies, etc.) */
     private Random_word game;
-
-    /** Composant graphique représentant le pendu */
     private Affiche affiche;
-
-    /** Timer qui compte le temps écoulé depuis le début du mot */
     private GameTimer gameTimer;
-
-    /** Niveau de difficulté courant ("facile", "moyen", "difficile", "hell") */
     private String difficulty;
 
     /**
-     * Constructeur : initialise le jeu avec la difficulté choisie,
+     * Constructeur : initialise le jeu selon la difficulté choisie,
-     * crée les composants graphiques et démarre le timer.
+     * crée tous les composants graphiques et démarre le timer.
-     *
+     * @param difficulty Niveau de difficulté ("facile", "moyen", "difficile", "hell")
-     * @param difficulty Niveau de difficulté pour le mot à deviner
      */
     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
+        // Initialisation
         initializeComponents();
         layoutComponents();
+        setupListeners();
 
-        // Gestion de la saisie utilisateur
+        // Démarre le timer et affiche la fenêtre
-        letterInputField.addActionListener(e -> handleGuess());
-
-        // Démarre le timer dès l'ouverture de la partie
         gameTimer.start();
-
-        // Affiche la fenêtre du jeu
         gameFrame.setVisible(true);
     }
 
-    // ==================== Initialisation des composants ====================
+    // ==================== Initialisation ====================
 
-    /**
+    /** Initialise les composants principaux : fenêtre, jeu, timer et score */
-     * Initialise tous les composants graphiques du jeu :
-     *  - fenêtre principale
-     *  - dessin du pendu
-     *  - labels pour le mot et les lettres incorrectes
-     *  - champ de saisie
-     *  - timer
-     */
     private void initializeComponents() {
+        initializeFrameAndPanels();
+        initializeGameComponents();
+        initializeTimerAndScore();
+    }
+
+    /** Initialise la fenêtre principale */
+    private void initializeFrameAndPanels() {
         gameFrame = new JFrame("Hanging Man - " + difficulty);
         gameFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         gameFrame.setSize(700, 500);
+    }
 
-        // Composant graphique pour dessiner le pendu
+    /** Initialise les composants du jeu : pendu, mot caché, lettres incorrectes, champ de saisie */
+    private void initializeGameComponents() {
         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));
+    }
 
-        // Création du timer
+    /** Initialise le timer et le score, avec un listener pour diminuer le score chaque seconde */
+    private void initializeTimerAndScore() {
         gameTimer = new GameTimer();
+        score = new Score();
+
+        // Listener pour diminuer le score chaque seconde et finir après 60s
+        gameTimer.setTimerListener(() -> {
+            score.decreaseBySecond(); // comportement normal selon le temps
+
+            // Si 60 secondes écoulées et que la partie n'est pas finie
+            if (gameTimer.getSecondsElapsed() >= 60 && !game.isGameOver()) {
+                score.setScoreToZero(); // on met le score à 0
+                endGame("Temps écoulé ! Vous avez perdu !");
+            }
+        });
+    }
+
+    /** Ajoute les listeners sur les composants */
+    private void setupListeners() {
+        letterInputField.addActionListener(e -> handleGuess());
     }
 
     // ==================== Mise en page ====================
 
-    /**
+    /** Organise la mise en page globale (BorderLayout : gauche pendu, droite info et saisie) */
-     * Crée la mise en page principale avec un BorderLayout :
-     *  - panneau gauche : dessin du pendu
-     *  - panneau droit : mot, lettres incorrectes, champ de saisie, boutons et timer
-     */
     private void layoutComponents() {
         JPanel mainPanel = new JPanel(new BorderLayout());
         mainPanel.add(createLeftPanel(), BorderLayout.WEST);
@@ -130,15 +114,7 @@ public class Action {
         return leftPanel;
     }
 
-    /**
+    /** Crée le panneau droit avec mot, lettres incorrectes, saisie, boutons et timer/score */
-     * Crée le panneau droit avec tous les éléments :
-     *  - mot caché
-     *  - lettres incorrectes
-     *  - champ de saisie
-     *  - bouton restart
-     *  - bouton changement de difficulté
-     *  - timer en haut à droite
-     */
     private JPanel createRightPanel() {
         JPanel rightPanel = new JPanel(new GridBagLayout());
         GridBagConstraints gbc = new GridBagConstraints();
@@ -146,51 +122,58 @@ public class Action {
         gbc.fill = GridBagConstraints.BOTH;
         gbc.insets = new Insets(5, 5, 5, 5);
 
-        // Mot caché
+        addWordAndIncorrectLetters(rightPanel, gbc);
-        gbc.gridy = 0;
+        addInputRow(rightPanel, gbc);
-        gbc.weighty = 1.0;
+        addButtons(rightPanel, gbc);
-        rightPanel.add(wordLabel, gbc);
+        addTimerAndScore(rightPanel, gbc);
-
-        // Lettres incorrectes
-        gbc.gridy = 1;
-        rightPanel.add(incorrectLettersLabel, gbc);
-
-        // Champ de saisie
-        gbc.gridy = 2;
-        JPanel inputRow = new JPanel();
-        inputRow.add(new JLabel("Enter a letter:"));
-        inputRow.add(letterInputField);
-        rightPanel.add(inputRow, gbc);
-
-        // Bouton restart
-        gbc.gridy = 3;
-        JButton restartButton = new JButton("Restart");
-        restartButton.addActionListener(e -> restartGame());
-        rightPanel.add(restartButton, gbc);
-
-        // Bouton changement de difficulté
-        gbc.gridy = 4;
-        JButton changeDifficultyButton = new JButton("Changer la difficulté");
-        changeDifficultyButton.addActionListener(e -> showDifficultyDialog());
-        rightPanel.add(changeDifficultyButton, gbc);
-
-        // Timer en haut à droite
-        gbc.gridy = 5;
-        gbc.anchor = GridBagConstraints.NORTHEAST;
-        rightPanel.add(gameTimer.getTimerLabel(), gbc);
 
         return rightPanel;
     }
 
+    /** Ajoute le mot caché et les lettres incorrectes dans le panneau */
+    private void addWordAndIncorrectLetters(JPanel panel, GridBagConstraints gbc) {
+        gbc.gridy = 0;
+        gbc.weighty = 1.0;
+        panel.add(wordLabel, gbc);
+
+        gbc.gridy = 1;
+        panel.add(incorrectLettersLabel, gbc);
+    }
+
+    /** Ajoute le champ de saisie pour les lettres */
+    private void addInputRow(JPanel panel, GridBagConstraints gbc) {
+        gbc.gridy = 2;
+        JPanel inputRow = new JPanel();
+        inputRow.add(new JLabel("Enter a letter:"));
+        inputRow.add(letterInputField);
+        panel.add(inputRow, gbc);
+    }
+
+    /** Ajoute les boutons restart et changement de difficulté */
+    private void addButtons(JPanel panel, GridBagConstraints gbc) {
+        gbc.gridy = 3;
+        JButton restartButton = new JButton("Restart");
+        restartButton.addActionListener(e -> restartGame());
+        panel.add(restartButton, gbc);
+
+        gbc.gridy = 4;
+        JButton changeDifficultyButton = new JButton("Changer la difficulté");
+        changeDifficultyButton.addActionListener(e -> showDifficultyDialog());
+        panel.add(changeDifficultyButton, gbc);
+    }
+
+    /** Ajoute le timer et le score en haut à droite */
+    private void addTimerAndScore(JPanel panel, GridBagConstraints gbc) {
+        gbc.gridy = 5;
+        JPanel topRightPanel = new JPanel(new BorderLayout());
+        topRightPanel.add(gameTimer.getTimerLabel(), BorderLayout.WEST);
+        topRightPanel.add(score.getScoreLabel(), BorderLayout.EAST);
+        panel.add(topRightPanel, gbc);
+    }
+
     // ==================== Gestion des actions ====================
 
-    /**
+    /** Traite la saisie d'une lettre par le joueur */
-     * Traite la saisie d'une lettre par le joueur :
-     *  - vérifie la validité
-     *  - met à jour le mot caché et lettres incorrectes
-     *  - met à jour le pendu
-     *  - termine la partie si nécessaire
-     */
     private void handleGuess() {
         String inputText = letterInputField.getText();
         letterInputField.setText("");
@@ -200,12 +183,27 @@ public class Action {
         char guessedLetter = inputText.charAt(0);
         String message = game.guessLetter(guessedLetter);
 
+        updateScore(message);
         updateUI();
 
-        if (game.isGameOver()) endGame(message);
+        if (game.isGameOver()) {
+            if (game.isWon()) {
+                score.increaseByWordFound();
+            }
+            endGame(message);
+        }
     }
 
-    /** Vérifie que le texte saisi est une seule lettre */
+    /** Met à jour le score selon le résultat de la lettre */
+    private void updateScore(String message) {
+        if (message.contains("Bien joué")) {
+            score.increaseByCorrectLetter();
+        } else if (message.contains("Mauvaise lettre")) {
+            score.decreaseByWrongLetter();
+        }
+    }
+
+    /** Vérifie que la saisie est une seule lettre */
     private boolean isValidInput(String inputText) {
         if (inputText.length() != 1 || !Character.isLetter(inputText.charAt(0))) {
             JOptionPane.showMessageDialog(gameFrame, "Please enter a single letter!");
@@ -214,20 +212,14 @@ public class Action {
         return true;
     }
 
-    /** Met à jour les labels et le dessin du pendu */
+    /** Met à jour l'affichage du mot, des lettres incorrectes et des vies du pendu */
     private void updateUI() {
         wordLabel.setText(game.getHiddenWord());
         incorrectLettersLabel.setText("Incorrect letters: " + game.getIncorrectLetters());
         affiche.setLives(game.getLives());
     }
 
-    /**
+    /** Termine la partie, arrête le timer et affiche le message */
-     * Termine la partie :
-     *  - arrête le timer
-     *  - met à jour le dessin du pendu en cas de victoire/défaite
-     *  - affiche le message de fin
-     *  - désactive le champ de saisie
-     */
     private void endGame(String message) {
         gameTimer.stop();
 
@@ -235,26 +227,24 @@ public class Action {
             affiche.setYouWin(true);
         } else {
             affiche.setLives(0);
+            score.setScoreToZero(); // <- on met le score à 0 en cas de défaite
         }
 
         JOptionPane.showMessageDialog(gameFrame, message);
         letterInputField.setEditable(false);
     }
 
-    /** Redémarre le jeu avec la même difficulté en utilisant PlayButtonListener */
+
+    /** Redémarre le jeu avec la même difficulté */
     private void restartGame() {
         gameFrame.dispose();
         JFrame tempFrame = new JFrame();
         new PlayButtonListener(tempFrame, difficulty).actionPerformed(null);
     }
 
-    /**
+    /** Affiche le dialogue pour changer la difficulté et relance le jeu */
-     * Affiche une boîte de dialogue pour changer la difficulté,
-     * puis relance le jeu avec la nouvelle difficulté.
-     */
     private void showDifficultyDialog() {
         String[] options = {"Facile", "Moyen", "Difficile", "Hell"};
-
         int choice = JOptionPane.showOptionDialog(
                 gameFrame,
                 "Choisissez la difficulté :",
@@ -269,23 +259,12 @@ public class Action {
         if (choice >= 0) {
             String newDifficulty;
             switch (choice) {
-                case 0:
+                case 0: newDifficulty = "facile"; break;
-                    newDifficulty = "facile";
+                case 1: newDifficulty = "moyen"; break;
-                    break;
+                case 2: newDifficulty = "difficile"; break;
-                case 1:
+                case 3: newDifficulty = "hell"; break;
-                    newDifficulty = "moyen";
+                default: newDifficulty = "moyen"; break;
-                    break;
-                case 2:
-                    newDifficulty = "difficile";
-                    break;
-                case 3:
-                    newDifficulty = "hell";
-                    break;
-                default:
-                    newDifficulty = "moyen";
-                    break;
             }
-
             gameFrame.dispose();
             JFrame tempFrame = new JFrame();
             new PlayButtonListener(tempFrame, newDifficulty).actionPerformed(null);

src/fr/iut/Projet/GameTimer.java

@@ -7,8 +7,8 @@ import java.awt.event.ActionListener;
 /**
  * Classe GameTimer qui gère le temps écoulé sur un mot.
  * 
- * Affiche le temps en secondes dans un JLabel et peut être intégré
+ * Affiche le temps en secondes dans un JLabel et peut déclencher un listener
- * à la fenêtre du jeu.
+ * à chaque seconde (par exemple pour réduire le score ou vérifier la limite de temps).
  */
 public class GameTimer {
 
@@ -21,9 +21,10 @@ public class GameTimer {
     /** Compteur de secondes écoulées */
     private int secondsElapsed;
 
-    /**
+    /** Listener appelé à chaque tick (chaque seconde) */
-     * Constructeur : crée le label et initialise le timer.
+    private Runnable timerListener;
-     */
+
+    /** Constructeur : crée le label et initialise le timer */
     public GameTimer() {
         this.secondsElapsed = 0;
         this.timerLabel = new JLabel("Temps : 0 s");
@@ -35,10 +36,20 @@ public class GameTimer {
             public void actionPerformed(ActionEvent e) {
                 secondsElapsed++;
                 timerLabel.setText("Temps : " + secondsElapsed + " s");
+
+                // Appel du listener pour gérer le score ou la fin de partie
+                if (timerListener != null) {
+                    timerListener.run();
+                }
             }
         });
     }
 
+    /** Définit le listener appelé à chaque seconde */
+    public void setTimerListener(Runnable listener) {
+        this.timerListener = listener;
+    }
+
     /** Démarre le timer */
     public void start() {
         secondsElapsed = 0;

src/fr/iut/Projet/Score.java

@@ -0,0 +1,70 @@
+package fr.iut.Projet;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * Classe Score qui gère le score du joueur.
+ * 
+ * Commence à 100, diminue à chaque seconde et à chaque erreur,
+ * augmente à chaque bonne lettre et ajoute un bonus si le mot est trouvé.
+ * Si le joueur perd, le score devient 0.
+ */
+public class Score {
+
+    private int currentScore;
+    private JLabel scoreLabel;
+
+    /** Constructeur : initialise le score à 100 */
+    public Score() {
+        this.currentScore = 100;
+        this.scoreLabel = new JLabel("Score : " + currentScore);
+        this.scoreLabel.setFont(new Font("Arial", Font.BOLD, 16));
+        this.scoreLabel.setHorizontalAlignment(SwingConstants.RIGHT);
+    }
+
+    /** Décrémente le score de 1 point chaque seconde */
+    public void decreaseBySecond() {
+        currentScore = Math.max(0, currentScore - 1);
+        updateLabel();
+    }
+
+    /** Décrémente le score de 5 points pour une mauvaise lettre */
+    public void decreaseByWrongLetter() {
+        currentScore = Math.max(0, currentScore - 5);
+        updateLabel();
+    }
+
+    /** Incrémente le score de 10 points pour une bonne lettre */
+    public void increaseByCorrectLetter() {
+        currentScore += 10;
+        updateLabel();
+    }
+
+    /** Incrémente le score de 50 points si le mot est trouvé */
+    public void increaseByWordFound() {
+        currentScore += 50;
+        updateLabel();
+    }
+
+    /** Met le score à zéro (utilisé si le joueur perd) */
+    public void setScoreToZero() {
+        currentScore = 0;
+        updateLabel();
+    }
+
+    /** Met à jour le texte du JLabel */
+    private void updateLabel() {
+        scoreLabel.setText("Score : " + currentScore);
+    }
+
+    /** @return le JLabel contenant le score */
+    public JLabel getScoreLabel() {
+        return scoreLabel;
+    }
+
+    /** @return le score actuel */
+    public int getCurrentScore() {
+        return currentScore;
+    }
+}