javadoc des controlleurs

src/fr/monkhanny/dorfromantik/controller/MainMenuButtonController.java

@@ -9,52 +9,90 @@ import java.awt.event.ActionListener;
 import java.awt.Dimension;
 import java.awt.Point;
 
-
-
+/**
+ * Contrôleur pour gérer les interactions avec les boutons du menu principal.
+ * Ce contrôleur permet de gérer les actions liées aux boutons "Jouer", 
+ * "Comment jouer ?", "Paramètres" et "Quitter" dans le menu principal.
+ *
+ * @version 1.0
+ * @author Moncef STITI, Khalid CHENOUNA
+ */
 public class MainMenuButtonController implements ActionListener {
 
-    private MainMenu mainMenu;
+    /**
+     * Instance du menu principal.
+     */
+    private final MainMenu mainMenu;
 
-    private JFrame settingsFrame;
-    private JFrame howToPlayFrame;
-    private JFrame gameModeFrame;
-    private JFrame gameFrame;
+    /**
+     * Fenêtre des paramètres.
+     */
+    private final JFrame settingsFrame;
 
+    /**
+     * Fenêtre d'aide (Comment jouer ?).
+     */
+    private final JFrame howToPlayFrame;
+
+    /**
+     * Fenêtre de sélection du mode de jeu.
+     */
+    private final JFrame gameModeFrame;
+
+    /**
+     * Fenêtre du jeu.
+     */
+    private final JFrame gameFrame;
+
+    /**
+     * Constructeur pour initialiser le contrôleur et attacher les actions aux boutons.
+     *
+     * @param mainMenu       Instance du menu principal
+     * @param settingsFrame  Fenêtre des paramètres
+     * @param howToPlayFrame Fenêtre d'aide (Comment jouer ?)
+     * @param gameModeFrame  Fenêtre de sélection du mode de jeu
+     * @param gameFrame      Fenêtre principale du jeu
+     */
     public MainMenuButtonController(MainMenu mainMenu, JFrame settingsFrame, JFrame howToPlayFrame, JFrame gameModeFrame, JFrame gameFrame) {
         this.mainMenu = mainMenu;
-        // Ajouter les écouteurs d'événements sur les boutons
-        ButtonPanel buttonPanel = mainMenu.getButtonPanel();
 
         // Attacher les actions aux boutons du menu principal
+        ButtonPanel buttonPanel = mainMenu.getButtonPanel();
         buttonPanel.getNewGameButton().addActionListener(this);
         buttonPanel.getHowToPlayButton().addActionListener(this);
         buttonPanel.getSettingsButton().addActionListener(this);
         buttonPanel.getExitButton().addActionListener(this);
 
-        // Paramètrage de la fenêtre des paramètres
+        // Configurer les différentes fenêtres
         this.settingsFrame = settingsFrame;
         configureFrame(this.settingsFrame);
 
-        // Paramètrage de la fenêtre du tutoriel
         this.howToPlayFrame = howToPlayFrame;
         configureFrame(this.howToPlayFrame);
 
-        // Paramètrage de la fenêtre du jeu
         this.gameModeFrame = gameModeFrame;
         configureFrame(this.gameModeFrame);
 
-        // Paramètrage de la fenêtre du jeu
         this.gameFrame = gameFrame;
         configureFrame(this.gameFrame);
     }
 
+    /**
+     * Configure une fenêtre (taille, position, comportement par défaut).
+     *
+     * @param frame La fenêtre à configurer
+     */
     private void configureFrame(JFrame frame) {
         frame.setLocationRelativeTo(null);
         frame.setVisible(false);
         frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
     }
 
-
+    /**
+     * Gère les actions déclenchées par les boutons du menu principal.
+     *
+     * @param e Événement d'action
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
         String command = e.getActionCommand();
@@ -78,39 +116,54 @@ public class MainMenuButtonController implements ActionListener {
         }
     }
 
+    /**
+     * Démarre une nouvelle partie en affichant la fenêtre de sélection du mode de jeu.
+     */
     public void startNewGame() {
         adjustFrameDisplay(this.gameModeFrame);
         this.mainMenu.setVisible(false);
         this.gameModeFrame.setVisible(true);
     }
 
+    /**
+     * Affiche la fenêtre "Comment jouer ?".
+     */
     public void showHowToPlay() {
         adjustFrameDisplay(this.howToPlayFrame);
         this.mainMenu.setVisible(false);
         this.howToPlayFrame.setVisible(true);
     }
 
+    /**
+     * Quitte le jeu en fermant l'application.
+     */
     private void exitGame() {
-        System.exit(0); // Fermer l'application
+        System.exit(0); // Ferme l'application
     }
 
+    /**
+     * Ouvre la fenêtre des paramètres.
+     */
     private void openSettings() {
         adjustFrameDisplay(this.settingsFrame);
         this.mainMenu.setVisible(false);
         this.settingsFrame.setVisible(true);
     }
 
-
+    /**
+     * Ajuste la taille et la position d'une fenêtre par rapport au menu principal.
+     *
+     * @param frame La fenêtre à ajuster
+     */
     private void adjustFrameDisplay(JFrame frame) {
-        boolean wasVisible = frame.isVisible(); // Vérifier si la fenêtre était déjà visible
+        boolean wasVisible = frame.isVisible(); // Vérifie si la fenêtre est déjà visible
 
-        if(!wasVisible){
-            // Récupérer la taille et la position de la fenêtre du menu principal
+        if (!wasVisible) {
+            // Ajuste la taille et la position de la fenêtre
             Dimension mainMenuSize = this.mainMenu.getSize();
             Point mainMenuLocation = this.mainMenu.getLocation();
             frame.setSize(mainMenuSize);
             frame.setLocation(mainMenuLocation);
         }
     }
-    
 }

src/fr/monkhanny/dorfromantik/controller/MainMenuMouseController.java

@@ -5,15 +5,33 @@ import fr.monkhanny.dorfromantik.gui.ButtonHoverAnimator;
 
 import javax.swing.*;
 
+/**
+ * Contrôleur pour gérer les animations des boutons du menu principal lors des interactions avec la souris.
+ * Ce contrôleur attache des listeners de survol (hover) pour animer les boutons du panneau de boutons du menu principal.
+ *
+ * @version 1.0
+ * @author Moncef STITI, Khalid CHENOUNA
+ */
 public class MainMenuMouseController {
 
+    /**
+     * Référence au panneau contenant les boutons du menu principal.
+     */
     private final ButtonPanel buttonPanel;
 
+    /**
+     * Constructeur qui initialise le contrôleur et attache les listeners de survol aux boutons.
+     *
+     * @param buttonPanel Instance du panneau de boutons à contrôler
+     */
     public MainMenuMouseController(ButtonPanel buttonPanel) {
         this.buttonPanel = buttonPanel;
         initMouseListeners();
     }
 
+    /**
+     * Initialise les listeners de survol pour les boutons du panneau.
+     */
     private void initMouseListeners() {
         addButtonHoverListener(buttonPanel.getNewGameButton());
         addButtonHoverListener(buttonPanel.getHowToPlayButton());
@@ -21,6 +39,12 @@ public class MainMenuMouseController {
         addButtonHoverListener(buttonPanel.getExitButton());
     }
 
+    /**
+     * Ajoute un listener de survol pour un bouton spécifique.
+     * Ce listener utilise un {@link ButtonHoverAnimator} pour gérer les animations.
+     *
+     * @param button Bouton auquel attacher le listener
+     */
     private void addButtonHoverListener(JButton button) {
         ButtonHoverAnimator animator = new ButtonHoverAnimator(button);
         button.addMouseListener(new ButtonHoverListener(animator));

src/fr/monkhanny/dorfromantik/controller/MainMenuResizeController.java

@@ -2,17 +2,41 @@ package fr.monkhanny.dorfromantik.controller;
 
 import fr.monkhanny.dorfromantik.gui.MainMenu;
 
+/**
+ * Contrôleur pour gérer les redimensionnements de la fenêtre du menu principal.
+ * Ce contrôleur attache un gestionnaire de redimensionnement pour ajuster dynamiquement 
+ * les éléments du menu principal lorsque la fenêtre est redimensionnée.
+ *
+ * @version 1.0
+ * @author 
+ * Moncef STITI, Khalid CHENOUNA
+ */
 public class MainMenuResizeController {
 
-    private MainMenu mainMenu;
-    private MainMenuResizeHandler resizeHandler;
+    /**
+     * Instance du menu principal.
+     */
+    private final MainMenu mainMenu;
 
+    /**
+     * Gestionnaire de redimensionnement pour le menu principal.
+     */
+    private final MainMenuResizeHandler resizeHandler;
+
+    /**
+     * Constructeur qui initialise le contrôleur et attache le gestionnaire de redimensionnement.
+     *
+     * @param mainMenu Instance du menu principal
+     */
     public MainMenuResizeController(MainMenu mainMenu) {
         this.mainMenu = mainMenu;
         this.resizeHandler = new MainMenuResizeHandler(mainMenu);
         addComponentListener();
     }
 
+    /**
+     * Attache le gestionnaire de redimensionnement au menu principal.
+     */
     private void addComponentListener() {
         mainMenu.addComponentListener(resizeHandler);
     }

src/fr/monkhanny/dorfromantik/controller/MainMenuResizeHandler.java

@@ -7,24 +7,50 @@ import fr.monkhanny.dorfromantik.gui.ButtonHoverAnimator;
 import java.awt.event.ComponentAdapter;
 import java.awt.event.ComponentEvent;
 
+/**
+ * Gestionnaire de redimensionnement pour le menu principal.
+ * Ce gestionnaire ajuste dynamiquement les éléments du menu principal 
+ * (titre, boutons, etc.) lorsque la fenêtre est redimensionnée.
+ *
+ * @version 1.0
+ * @author 
+ * Moncef STITI, Khalid CHENOUNA
+ */
 public class MainMenuResizeHandler extends ComponentAdapter {
 
-    private MainMenu mainMenu;
+    /**
+     * Instance du menu principal à ajuster.
+     */
+    private final MainMenu mainMenu;
 
+    /**
+     * Constructeur qui initialise le gestionnaire avec une référence au menu principal.
+     *
+     * @param mainMenu Instance du menu principal
+     */
     public MainMenuResizeHandler(MainMenu mainMenu) {
         this.mainMenu = mainMenu;
     }
 
+    /**
+     * Méthode appelée lorsque la fenêtre du menu principal est redimensionnée.
+     * Ajuste la taille de la police du titre et des boutons en fonction de la nouvelle largeur de la fenêtre.
+     *
+     * @param e Événement de redimensionnement
+     * @see ComponentEvent
+     */
     @Override
     public void componentResized(ComponentEvent e) {
         int mainMenuWidth = mainMenu.getWidth();
 
-        // Ajuster la taille de la police du titre en fonction de la taille de la fenêtre
+        // Ajuster la taille de la police du titre en fonction de la largeur de la fenêtre
         float newFontSize = Options.BASE_TITLE_FONT_SIZE * (mainMenuWidth / 900f);
         mainMenu.getTitleLabel().updateTitleFont(newFontSize);
 
         // Mettre à jour les polices des boutons
         mainMenu.getButtonPanel().updateButtonFonts(mainMenuWidth);
-        ButtonHoverAnimator.updateOriginalFont(mainMenuWidth / 30f); // On passe la nouvelle taille de police pour chaque bouton
+
+        // Mettre à jour la taille de la police originale pour les animations de survol des boutons
+        ButtonHoverAnimator.updateOriginalFont(mainMenuWidth / 30f);
     }
 }

src/fr/monkhanny/dorfromantik/controller/TutorialController.java

@@ -9,25 +9,57 @@ import javax.swing.*;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * Contrôleur pour gérer le panneau de tutoriel.
+ * Ce contrôleur configure les étapes du tutoriel et relie le panneau de tutoriel au menu principal et à sa fenêtre dédiée.
+ *
+ * @version 1.0
+ * @author 
+ * Lenny FOULOU, Khalid CHENOUNA
+ */
 public class TutorialController {
-    private TutorialPanel tutorialPanel;
 
-    private MainMenu mainMenu;
-    private JFrame tutorialFrame;
+    /**
+     * Instance du panneau de tutoriel contenant les étapes.
+     */
+    private final TutorialPanel tutorialPanel;
 
+    /**
+     * Référence au menu principal.
+     */
+    private final MainMenu mainMenu;
+
+    /**
+     * Référence à la fenêtre contenant le tutoriel.
+     */
+    private final JFrame tutorialFrame;
+
+    /**
+     * Constructeur qui initialise le contrôleur et configure les étapes du tutoriel.
+     *
+     * @param mainMenu Référence au menu principal
+     * @param tutorialFrame Fenêtre dans laquelle le tutoriel est affiché
+     */
     public TutorialController(MainMenu mainMenu, JFrame tutorialFrame) {
         this.mainMenu = mainMenu;
         this.tutorialFrame = tutorialFrame;
 
+        // Création des étapes du tutoriel avec leurs titres, descriptions et images
         List<Step> steps = new ArrayList<>();
         steps.add(new Step("Étape n°1", "Explication de la première étape ici.", Images.TUTORIAL_GIF1.getImagePath()));
         steps.add(new Step("Étape n°2", "Explication de la deuxième étape ici.", Images.TUTORIAL_GIF2.getImagePath()));
         steps.add(new Step("Étape n°3", "Explication de la troisième étape ici.", Images.TUTORIAL_GIF3.getImagePath()));
         steps.add(new Step("Étape n°4", "Explication de la quatrième étape ici.", Images.TUTORIAL_GIF4.getImagePath()));
 
+        // Initialisation du panneau de tutoriel avec les étapes, le menu principal et la fenêtre associée
         tutorialPanel = new TutorialPanel(steps, this.mainMenu, this.tutorialFrame);
     }
 
+    /**
+     * Récupère le panneau de tutoriel configuré.
+     *
+     * @return Instance du panneau de tutoriel
+     */
     public JPanel getTutorialPanel() {
         return tutorialPanel;
     }