ajout JAVADOC pour le repertoire gui

src/fr/monkhanny/dorfromantik/gui/GameControlsMenu.java

@@ -4,12 +4,32 @@ import javax.swing.*;
 import java.awt.*;
 import java.net.URL;
 
+/**
+ * Panneau d'affichage des contrôles du jeu, qui présente des informations sur les commandes du clavier et de la souris.
+ * Le menu peut être affiché ou masqué en fonction de l'état de visibilité.
+ * @version 1.0
+ * @author Lenny FOULOU
+ */
 public class GameControlsMenu extends JPanel {
+
+    /**
+     * Indique si le menu des contrôles est visible ou non.
+     * Ce champ détermine l'état actuel de visibilité du panneau des contrôles.
+     */
     private boolean isVisible = true;
 
     // Chemin de base pour les icônes
+    /**
+     * Chemin de base pour les icônes utilisées dans le menu des contrôles.
+     * Ce chemin est relatif à la structure du classpath du projet et spécifie où se trouvent les icônes associées aux commandes du jeu.
+     * Les icônes doivent être stockées dans le dossier suivant : /ressources/images/Icone/Keyboard-Mouse/.
+     */
     private static final String ICON_PATH = "/ressources/images/Icone/Keyboard-Mouse/";
 
+    /**
+     * Constructeur qui initialise et configure le panneau des contrôles du jeu.
+     * Ce constructeur crée un menu avec des icônes et du texte pour chaque commande du jeu.
+     */
     public GameControlsMenu() {
         setLayout(new BoxLayout(this, BoxLayout.Y_AXIS)); // Mise en page verticale
         setBackground(new Color(0, 0, 0, 150)); // Fond semi-transparent
@@ -30,6 +50,13 @@ public class GameControlsMenu extends JPanel {
     }
 
     // Crée un JPanel avec l'icône et le texte aligné horizontalement
+    /**
+     * Crée un panneau avec une icône et un texte alignés horizontalement.
+     *
+     * @param text     Le texte à afficher à côté de l'icône.
+     * @param iconName Le nom du fichier d'icône à charger.
+     * @return Un JPanel contenant l'icône et le texte.
+     */
     private JPanel createPanel(String text, String iconName) {
         JPanel panel = new JPanel();
         panel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 5)); // Alignement à gauche
@@ -49,6 +76,13 @@ public class GameControlsMenu extends JPanel {
     }
 
     // Crée un JPanel avec plusieurs icônes et un texte, en ajoutant un "+" entre les icônes
+    /**
+     * Crée un panneau avec plusieurs icônes et un texte, en ajoutant un "+" entre les icônes.
+     *
+     * @param text      Le texte à afficher après les icônes.
+     * @param iconNames Les noms des fichiers d'icônes à charger.
+     * @return Un JPanel contenant les icônes et le texte.
+     */
     private JPanel createPanelWithMultipleIcons(String text, String... iconNames) {
         JPanel panel = new JPanel();
         panel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 5)); // Alignement à gauche
@@ -77,6 +111,12 @@ public class GameControlsMenu extends JPanel {
     }
 
     // Charge l'icône depuis le répertoire spécifié et la redimensionne
+    /**
+     * Charge une icône à partir du répertoire spécifié et la redimensionne.
+     * 
+     * @param iconName Le nom du fichier de l'icône à charger.
+     * @return L'icône redimensionnée sous forme de {@link ImageIcon}.
+     */
     private ImageIcon loadIcon(String iconName) {
         // Utilisation de getClass().getResource() pour charger l'icône depuis le classpath
         URL iconURL = getClass().getResource(ICON_PATH + iconName);
@@ -92,11 +132,20 @@ public class GameControlsMenu extends JPanel {
         }
     }
 
+    /**
+     * Permet de basculer la visibilité du menu des contrôles.
+     * Si le menu est visible, il devient invisible, et inversement.
+     */
     public void toggleVisibility() {
         isVisible = !isVisible;
         setVisible(isVisible);
     }
 
