ajout javadoc pour game et gui

src/fr/monkhanny/dorfromantik/game/Tile.java

@@ -14,12 +14,30 @@ import fr.monkhanny.dorfromantik.enums.TileOrientation;
 import fr.monkhanny.dorfromantik.utils.Hexagon;
 import fr.monkhanny.dorfromantik.utils.HexagonDrawer;
 
-
+/**
+ * Représente une tuile hexagonale dans le jeu.
+ * 
+ * Une tuile est définie par son emplacement sur le plateau, son rayon, et les biomes associés 
+ * à chacun de ses côtés. Elle peut être dessinée graphiquement, pivotée, et possède des fonctionnalités
+ * pour interagir avec ses tuiles voisines.
+ * 
+ * @version 1.0
+ * @author Moncef STITI, Khalid CHENOUNA, Lenny FOULOU
+ */
 public class Tile extends Cell {
 
+  /** Biomes associés aux côtés de la tuile. */
   private HashMap<TileOrientation, Biome> sideBiomes = new HashMap<>();
 
-
+    /**
+    * Constructeur pour une tuile avec des biomes spécifiques.
+    * 
+    * @param board  Le plateau de jeu auquel la tuile appartient.
+    * @param x      Coordonnée X de la tuile.
+    * @param y      Coordonnée Y de la tuile.
+    * @param radius Rayon de la tuile.
+    * @param biomes Liste des biomes affectés aux côtés de la tuile.
+    */
   public Tile(Board board, int x, int y, int radius, Biome... biomes) {
     super(board, x, y, radius);
     TileOrientation[] sides = TileOrientation.values();
@@ -28,23 +46,47 @@ public class Tile extends Cell {
     }
   }
 
- 
+     /**
+    * Constructeur pour une tuile avec des biomes assignés aléatoirement.
+    * 
+    * @param board  Le plateau de jeu auquel la tuile appartient.
+    * @param x      Coordonnée X de la tuile.
+    * @param y      Coordonnée Y de la tuile.
+    * @param radius Rayon de la tuile.
+    */
   public Tile(Board board, int x, int y, int radius) {
     super(board, x, y, radius);
     this.assignRandomBiomes();
   }
 
-  
+    /**
+     * Constructeur pour une tuile positionnée en utilisant un point central, avec des biomes spécifiques.
+     * 
+     * @param board  Le plateau de jeu auquel la tuile appartient.
+     * @param center Point central de la tuile.
+     * @param radius Rayon de la tuile.
+     * @param biomes Liste des biomes affectés aux côtés de la tuile.
+     */
   public Tile(Board board, Point center, int radius, Biome... biomes) {
     this(board, center.x, center.y, radius, biomes);
   }
 
-
+    /**
+     * Constructeur pour une tuile positionnée en utilisant un point central, avec des biomes assignés aléatoirement.
+     * 
+     * @param board  Le plateau de jeu auquel la tuile appartient.
+     * @param center Point central de la tuile.
+     * @param radius Rayon de la tuile.
+     */
   public Tile(Board board, Point center, int radius) {
     this(board, center.x, center.y, radius);
   }
 
- 
+    /**
+     * Définit les biomes associés aux côtés de la tuile.
+     * 
+     * @param biomes Liste des biomes à assigner.
+     */
   public void setBiomes(Biome... biomes) {
     TileOrientation[] sides = TileOrientation.values();
     for (int i = 0; i < sides.length; i++) {
@@ -52,7 +94,12 @@ public class Tile extends Cell {
     }
   }
 
-  
+    /**
+     * Assigne aléatoirement des biomes aux côtés de la tuile.
+     * 
+     * Utilise le moteur de jeu pour générer des biomes aléatoires, tout en garantissant
+     * une répartition équilibrée entre deux biomes.
+     */  
   public void assignRandomBiomes() {
     Game game = this.getBoard().getGame();
     Biome[] biomes = Biome.values();
@@ -74,11 +121,21 @@ public class Tile extends Cell {
     }
   }
 
+    /**
+     * Obtient le biome associé à un côté spécifique de la tuile.
+     * 
+     * @param side Le côté de la tuile.
+     * @return Le biome associé.
+     */
   public Biome getBiome(TileOrientation side) {
     return this.sideBiomes.get(side);
   }
 
- 
+     /**
+     * Obtient le biome dominant de la tuile.
+     * 
+     * @return Le biome dominant ou {@code null} en cas d'égalité parfaite.
+     */
   public Biome getDominantBiome() {
     TileOrientation[] sides = TileOrientation.values();
 
@@ -106,7 +163,18 @@ public class Tile extends Cell {
     return null;
   }
 
-
+  /**
+   * Retourne les biomes associés à chaque côté de la tuile.
+   * 
+   * Cette méthode récupère les biomes pour tous les côtés de la tuile en respectant
+   * l'ordre des orientations définies par l'énumération {@link TileOrientation}.
+   * Les biomes sont placés dans un tableau où l'index correspond à l'ordre ordinal
+   * de chaque orientation.
+   * 
+   * @return Un tableau de {@link Biome} représentant les biomes associés à chaque côté
+   *         de la tuile. La longueur du tableau est égale au nombre de côtés dans 
+   *         {@link TileOrientation}.
+   */
   public Biome[] getBiomes() {
     Biome[] biomes = new Biome[TileOrientation.values().length];
     for (TileOrientation side : TileOrientation.values()) {
@@ -115,7 +183,11 @@ public class Tile extends Cell {
     return biomes;
   }
 
-  
+    /**
+     * Tourne la tuile dans le sens horaire ou anti-horaire.
+     * 
+     * @param clockwise {@code true} pour tourner dans le sens horaire, {@code false} sinon.
+     */
   public void rotate(boolean clockwise) {
     TileOrientation[] sides = TileOrientation.values();
     HashMap<TileOrientation, Biome> newBiomesMap = new HashMap<>();
@@ -130,7 +202,12 @@ public class Tile extends Cell {
     this.repaint();
   }
 
- 
+     /**
+     * Vérifie si la tuile contient un biome donné.
+     * 
+     * @param biome Le biome recherché.
+     * @return {@code true} si la tuile contient le biome, sinon {@code false}.
+     */
   public boolean containsBiome(Biome biome) {
     for (TileOrientation side : TileOrientation.values()) {
       if (this.getBiome(side) == biome) {
@@ -140,7 +217,18 @@ public class Tile extends Cell {
     return false;
   }
 
-
+  /**
+   * Vérifie si la tuile donnée est adjacente à la tuile actuelle.
+   * 
+   * Cette méthode calcule la distance euclidienne entre les coordonnées des deux
+   * tuiles et détermine si la distance est suffisamment proche pour être considérée
+   * comme adjacente dans une grille hexagonale. La distance attendue entre deux tuiles
+   * adjacentes est calculée en fonction du rayon des tuiles et de la géométrie hexagonale.
+   * 
+   * @param otherTile La tuile à tester pour l'adjacence.
+   * @return {@code true} si la tuile donnée est adjacente à la tuile actuelle, 
+   *         sinon {@code false}.
+   */
   public boolean isAdjacentTo(Tile otherTile) {
     
     int radius = this.getRadius(); // Utilisation du rayon pour la distance correcte
@@ -165,7 +253,18 @@ public class Tile extends Cell {
     return false;
 }
 
-
+  /**
+   * Récupère la tuile voisine dans une direction donnée.
+   * 
+   * Cette méthode calcule les coordonnées de la tuile voisine en fonction de
+   * la direction spécifiée (orientation) et de la distance relative dans une
+   * grille hexagonale. Elle utilise le rayon de la tuile pour déterminer la
+   * distance correcte.
+   * 
+   * @param orientation La direction (orientation) du voisin souhaité par rapport à la tuile actuelle.
+   *                    Les valeurs possibles sont définies dans {@link TileOrientation}.
+   * @return La tuile voisine dans la direction spécifiée, ou {@code null} si aucune tuile n'existe à cet endroit.
+   */
 public Tile getNeighbor(TileOrientation orientation) {
   int radius = this.getRadius();
   int neighborX = this.getXCoord();
@@ -194,7 +293,13 @@ public Tile getNeighbor(TileOrientation orientation) {
 }
 
 
-
+    /**
+     * Détermine le côté de la tuile en fonction d'une position (x, y).
+     * 
+     * @param x Coordonnée X relative.
+     * @param y Coordonnée Y relative.
+     * @return Le côté correspondant.
+     */
   public TileOrientation determineSide(int x, int y) {
     int radius = this.getRadius();
     TileOrientation[] sides = TileOrientation.values();
@@ -221,6 +326,14 @@ public Tile getNeighbor(TileOrientation orientation) {
     return floorBiome.equals(dominantBiome) ? sides[ceilSide] : sides[floorSide];
   }
 
+    /**
+     * Dessine la tuile à une position donnée avec une échelle spécifique.
+     * 
+     * @param g     Contexte graphique.
+     * @param x     Coordonnée X où dessiner.
+     * @param y     Coordonnée Y où dessiner.
+     * @param scale Échelle du dessin.
+     */
   protected void drawTileAt(Graphics g, int x, int y, float scale) {
       // Sauvegarde de l'état actuel du graphique
       Graphics2D g2d = (Graphics2D) g.create();

src/fr/monkhanny/dorfromantik/game/TilePanningTransition.java

@@ -2,12 +2,37 @@ package fr.monkhanny.dorfromantik.game;
 
 import fr.monkhanny.dorfromantik.listeners.TilePanningActionListener;
 
-
+/**
+ * Représente une transition de panoramique pour déplacer la vue du plateau de jeu.
+ * 
+ * Cette classe permet de déplacer la vue du plateau de jeu avec une animation fluide en
+ * ajustant les décalages cibles sur les axes X et Y, répartis sur un nombre défini d'étapes.
+ * 
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class TilePanningTransition {
+
+    /** Le plateau de jeu sur lequel le panoramique est appliqué. */
     private Board board;
-    private int targetOffsetX, targetOffsetY;
+
+    /** Décalage cible sur l'axe X, en pixels ou en unités logiques. */
+    private int targetOffsetX;
+
+    /** Décalage cible sur l'axe Y, en pixels ou en unités logiques. */
+    private int targetOffsetY;
+
+    /** Nombre d'étapes de l'animation pour atteindre la cible. */
     private int steps;
 
+    /**
+     * Initialise une transition de panoramique avec les paramètres spécifiés.
+     * 
+     * @param board Le plateau de jeu affecté par le panoramique.
+     * @param targetOffsetX Décalage cible à atteindre sur l'axe X.
+     * @param targetOffsetY Décalage cible à atteindre sur l'axe Y.
+     * @param steps Nombre d'étapes de l'animation pour effectuer le panoramique.
+     */
     public TilePanningTransition(Board board, int targetOffsetX, int targetOffsetY, int steps) {
         this.board = board;
         this.targetOffsetX = targetOffsetX;
@@ -15,6 +40,12 @@ public class TilePanningTransition {
         this.steps = steps;
     }
 
+    /**
+     * Démarre la transition de panoramique.
+     * 
+     * Cette méthode crée un écouteur d'animation (`TilePanningActionListener`) configuré avec
+     * les cibles et les étapes définies, puis démarre l'animation si aucune n'est déjà en cours.
+     */
     public void start() {
         // Créer un listener d'animation
         TilePanningActionListener listener = new TilePanningActionListener(board, targetOffsetX, targetOffsetY, steps);

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

@@ -5,19 +5,59 @@ import java.util.List;
 import java.util.Objects;
 import javax.swing.*;
 
+/**
+ * Un composant graphique Swing pour afficher un histogramme représentant les scores moyens des groupes.
+ * Chaque barre représente un groupe et est colorée différemment en fonction de s'il est mis en surbrillance.
+ * 
+ * Les barres sont ombrées et incluent des labels pour indiquer les scores moyens, ainsi que les noms des groupes.
+ * 
+ * @version 1.0
+ * @author Moncef STITI
+ */
 public class BarChartPanel extends JPanel {
+
+    /** Liste des scores moyens des groupes. */
     private final List<Integer> groupAverages;
+    
+    /** Indice du groupe mis en surbrillance. */
     private final int highlightedGroup;
+
+    /** Couleur de la barre pour le groupe du joueur. */
     private static final Color PLAYER_GROUP_COLOR = new Color(204, 0, 0);
+
+    /** Couleur des barres pour les autres groupes. */
     private static final Color OTHER_GROUP_COLOR = new Color(0, 0, 204);
+
+    /** Couleur de l'ombre projetée par les barres. */
     private static final Color SHADOW_COLOR = new Color(0, 0, 0, 60);
+
+    /** Couleur du texte affiché sur les barres. */
     private static final Color TEXT_COLOR = Color.BLACK;
+
+    /** Police pour le label "Score moyen". */
     private static final Font AVERAGE_FONT = new Font("Arial", Font.ITALIC, 12);
+
+    /** Police pour les labels des groupes. */
     private static final Font GROUP_LABEL_FONT = new Font("Arial", Font.BOLD, 16);
+
+    /** Police pour afficher les scores des groupes. */
     private static final Font SCORE_FONT = new Font("Arial", Font.BOLD, 14);
+
+    /** Marge autour de l'histogramme. */
     private static final int PADDING = 30;
+
+    /** Décalage de l'ombre en pixels. */
     private static final int SHADOW_OFFSET = 2;
 
+    /**
+     * Construit un nouveau panneau d'histogramme.
+     * 
+     * @param groupAverages Liste des scores moyens des groupes.
+     *                      La taille de cette liste détermine le nombre de barres dans l'histogramme.
+     * @param highlightedGroup Indice du groupe à mettre en surbrillance.
+     *                         Si cet indice ne correspond à aucun groupe, aucune barre ne sera mise en surbrillance.
+     * @throws NullPointerException si {@code groupAverages} est {@code null}.
+     */
     public BarChartPanel(List<Integer> groupAverages, int highlightedGroup) {
         this.groupAverages = Objects.requireNonNull(groupAverages, "Group averages cannot be null");
         this.highlightedGroup = highlightedGroup;
@@ -28,6 +68,11 @@ public class BarChartPanel extends JPanel {
         setAlignmentX(Component.CENTER_ALIGNMENT);
     }
 
+    /**
+     * Dessine le composant graphique, incluant les barres, les labels et les scores.
+     * 
+     * @param g Le contexte graphique.
+     */
     @Override
 protected void paintComponent(Graphics g) {
     super.paintComponent(g);

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

@@ -6,19 +6,49 @@ import fr.monkhanny.dorfromantik.controller.ButtonHoverAnimationListener;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * Classe gérant les animations de survol pour les boutons (JButton).
+ * Permet d'effectuer des transitions douces sur les propriétés du bouton, telles que
+ * la couleur du texte et la taille de la police, lors du survol ou du départ de la souris.
+ * 
+ * @version 1.0
+ * @author Khalid CHENOUNA
+ */
 public class ButtonHoverAnimator {
 
+    /** Le bouton pour lequel les animations sont appliquées. */
     private final JButton button;
+
+    /** La couleur d'origine du texte du bouton. */
     private final Color originalColor;
+
+    /** La police d'origine du bouton, partagée pour toutes les instances. */
     private static Font originalFont;
+
+    /** Timer utilisé pour exécuter les animations avec une transition fluide. */
     private Timer animationTimer;
        
+    /**
+     * Constructeur de l'animateur de bouton.
+     * Initialise les propriétés d'origine (couleur, police) et associe l'animation au bouton spécifié.
+     *
+     * @param button Le bouton cible de l'animation.
+     */
     public ButtonHoverAnimator(JButton button) {
         this.button = button;
         this.originalColor = button.getForeground();
         ButtonHoverAnimator.originalFont = button.getFont();
     }
     
+    /**
+     * Lance l'animation de transition sur le bouton, en fonction de l'état du survol.
+     *
+     * @param entering Indique si la souris entre ou quitte le bouton :
+     *                 <ul>
+     *                   <li><code>true</code> : la souris entre sur le bouton (animation d'entrée).</li>
+     *                   <li><code>false</code> : la souris quitte le bouton (animation de sortie).</li>
+     *                 </ul>
+     */
     public void startAnimation(boolean entering) {
         if (animationTimer != null && animationTimer.isRunning()) {
             animationTimer.stop();
@@ -29,6 +59,13 @@ public class ButtonHoverAnimator {
         animationTimer.start();
     }
     
+    /**
+     * Met à jour la taille de la police originale partagée entre toutes les instances.
+     * Cette méthode est utile pour adapter dynamiquement la police en fonction de
+     * la taille de la fenêtre ou des préférences de l'utilisateur.
+     *
+     * @param newFontSize La nouvelle taille de la police.
+     */
     public static void updateOriginalFont(float newFontSize) {
         originalFont = originalFont.deriveFont(newFontSize);
     }

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

@@ -8,14 +8,32 @@ import javax.swing.*;
 import java.util.List;
 import java.util.Arrays;
 
-
+/**
+ * Représente un panneau contenant les boutons du menu principal du jeu.
+ * Ce panneau dispose d'une disposition verticale et intègre des boutons avec un style personnalisé.
+ * 
+ * @version 1.0
+ * @author Khalid CHENOUNA
+ */
 public class ButtonPanel extends JPanel {
 
+    /** Bouton pour démarrer une nouvelle partie. */
     private JButton newGameButton;
+
+    /** Bouton pour accéder aux instructions sur comment jouer. */
     private JButton howToPlayButton;
+
+    /** Bouton pour accéder aux paramètres du jeu. */
     private JButton settingsButton;
+
+    /** Bouton pour quitter l'application. */
     private JButton exitButton;
 
+     /**
+     * Constructeur qui initialise le panneau avec des boutons et applique un style personnalisé.
+     * 
+     * @param fontSize La taille de police initiale des boutons.
+     */
     public ButtonPanel(float fontSize) {
         // Paramétrage de l'apparence du panneau
         this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
@@ -47,26 +65,58 @@ public class ButtonPanel extends JPanel {
         MainMenuMouseController gestionSouris = new MainMenuMouseController(this);
     }
 
+    /**
+     * Retourne le bouton "Jouer".
+     *
+     * @return Le bouton "Jouer".
+     */
     public JButton getNewGameButton() {
         return newGameButton;
     }
 
+    /**
+     * Retourne le bouton "Comment jouer ?".
+     *
+     * @return Le bouton "Comment jouer ?".
+     */
     public JButton getHowToPlayButton() {
         return howToPlayButton;
     }
 
+    /**
+     * Retourne le bouton "Paramètres".
+     *
+     * @return Le bouton "Paramètres".
+     */
     public JButton getSettingsButton() {
         return settingsButton;
     }
 
+    /**
+     * Retourne le bouton "Quitter".
+     *
+     * @return Le bouton "Quitter".
+     */
     public JButton getExitButton() {
         return exitButton;
     }
 
+     /**
+     * Retourne la liste de tous les boutons contenus dans ce panneau.
+     *
+     * @return Une liste des boutons : "Jouer", "Comment jouer ?", "Paramètres" et "Quitter".
+     */
     public List<JButton> getButtons() {
         return Arrays.asList(newGameButton, howToPlayButton, settingsButton, exitButton);
     }
 
+    /**
+     * Met à jour la taille des polices des boutons en fonction de la largeur de la fenêtre.
+     * Cette méthode ajuste dynamiquement la taille des polices pour s'adapter
+     * à différents écrans ou résolutions.
+     *
+     * @param windowWidth La largeur actuelle de la fenêtre.
+     */
     public void updateButtonFonts(int windowWidth) {
         // Mettre à jour la police des boutons avec la taille ajustée
         float newFontSize = windowWidth / 30f;