+    /**
+     * Définit la visibilité du menu des contrôles.
+     * 
+     * @param visible Indique si le menu doit être visible (true) ou non (false).
+     */
     public void setControlsMenuVisible(boolean visible) {
         isVisible = visible;
         setVisible(visible);

src/fr/monkhanny/dorfromantik/gui/GameModeSelectionPanel.java

@@ -17,24 +17,65 @@ import java.util.List;
 import java.util.Date;
 import java.util.Calendar;
 
+/**
+ * Classe représentant le panneau de sélection du mode de jeu dans l'interface graphique.
+ * Ce panneau permet à l'utilisateur de choisir une série de jeux à partir d'une liste paginée.
+ * Il offre également des fonctionnalités de filtrage par dates et par créateur, ainsi qu'un champ pour entrer une seed.
+ * @version 1.0
+ * @author Moncef STITI, Khalid CHENOUNA, Lenny FOULOU
+ */
 public class GameModeSelectionPanel extends JPanel {
 
+    /** Titre de la section de sélection des séries. */
     private JLabel titleLabel;
+
+    /** Champ de texte pour entrer la "seed" du jeu. */
     private JTextField seedField;
+
+    /** Bouton pour démarrer le jeu avec la seed spécifiée. */
     private JButton startButton;
+
+    /** Liste des boutons représentant les différentes séries disponibles. */
     private List<JButton> seriesButtons;
+
+    /** Base de données utilisée pour récupérer les séries. */
     private Database database;
+
+    /** Panneau contenant les boutons de mode de jeu. */
     private JPanel modePanel;
+
+    /** Bouton permettant de naviguer vers la page précédente. */
     private JButton prevButton;
+
+    /** Bouton permettant de naviguer vers la page suivante. */
     private JButton nextButton;
+
+    /** Page actuelle dans la pagination des séries. */
     private int currentPage = 1;
+
+    /** Nombre d'éléments à afficher par page. */
     private int itemsPerPage = 15;
+
+    /** Étiquette affichant la page actuelle et le nombre total de pages. */
     private JLabel pageLabel;
+
+    /** Spinners permettant de sélectionner une plage de dates. */
     private JSpinner startDateSpinner;
     private JSpinner endDateSpinner;
+
+    /** Listener pour les actions des boutons. */
     private ActionListener buttonListener;
+
+    /** Case à cocher permettant de filtrer les séries créées uniquement par les développeurs. */
     private JCheckBox developerSeriesCheckBox;
 
+    /**
+     * Constructeur de la classe GameModeSelectionPanel.
+     * 
+     * @param buttonListener ActionListener à associer aux boutons du panneau.
+     * @param gameModeFrame Cadre principal de la fenêtre du jeu.
+     * @param mainMenu Menu principal permettant de revenir à l'écran principal.
+     */
     public GameModeSelectionPanel(ActionListener buttonListener, JFrame gameModeFrame, MainMenu mainMenu) {
         this.buttonListener = buttonListener;
     
@@ -94,6 +135,10 @@ public class GameModeSelectionPanel extends JPanel {
         background.add(seedPanel, BorderLayout.SOUTH);
     }
 
+    /**
+     * Charge les séries correspondant à la page actuelle et les affiche.
+     * Applique les filtres de date et de créateur de série, et gère la pagination.
+     */
     public void loadSeriesForCurrentPage() {
         // Clear existing buttons
         modePanel.removeAll();
@@ -150,7 +195,12 @@ public class GameModeSelectionPanel extends JPanel {
         modePanel.repaint();
     }
     
-
+    /**
+     * Met à jour le label de la page et l'état des boutons de pagination.
+     * 
+     * @param currentPage Page actuelle.
+     * @param totalPages Nombre total de pages disponibles.
+     */
     private void updatePageLabelAndButtons(int currentPage, int totalPages) {
         pageLabel.setText("Page " + currentPage + " / " + totalPages);
     
@@ -166,7 +216,12 @@ public class GameModeSelectionPanel extends JPanel {
     }
     
     
-
+    /**
+     * Crée un panneau pour le filtrage des séries par date.
+     * Ce panneau permet à l'utilisateur de sélectionner une plage de dates et de filtrer les séries.
+     * 
+     * @return Le panneau de filtrage des dates.
+     */
     private JPanel createDateFilterPanel() {
         // Création du panneau de date avec un BoxLayout vertical pour un meilleur agencement
         JPanel datePanel = new JPanel();
@@ -236,6 +291,11 @@ public class GameModeSelectionPanel extends JPanel {
         return datePanel;
     }
     
+    /**
+     * Applique une stylisation particulière aux spinners de date.
+     * 
+     * @param spinner Le JSpinner à styliser.
+     */
     private void stylizeDateSpinner(JSpinner spinner) {
         JComponent editor = spinner.getEditor();
         if (editor instanceof JSpinner.DefaultEditor) {
@@ -252,7 +312,11 @@ public class GameModeSelectionPanel extends JPanel {
         }
     }
     
-    
+    /**
+     * Crée le panneau de pagination avec les boutons "Précédent" et "Suivant".
+     * 
+     * @return Le panneau de pagination.
+     */
     private JPanel createPaginationPanel() {
         JPanel paginationPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
         paginationPanel.setOpaque(false);
@@ -273,7 +337,13 @@ public class GameModeSelectionPanel extends JPanel {
         return paginationPanel;
     }
     
-    
+    /**
+     * Crée le panneau supérieur contenant le bouton de retour au menu principal.
+     * 
+     * @param gameModeFrame Cadre principal de la fenêtre du jeu.
+     * @param mainMenu Menu principal permettant de revenir à l'écran principal.
+     * @return Le panneau supérieur.
+     */
     private JPanel createTopPanel(JFrame gameModeFrame, MainMenu mainMenu) {
         // Utilisation de BorderLayout pour aligner correctement le bouton à gauche
         JPanel topPanel = new JPanel(new BorderLayout());
@@ -288,6 +358,13 @@ public class GameModeSelectionPanel extends JPanel {
         return topPanel;
     }
     
+    /**
+     * Crée un bouton de retour avec une icône spécifique et un événement de fermeture.
+     * 
+     * @param gameModeFrame Cadre principal de la fenêtre du jeu.
+     * @param mainMenu Menu principal permettant de revenir à l'écran principal.
+     * @return Le bouton de retour.
+     */
     private JButton createReturnButtonWithIcon(JFrame gameModeFrame, MainMenu mainMenu) {
         ImageIcon originalIcon = new ImageIcon("./ressources/images/Icone/ExitIcon.png");
         Image scaledImage = originalIcon.getImage().getScaledInstance(50, 50, Image.SCALE_SMOOTH);
@@ -303,12 +380,25 @@ public class GameModeSelectionPanel extends JPanel {
         return returnButton;
     }
     
+    /**
+     * Crée le panneau principal pour afficher les séries.
+     * 
+     * @return Le panneau principal.
+     */
     private JPanel createMainPanel() {
         JPanel mainPanel = new JPanel(new GridBagLayout());
         mainPanel.setOpaque(false);
         return mainPanel;
     }
     
+    /**
+     * Crée des contraintes pour la mise en page du panneau principal.
+     * 
+     * @param x La position x de la cellule.
+     * @param y La position y de la cellule.
+     * @param gridWidth Le nombre de cellules à occuper horizontalement.
+     * @return Les contraintes de mise en page.
+     */
     private GridBagConstraints createGridBagConstraints(int x, int y, int gridWidth) {
         GridBagConstraints gbc = new GridBagConstraints();
         gbc.gridx = x;
@@ -319,7 +409,13 @@ public class GameModeSelectionPanel extends JPanel {
         return gbc;
     }
     
-
+    /**
+     * Crée un bouton pour chaque mode de jeu (série).
+     * 
+     * @param modeName Nom de la série.
+     * @param buttonListener ActionListener à associer au bouton.
+     * @return Le bouton créé pour la série.
+     */
     private JButton createGameModeButton(String modeName, ActionListener buttonListener) {
         JButton button = new JButton(modeName);
         button.setFont(new Font("Arial", Font.BOLD, 18)); // Texte clair et lisible
@@ -354,17 +450,30 @@ public class GameModeSelectionPanel extends JPanel {
         return button;
     }
 
-
+    /**
+     * Retourne le numéro de la page actuelle.
+     * 
+     * @return Le numéro de la page actuelle.
+     */
     public int getCurrentPage() {
         return currentPage;
     }
     
+    /**
+     * Définit le numéro de la page actuelle.
+     * 
+     * @param currentPage Le numéro de la page à définir.
+     */
     public void setCurrentPage(int currentPage) {
         this.currentPage = currentPage;
     }
     
-    
+    /**
-    
+     * Crée et configure un panneau pour l'entrée du seed et le bouton de démarrage.
+     * 
+     * @param buttonListener L'écouteur d'événement pour le bouton "Démarrer".
+     * @return Le panneau contenant le champ de texte pour le seed et le bouton de démarrage.
+     */
     private JPanel createSeedPanel(ActionListener buttonListener) {
         JPanel seedPanel = new JPanel();
         seedPanel.setOpaque(false);
@@ -392,10 +501,21 @@ public class GameModeSelectionPanel extends JPanel {
         return seedPanel;
     }
 
+    /**
+     * Retourne le seed sous forme de chaîne de caractères.
+     * 
+     * @return Le seed en tant que chaîne de caractères.
+     */
     public String getStringSeed() {
         return seedField.getText();
     }
 
+    /**
+     * Retourne le seed sous forme de long. Si la chaîne de texte ne peut pas être convertie en long,
+     * le timestamp actuel est utilisé comme seed.
+     * 
+     * @return Le seed en tant que valeur long.
+     */
     public long getLongSeed(){
         try{
             return Long.parseLong(seedField.getText());

src/fr/monkhanny/dorfromantik/gui/GameOver.java

@@ -11,9 +11,32 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.ArrayList;
 
+/**
+ * La classe GameOver est un panneau graphique (JPanel) affiché à la fin d'une partie.
+ * Elle affiche le score final du joueur, des informations sur sa performance par rapport aux autres joueurs, 
+ * un graphique en barres pour visualiser la position du joueur dans son groupe, ainsi qu'une citation humoristique.
+ * Elle permet également au joueur de retourner au menu principal du jeu.
+ * @version 1.0
+ * @author Khalid CHENOUNA, Lenny FOULOU
+ */
 public class GameOver extends JPanel {
+
+    /**
+     * Le cadre principal du jeu (JFrame) qui contient tous les panneaux et composants graphiques.
+     * Il permet la gestion de l'interface utilisateur du jeu et permet de naviguer entre les écrans (comme l'écran de fin de jeu).
+     */
     private JFrame gameFrame;
 
+    /**
+     * Constructeur de la classe GameOver.
+     * Ce constructeur crée un écran de fin de partie affichant le score du joueur et des informations supplémentaires,
+     * telles que son groupe dans le classement.
+     * 
+     * @param gameFrame Le cadre principal du jeu (JFrame) permettant de naviguer entre les écrans.
+     * @param finalScore Le score final du joueur.
+     * @param database L'objet Database permettant d'interagir avec la base de données.
+     * @param mainMenu Le menu principal permettant de revenir à l'accueil.
+     */
     public GameOver(JFrame gameFrame, int finalScore, Database database, MainMenu mainMenu) {
         this.gameFrame = gameFrame;
         this.gameFrame.setTitle("Partie terminée - Dorfromantik");
@@ -146,7 +169,15 @@ public class GameOver extends JPanel {
         mainPanel.add(returnButton);
     }
     
-    
+    /**
+     * Vérifie si le score du joueur se trouve dans le groupe spécifié par les indices de départ et de fin.
+     *
+     * @param allScores La liste de tous les scores des joueurs.
+     * @param finalScore Le score final du joueur.
+     * @param startIdx L'indice de début du groupe.
+     * @param endIdx L'indice de fin du groupe.
+     * @return true si le score est dans le groupe, sinon false.
+     */
     private boolean scoreInGroup(List<Integer> allScores, int finalScore, int startIdx, int endIdx) {
         for (int i = startIdx; i < endIdx; i++) {
             if (allScores.get(i) == finalScore) {
@@ -156,6 +187,12 @@ public class GameOver extends JPanel {
         return false;
     }
 
+    /**
+     * Retourne une citation humoristique basée sur le groupe du joueur.
+     *
+     * @param playerGroup Le groupe du joueur (1 à 10).
+     * @return Une citation humoristique correspondant au groupe.
+     */
     private String getFunnyQuote(int playerGroup) {
         // A list of funny and motivational quotes based on the group
         switch (playerGroup) {

src/fr/monkhanny/dorfromantik/gui/Leaderboard.java

@@ -3,10 +3,27 @@ package fr.monkhanny.dorfromantik.gui;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * Classe abstraite représentant un classement (Leaderboard).
+ * Cette classe sert de base pour la création de différents types de classements, tels que le classement mondial ou par tranche.
+ * Elle définit la structure de base d'un leaderboard et inclut une méthode abstraite pour actualiser son contenu.
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public abstract class Leaderboard extends JPanel {
+
+    /**
+     * Constructeur de la classe Leaderboard.
+     * Initialise le panneau avec une disposition de type BorderLayout.
+     */
     public Leaderboard() {
         setLayout(new BorderLayout());
     }
 
+    /**
+     * Méthode abstraite pour actualiser le contenu du classement.
+     * Chaque implémentation concrète de cette classe devra fournir sa propre version de cette méthode
+     * pour actualiser les données et l'affichage du leaderboard.
+     */
     public abstract void refresh(); // Méthode pour actualiser le contenu
 }

src/fr/monkhanny/dorfromantik/gui/LeaderboardBarChartPanel.java

@@ -3,15 +3,49 @@ package fr.monkhanny.dorfromantik.gui;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * Panneau représentant un graphique en barres pour visualiser la position d'un joueur dans un classement global.
+ * Ce graphique divise les joueurs en 10 tranches égales et colore la barre correspondant à la tranche du joueur
+ * en vert, tandis que les autres tranches sont colorées en rouge.
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class LeaderboardBarChartPanel extends JPanel {
+
+    /**
+     * Le nombre total de joueurs dans le classement.
+     * Utilisé pour déterminer la position relative du joueur dans le graphique en barres.
+     */
     private int totalPlayers;
+
+    /**
+     * Le rang actuel du joueur dans le classement.
+     * Utilisé pour déterminer dans quelle tranche le joueur se situe pour le graphique en barres.
+     */
     private int rank;
 
+    /**
+     * Constructeur de la classe {@code LeaderboardBarChartPanel}.
+     * Initialise le panneau avec le nombre total de joueurs et le rang actuel du joueur.
+     *
+     * @param totalPlayers Le nombre total de joueurs dans le classement.
+     * @param rank         Le rang actuel du joueur dans le classement.
+     */
     public LeaderboardBarChartPanel(int totalPlayers, int rank) {
         this.totalPlayers = totalPlayers;
         this.rank = rank;
     }
 
+    /**
+     * Méthode de dessin personnalisée pour afficher un graphique en barres représentant les tranches de classement des joueurs.
+     * Chaque barre représente une tranche du classement. La barre correspondant à la tranche du joueur est colorée en vert,
+     * et les autres barres sont colorées en rouge.
+     * <p>
+     * Cette méthode est appelée chaque fois que le panneau doit être redessiné.
+     * </p>
+     *
+     * @param g L'objet {@link Graphics} utilisé pour dessiner le graphique en barres.
+     */
     @Override
     protected void paintComponent(Graphics g) {
         super.paintComponent(g);

src/fr/monkhanny/dorfromantik/gui/LeaderboardByTier.java

@@ -4,13 +4,31 @@ import javax.swing.*;
 import java.awt.*;
 
 // @TODO : MODIFIER CAR C'EST PAS BEAU + BDD
+/**
+ * Classe représentant le leaderboard affichant les joueurs par tranche de classement.
+ * Cette classe étend {@link Leaderboard} et permet de visualiser dans quelle tranche se trouve un joueur
+ * par rapport aux autres, en utilisant des tranches basées sur le classement global.
+ * Le classement est présenté avec des informations sur le pourcentage de joueurs devant et derrière le joueur.
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class LeaderboardByTier extends Leaderboard {
 
+    /**
+     * Constructeur de la classe {@code LeaderboardByTier}.
+     * Charge les données initiales du leaderboard en appelant la méthode {@link #refresh()}.
+     */
     public LeaderboardByTier() {
         super();
         refresh(); // Charge les données initiales
     }
 
+    /**
+     * Actualise l'affichage du leaderboard en fonction des tranches de classement des joueurs.
+     * Cette méthode affiche le classement du joueur actuel, les tranches de classement globales,
+     * le pourcentage du joueur par rapport au total, et un graphique en barres représentant sa position
+     * par rapport aux autres joueurs.
+     */
     @Override
     public void refresh() {
         removeAll(); // Supprime tout contenu existant

src/fr/monkhanny/dorfromantik/gui/LeaderboardWorldWide.java

@@ -8,13 +8,29 @@ import java.awt.*;
 import java.sql.SQLException;
 import java.util.List;
 
+/**
+ * Classe représentant le leaderboard mondial des meilleurs joueurs.
+ * Cette classe étend {@link Leaderboard} et affiche les meilleurs joueurs en fonction de leurs scores.
+ * Le leaderboard est mis à jour en récupérant les données depuis la base de données.
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class LeaderboardWorldWide extends Leaderboard {
 
+    /**
+     * Constructeur de la classe {@code LeaderboardWorldWide}.
+     * Charge les données initiales du leaderboard en appelant la méthode {@link #refresh()}.
+     */
     public LeaderboardWorldWide() {
         super();
         refresh(); // Charge les données initiales
     }
 
+    /**
+     * Actualise le leaderboard en récupérant les données des meilleurs joueurs.
+     * Remplace le contenu existant par les informations les plus récentes sur les joueurs.
+     * La méthode affiche les trois premiers joueurs avec des médailles, suivis des autres joueurs.
+     */
     @Override
     public void refresh() {
         removeAll(); // Supprime tout contenu existant
@@ -97,6 +113,14 @@ public class LeaderboardWorldWide extends Leaderboard {
         repaint();
     }
 
+    /**
+     * Crée un panneau affichant les informations d'un joueur, y compris son rang, son nom et son score.
+     * 
+     * @param playerName Le nom du joueur.
+     * @param score Le score du joueur.
+     * @param rank Le rang du joueur dans le leaderboard.
+     * @return Un panneau affichant les informations du joueur.
+     */
     private JPanel createPlayerPanel(String playerName, int score, int rank) {
         JPanel panel = new JPanel();
         panel.setLayout(new BorderLayout());
@@ -123,12 +147,30 @@ public class LeaderboardWorldWide extends Leaderboard {
         return panel;
     }
 
+    /**
+     * Redimensionne l'icône spécifiée à la taille donnée.
+     * 
+     * @param path Le chemin de l'image à redimensionner.
+     * @param width La largeur souhaitée de l'image.
+     * @param height La hauteur souhaitée de l'image.
+     * @return L'icône redimensionnée.
+     */
     private ImageIcon resizeIcon(String path, int width, int height) {
         ImageIcon icon = new ImageIcon(path);
         Image img = icon.getImage().getScaledInstance(width, height, Image.SCALE_SMOOTH);
         return new ImageIcon(img);
     }
 
+    /**
+     * Crée un panneau affichant les informations d'un des trois meilleurs joueurs, y compris leur médaille,
+     * leur nom et leur score.
+     * 
+     * @param playerName Le nom du joueur.
+     * @param score Le score du joueur.
+     * @param medalPath Le chemin vers l'image de la médaille.
+     * @param isFirst Indique si le joueur est premier.
+     * @return Un panneau avec le joueur, sa médaille, son nom et son score.
+     */
     private JPanel createTopPlayerPanel(String playerName, int score, String medalPath, boolean isFirst) {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

src/fr/monkhanny/dorfromantik/gui/MainMenu.java

@@ -9,14 +9,39 @@ import fr.monkhanny.dorfromantik.Options;
 import javax.swing.*;
 import java.awt.*;
 
-
+/**
+ * Classe représentant le menu principal du jeu.
+ * Elle gère l'affichage du titre, des boutons et du leaderboard.
+ * @version 1.0
+ * @author Lenny FOULOU
+ */
 public class MainMenu extends JFrame {
 
+    /**
+     * Titre du menu principal, affiché en haut au centre de la fenêtre.
+     */
     private Title titleLabel;
-    private ButtonPanel buttonPanel;
-    private JPanel leaderboardContainer; // Conteneur pour le leaderboard
-    private Leaderboard currentLeaderboard; // Référence au leaderboard actuel
 
+    /**
+     * Panneau contenant les boutons du menu principal.
+     */
+    private ButtonPanel buttonPanel;
+
+    /**
+     * Conteneur pour le leaderboard.
+     */
+    private JPanel leaderboardContainer;
+
+    /**
+     * Référence au leaderboard actuel affiché.
+     */
+    private Leaderboard currentLeaderboard;
+
+    /**
+     * Constructeur pour initialiser le menu principal.
+     * Charge les polices, configure la fenêtre principale et ajoute les éléments graphiques
+     * tels que le titre, les boutons et le leaderboard.
+     */
     public MainMenu() {
         // Charger les polices pour le titre et les boutons
         FontManager.loadCustomFont(Fonts.TITLE);  // Charge la police pour le titre
@@ -64,10 +89,20 @@ public class MainMenu extends JFrame {
         setVisible(true);
     }
 
+    /**
+     * Obtient le titre du menu principal.
+     * 
+     * @return Le titre du menu principal.
+     */
     public Title getTitleLabel() {
         return titleLabel;
     }
 
+    /**
+     * Obtient le panneau contenant les boutons du menu principal.
+     * 
+     * @return Le panneau des boutons.
+     */
     public ButtonPanel getButtonPanel() {
         return buttonPanel;
     }

src/fr/monkhanny/dorfromantik/gui/Reward.java

@@ -3,12 +3,44 @@ package fr.monkhanny.dorfromantik.gui;
 import javax.swing.*;
 
 // Classe pour représenter une récompense
+/**
+ * Classe représentant une récompense dans le jeu.
+ * Une récompense peut avoir un nom, une description, un état (déverrouillée ou non)
+ * et une icône associée.
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class Reward {
+
+    /**
+     * Nom de la récompense.
+     */
     private String name;
+
+    /**
+     * Description de la récompense, fournissant des informations ou un contexte sur celle-ci.
+     */
     private String description;
+
+    /**
+     * État indiquant si la récompense est déverrouillée.
+     * {@code true} si elle est déverrouillée, {@code false} sinon.
+     */
     private boolean isUnlocked;
+
+    /**
+     * Icône représentant visuellement la récompense.
+     */
     private ImageIcon icon;
 
+    /**
+     * Constructeur permettant de créer une nouvelle récompense.
+     *
+     * @param name        le nom de la récompense
+     * @param description la description de la récompense
+     * @param isUnlocked  {@code true} si la récompense est déverrouillée, {@code false} sinon
+     * @param icon        l'icône associée à la récompense
+     */
     public Reward(String name, String description, boolean isUnlocked, ImageIcon icon) {
         this.name = name;
         this.description = description;
@@ -16,18 +48,38 @@ public class Reward {
         this.icon = icon;
     }
 
+    /**
+     * Obtient le nom de la récompense.
+     *
+     * @return le nom de la récompense
+     */
     public String getName() {
         return name;
     }
 
+    /**
+     * Obtient la description de la récompense.
+     *
+     * @return la description de la récompense
+     */
     public String getDescription() {
         return description;
     }
 
+    /**
+     * Vérifie si la récompense est déverrouillée.
+     *
+     * @return {@code true} si la récompense est déverrouillée, {@code false} sinon
+     */
     public boolean isUnlocked() {
         return isUnlocked;
     }
 
+    /**
+     * Obtient l'icône représentant la récompense.
+     *
+     * @return l'icône de la récompense
+     */
     public ImageIcon getIcon() {
         return icon;
     }

src/fr/monkhanny/dorfromantik/gui/SettingsPanel.java

@@ -9,12 +9,41 @@ import javax.swing.*;
 import java.awt.*;
 import javax.swing.event.ChangeListener;
 
+
+/**
+ * Représente le panneau des paramètres du jeu.
+ * Permet aux utilisateurs de personnaliser les options comme le volume de la musique, les effets sonores,
+ * et l'activation ou la désactivation du focus automatique.
+ * @version 1.0
+ * @author Khalid CHENOUNA, Moncef STITI
+ */
 public class SettingsPanel extends JPanel {
 
+    /**
+     * Référence au menu principal pour permettre le retour à celui-ci
+     * lorsque l'utilisateur clique sur le bouton de retour.
+     */
     private MainMenu mainMenu;
+
+    /**
+     * Référence à la fenêtre contenant ce panneau de paramètres.
+     * Utilisée pour effectuer des actions comme fermer ou redimensionner la fenêtre.
+     */
     private JFrame settingsFrame;
+
+    /**
+     * Bouton permettant de revenir au menu principal.
+     * Déclaré en tant qu'attribut pour permettre un accès facile depuis différentes méthodes
+     * (comme la méthode pour définir sa visibilité).
+     */
     private JButton returnButton; // Déclarer le bouton pour pouvoir y accéder depuis d'autres méthodes
 
+    /**
+     * Constructeur pour initialiser le panneau des paramètres.
+     *
+     * @param mainMenu      L'instance du menu principal à réafficher lorsque le bouton de retour est cliqué.
+     * @param settingsFrame La fenêtre contenant ce panneau.
+     */
     public SettingsPanel(MainMenu mainMenu, JFrame settingsFrame) {
         this.mainMenu = mainMenu;
         this.settingsFrame = settingsFrame;
@@ -26,16 +55,25 @@ public class SettingsPanel extends JPanel {
         setupMainPanel(); // Configuration du panneau principal pour les sliders et boutons
     }
 
+    /**
+     * Définit la taille minimale de la fenêtre des paramètres.
+     */
     private void initializeSettingsFrame() {
         settingsFrame.setMinimumSize(Options.MINIMUM_FRAME_SIZE);
     }
-
+    
+    /**
+     * Configure le fond d'écran du panneau.
+     */
     private void setupBackground() {
         JLabel background = new JLabel(new ImageIcon("./ressources/images/MainMenu/backgroundBlured.jpg"));
         background.setLayout(new GridBagLayout());
         this.add(background, BorderLayout.CENTER); // Déplacer l'ajout du fond au centre
     }
-
+    
+    /**
+     * Configure le panneau supérieur contenant le titre et le bouton de retour.
+     */
     private void setupTopPanel() {
         JPanel topPanel = new JPanel(new BorderLayout());
         topPanel.setOpaque(false);
@@ -53,13 +91,24 @@ public class SettingsPanel extends JPanel {
         this.add(topPanel, BorderLayout.NORTH);
     }
 
+ 
     // Méthode pour rendre le bouton de retour visible ou invisible
+    /**
+     * Permet de rendre le bouton de retour visible ou invisible.
+     *
+     * @param visible Si vrai, le bouton de retour sera visible ; sinon, il sera caché.
+     */
     public void setReturnButtonVisible(boolean visible) {
         if (returnButton != null) {
             returnButton.setVisible(visible);
         }
     }
 
+    /**
+     * Dessine le composant avec un fond personnalisé.
+     *
+     * @param g Le contexte graphique utilisé pour dessiner le panneau.
+     */
     @Override
     protected void paintComponent(Graphics g) {
         super.paintComponent(g);
@@ -67,6 +116,9 @@ public class SettingsPanel extends JPanel {
         g.drawImage(backgroundImage.getImage(), 0, 0, getWidth(), getHeight(), this);
     }
 
+    /**
+     * Configure le panneau principal contenant les contrôles des paramètres.
+     */
     private void setupMainPanel() {
         JPanel mainPanel = new JPanel(new GridBagLayout());
         mainPanel.setOpaque(false);
@@ -89,6 +141,15 @@ public class SettingsPanel extends JPanel {
         this.add(mainPanel, BorderLayout.CENTER);
     }
 
+    /**
+     * Crée un panneau pour les contrôles de son.
+     *
+     * @param labelText           Le texte du titre (ex. "Musique" ou "SFX").
+     * @param volumeSlider        Le slider pour régler le volume.
+     * @param sliderChangeListener Le listener pour les changements de volume.
+     * @param muteCheckBoxListener Le listener pour couper ou réactiver le son.
+     * @return Le panneau configuré pour le contrôle du son.
+     */
     private JPanel createSoundPanel(String labelText, JSlider volumeSlider, ChangeListener sliderChangeListener, MuteCheckBoxListener muteCheckBoxListener) {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); // Utilisation de BoxLayout pour une disposition verticale
@@ -151,6 +212,11 @@ public class SettingsPanel extends JPanel {
         return panel;
     }
 
+    /**
+     * Crée un panneau pour le contrôle de l'auto-focus.
+     *
+     * @return Le panneau de contrôle de l'auto-focus.
+     */
     private JPanel createAutoFocusPanel() {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); // Disposition verticale
@@ -200,6 +266,12 @@ public class SettingsPanel extends JPanel {
     }
 
 
+     /**
+     * Crée un panneau contenant un slider et ses libellés.
+     *
+     * @param volumeSlider Le slider à inclure dans le panneau.
+     * @return Le panneau contenant le slider et ses libellés.
+     */
     private JPanel createSliderPanel(JSlider volumeSlider) {
         JPanel sliderPanel = new JPanel(new BorderLayout());
         sliderPanel.setOpaque(false);
@@ -219,6 +291,14 @@ public class SettingsPanel extends JPanel {
         return sliderPanel;
     }
 
+    /**
+     * Crée des contraintes pour un élément de disposition GridBag.
+     *
+     * @param x         La position en colonne.
+     * @param y         La position en ligne.
+     * @param gridWidth La largeur en colonnes.
+     * @return Les contraintes configurées.
+     */
     private GridBagConstraints createGridBagConstraints(int x, int y, int gridWidth) {
         GridBagConstraints gbc = new GridBagConstraints();
         gbc.gridx = x;
@@ -229,6 +309,11 @@ public class SettingsPanel extends JPanel {
         return gbc;
     }
 
+    /**
+     * Crée un bouton de retour avec une icône.
+     *
+     * @return Le bouton de retour configuré.
+     */
     private JButton createReturnButtonWithIcon() {
         ImageIcon originalIcon = new ImageIcon(Images.EXIT_ICON.getImagePath());
 

src/fr/monkhanny/dorfromantik/gui/Step.java

@@ -1,24 +1,65 @@
 package fr.monkhanny.dorfromantik.gui;
 
+/**
+ * Représente une étape dans le tutoriel du jeu.
+ * Chaque étape comprend un titre, un texte descriptif et une image associée.
+ * @version 1.0
+ * @author Khalid CHENOUNA
+ */
 public class Step {
+
+    /**
+     * Titre de l'étape.
+     */
     private String title;
+
+    /**
+     * Texte descriptif de l'étape.
+     */
     private String text;
+
+    /**
+     * Chemin vers l'image associée à l'étape.
+     */
     private String imagePath;
 
+    /**
+     * Constructeur pour créer une nouvelle étape de tutoriel.
+     *
+     * @param title     Titre de l'étape.
+     * @param text      Texte descriptif de l'étape.
+     * @param imagePath Chemin vers l'image associée.
+     */
     public Step(String title, String text, String imagePath) {
         this.title = title;
         this.text = text;
         this.imagePath = imagePath;
     }
 
+    /**
+     * Obtient le texte descriptif de l'étape.
+     *
+     * @return Le texte descriptif de l'étape.
+     */
+
     public String getText() {
         return text;
     }
 
+    /**
+     * Obtient le chemin vers l'image associée à l'étape.
+     *
+     * @return Le chemin de l'image.
+     */
     public String getImagePath() {
         return imagePath;
     }
 
+    /**
+     * Obtient le titre de l'étape.
+     *
+     * @return Le titre de l'étape.
+     */
     public String getTitle() {
         return title;
     }

src/fr/monkhanny/dorfromantik/gui/TutorialPanel.java

@@ -9,18 +9,67 @@ import javax.swing.*;
 import java.awt.*;
 import java.util.List;
 
+/**
+ * Panneau d'interface utilisateur pour afficher le tutoriel du jeu.
+ * Permet de naviguer entre différentes étapes (texte et image) 
+ * et de retourner au menu principal via un bouton de retour.
+ * @version 1.0
+ * @author Lenny FOULOU, Moncef STITI
+ */
 public class TutorialPanel extends JPanel {
 
+    /**
+     * Liste des étapes du tutoriel.
+     */
     private List<Step> steps;
+
+    /**
+     * Index de l'étape actuellement affichée.
+     */
     private int currentStepIndex;
+       
+    /**
+     * Titre affiché en haut du panneau.
+     */
     private Title title;
+        
+    /**
+     * Texte décrivant l'étape actuelle.
+     */
     private JLabel stepText;
+
+    /**
+     * Image associée à l'étape actuelle.
+     */
     private JLabel stepImage;
+        
+    /**
+     * Bouton pour naviguer vers l'étape suivante.
+     */
     private JButton nextButton;
+        
+    /**
+     * Bouton pour naviguer vers l'étape précédente.
+     */
     private JButton prevButton;
+        
+    /**
+     * Instance du menu principal pour gérer le retour.
+     */
     private MainMenu mainMenu;
+        
+    /**
+     * Fenêtre actuelle contenant ce panneau.
+     */
     private JFrame tutorialFrame;
 
+    /**
+     * Constructeur pour initialiser le panneau avec les étapes et les composants nécessaires.
+     *
+     * @param steps         Liste des étapes du tutoriel.
+     * @param mainMenu      Instance du menu principal pour gérer le retour.
+     * @param tutorialFrame Fenêtre contenant ce panneau.
+     */
     public TutorialPanel(List<Step> steps, MainMenu mainMenu, JFrame tutorialFrame) {
         this.steps = steps;
         this.currentStepIndex = 0;
@@ -108,6 +157,11 @@ public class TutorialPanel extends JPanel {
         updateStepDisplay();
     }
 
+    /**
+     * Redéfinit la méthode de dessin pour inclure un arrière-plan personnalisé.
+     *
+     * @param g Le contexte graphique.
+     */
     @Override
     protected void paintComponent(Graphics g) {
         super.paintComponent(g); // Appel à super pour s'assurer que le panneau est dessiné
@@ -118,6 +172,9 @@ public class TutorialPanel extends JPanel {
         g.drawImage(image, 0, 0, getWidth(), getHeight(), this); // Dessiner l'image pour couvrir tout le panneau
     }
 
+    /**
+     * Met à jour l'affichage des informations pour l'étape actuelle.
+     */
     private void updateStepDisplay() {
         Step currentStep = steps.get(currentStepIndex);
         String formattedText = addLineBreaks(currentStep.getText(), 10); // Limite à 10 mots par ligne
@@ -129,7 +186,11 @@ public class TutorialPanel extends JPanel {
         nextButton.setEnabled(currentStepIndex < steps.size() - 1);
     }
     
-
+    /**
+     * Applique un style personnalisé aux boutons.
+     *
+     * @param button Le bouton à styliser.
+     */
     private void styleButton(JButton button) {
         // Police et taille
         button.setFont(new Font("Arial", Font.BOLD, 18));
@@ -149,6 +210,9 @@ public class TutorialPanel extends JPanel {
         button.addMouseListener(new TutorialButtonHoverListener(button, new Color(60,60,60), new Color(34,34,34)));
     }
 
+    /**
+     * Affiche l'étape précédente du tutoriel si possible.
+     */
     private void showPreviousStep() {
         if (currentStepIndex > 0) {
             currentStepIndex--;
@@ -156,6 +220,9 @@ public class TutorialPanel extends JPanel {
         }
     }
 
+    /**
+     * Affiche l'étape suivante du tutoriel si possible.
+     */
     private void showNextStep() {
         if (currentStepIndex < steps.size() - 1) {
             currentStepIndex++;
@@ -163,6 +230,11 @@ public class TutorialPanel extends JPanel {
         }
     }
 
+    /**
+     * Crée un bouton de retour avec une icône personnalisée.
+     *
+     * @return Le bouton de retour configuré.
+     */
     private JButton createReturnButtonWithIcon() {
         ImageIcon originalIcon = new ImageIcon(Images.EXIT_ICON.getImagePath());
 
@@ -180,6 +252,13 @@ public class TutorialPanel extends JPanel {
         return returnButton;
     }
 
+    /**
+     * Ajoute des retours à la ligne pour limiter le nombre de mots par ligne dans un texte.
+     *
+     * @param text             Texte à formater.
+     * @param maxWordsPerLine  Nombre maximal de mots par ligne.
+     * @return Texte formaté avec des retours à la ligne.
+     */
     private String addLineBreaks(String text, int maxWordsPerLine) {
         String[] words = text.split(" ");
         StringBuilder formattedText = new StringBuilder("<html>");