ajout java doc + Makefile + mariadb.jar

src/main/Makefile

@@ -4,16 +4,16 @@ JC = javac
 JCFLAGS = -encoding UTF-8 -implicit:none -cp classes -d classes
 
 JVM = java
-JVMFLAGS = -cp classes
+JVMFLAGS = -cp "classes:mariadb.jar"
+MANIFEST_FILE = META-INF/MANIFEST.MF
 
 ### RÈGLES ESSENTIELLES ###
 
-Main.class: Main.java java/controller/MenuController.class java/view/MenuView.class java/controller/GameController.class
+Main.class: Main.java  java/view/MenuView.class java/controller/GameController.class java/view/App.class
 	$(JC) $(JCFLAGS) Main.java
 
-# Compilation des contrôleurs
+###java/controller/MenuController.class: java/controller/MenuController.java java/model/MenuModel.class java/view/MenuView.class java/controller/NewListener.class java/controller/QuiListener.class java/controller/SeriesSelector.class
-java/controller/MenuController.class: java/controller/MenuController.java java/model/MenuModel.class java/view/MenuView.class java/controller/NewListener.class java/controller/QuiListener.class java/controller/ResListener.class
+###$(JC) $(JCFLAGS) java/controller/MenuController.java
-	$(JC) $(JCFLAGS) java/controller/MenuController.java
 
 java/controller/NewListener.class: java/controller/NewListener.java
 	$(JC) $(JCFLAGS) java/controller/NewListener.java
@@ -21,10 +21,13 @@ java/controller/NewListener.class: java/controller/NewListener.java
 java/controller/QuiListener.class: java/controller/QuiListener.java
 	$(JC) $(JCFLAGS) java/controller/QuiListener.java
 
-java/controller/ResListener.class: java/controller/ResListener.java java/view/GameView.class java/view/App.class 
+java/controller/ResListener.class: java/controller/ResListener.java java/view/GameView.class java/view/App.class
 	$(JC) $(JCFLAGS) java/controller/ResListener.java
 
-java/controller/GameController.class: java/controller/GameController.java java/controller/TilePlacer.class java/model/Tile.class java/controller/CameraController.class java/controller/HexagonMouseListener.class
+java/controller/SeriesSelector.class: java/controller/SeriesSelector.java java/view/GameView.class
+	$(JC) $(JCFLAGS) java/controller/SeriesSelector.java
+
+java/controller/GameController.class: java/controller/GameController.java java/controller/ScoreGameContext.class java/controller/TilePlacer.class java/model/Tile.class java/controller/CameraController.class java/controller/HexagonMouseListener.class java/model/TileDatabaseManager.class java/controller/SendScore.class java/controller/GameEndListener.class
 	$(JC) $(JCFLAGS) java/controller/GameController.java
 
 java/controller/MouseWheelController.class: java/controller/MouseWheelController.java java/view/HexagonTile.class java/controller/GameController.class
@@ -39,17 +42,15 @@ java/controller/CameraController.class: java/controller/CameraController.java ja
 java/controller/GameContext.class: java/controller/GameContext.java java/view/HexagonTile.class
 	$(JC) $(JCFLAGS) java/controller/GameContext.java
 
-# Compilation des vues
+java/view/GameView.class: java/view/GameView.java java/view/App.class java/view/ScoreView.class java/controller/MouseWheelController.class java/controller/GameController.class java/view/HexagonTile.class
-java/view/GameView.class: java/view/GameView.java java/controller/MouseWheelController.class java/controller/GameController.class java/view/HexagonTile.class
 	$(JC) $(JCFLAGS) java/view/GameView.java
 
-java/view/MenuView.class: java/view/MenuView.java java/view/BtnPerso.class java/view/ButtonHoverListener.class
+java/view/MenuView.class: java/view/MenuView.java java/view/BtnPerso.class java/view/ButtonHoverListener.class java/controller/SeriesSelector.class
 	$(JC) $(JCFLAGS) java/view/MenuView.java
 
 java/view/HexagonTile.class: java/view/HexagonTile.java java/model/Tile.class java/model/TerrainType.class
 	$(JC) $(JCFLAGS) java/view/HexagonTile.java
 
-# Compilation des modèles
 java/model/MenuModel.class: java/model/MenuModel.java
 	$(JC) $(JCFLAGS) java/model/MenuModel.java
 
@@ -59,17 +60,12 @@ java/model/Tile.class: java/model/Tile.java java/model/TerrainType.class
 java/model/TerrainType.class: java/model/TerrainType.java
 	$(JC) $(JCFLAGS) java/model/TerrainType.java
 
-# Compilation des composants individuels
 java/view/BtnPerso.class: java/view/BtnPerso.java
 	$(JC) $(JCFLAGS) java/view/BtnPerso.java
 
 java/view/ButtonHoverListener.class: java/view/ButtonHoverListener.java
 	$(JC) $(JCFLAGS) java/view/ButtonHoverListener.java
 
-java/view/App.class: java/view/App.java
-	$(JC) $(JCFLAGS) java/view/App.java
-
-# Compilation des handlers
 java/controller/MousePressHandler.class: java/controller/MousePressHandler.java java/controller/CameraControllerListener.class
 	$(JC) $(JCFLAGS) java/controller/MousePressHandler.java
 
@@ -82,12 +78,51 @@ java/controller/CameraControllerListener.class: java/controller/CameraController
 java/controller/TilePlacer.class: java/controller/TilePlacer.java
 	$(JC) $(JCFLAGS) java/controller/TilePlacer.java
 
+java/model/TileDatabaseManager.class: java/model/TileDatabaseManager.java java/model/Tile.class
+	$(JC) $(JCFLAGS) java/model/TileDatabaseManager.java
+
+java/controller/ScoreGameContext.class: java/controller/ScoreGameContext.java java/controller/GameContext.class java/model/Pocket.class java/model/TerrainType.class java/view/HexagonTile.class
+	$(JC) $(JCFLAGS) java/controller/ScoreGameContext.java
+
+java/controller/SerieListener.class: java/controller/SerieListener.java java/controller/GameController.class
+	$(JC) $(JCFLAGS) java/controller/SerieListener.java
+
+java/model/Pocket.class: java/model/Pocket.java java/model/TerrainType.class
+	$(JC) $(JCFLAGS) java/model/Pocket.java
+
+java/controller/SendScore.class: java/controller/SendScore.java
+	$(JC) $(JCFLAGS) java/controller/SendScore.java
+
+java/controller/GameEndListener.class: java/controller/GameEndListener.java
+	$(JC) $(JCFLAGS) java/controller/GameEndListener.java
+
+java/view/App.class: java/view/App.java
+	$(JC) $(JCFLAGS) java/view/App.java
+
+java/view/ScoreView.class: java/view/ScoreView.java java/view/App.class java/controller/AllScore.class java/view/BtnPerso.class 
+	$(JC) $(JCFLAGS) java/view/ScoreView.java
+
+java/controller/AllScore.class: java/controller/AllScore.java
+	$(JC) $(JCFLAGS) java/controller/AllScore.java
+
 ### RÈGLE POUR COPIER LES IMAGES ###
 
 copy-images:
 	mkdir -p classes/java/view/img
 	if [ -d java/view/img ]; then cp -r java/view/img/* classes/java/view/img/; else echo "Le répertoire java/view/img n'existe pas."; fi
 
+$(MANIFEST_FILE):
+	mkdir -p META-INF
+	echo "Manifest-Version: 1.0" > $(MANIFEST_FILE)
+	echo "Main-Class: main.Main" >> $(MANIFEST_FILE)
+	echo "Class-Path: mariadb.jar" >> $(MANIFEST_FILE)
+
+### ARCHIVE JAR ###
+
+Main.jar: Main.class copy-images $(MANIFEST_FILE)
+	mkdir -p classes/java/view/img  
+	jar cfm Main.jar $(MANIFEST_FILE) -C classes .
+
 ### RÈGLES OPTIONNELLES ###
 
 run: Main.class copy-images
@@ -95,12 +130,10 @@ run: Main.class copy-images
 
 clean:
 	-rm -f classes/**/*.class
-
-mrproper: clean
 	-rm -rf classes/java/view/img
 
 ### BUTS FACTICES ###
 
-.PHONY: run clean mrproper copy-images
+.PHONY: run clean copy-images
 
 ### FIN ###

src/main/java/model/Pocket.java

@@ -1,40 +1,81 @@
+// src/main/java/model/Pocket.java
 package model;
 
 import java.awt.Point;
 import java.util.HashSet;
 import java.util.Set;
 
+/**
+ * La classe <code>Pocket</code> représente un groupe de tuiles adjacentes
+ * d'un même type de terrain dans le jeu.
+ */
 public class Pocket {
     private TerrainType terrainType;  // Type de terrain de cette Pocket
     private Set<Point> tiles;  // Ensemble des positions des tuiles de la Pocket
 
+    /**
+     * Constructeur de la classe <code>Pocket</code>.
+     *
+     * @param terrainType Le type de terrain associé à cette Pocket.
+     */
     public Pocket(TerrainType terrainType) {
         this.terrainType = terrainType;
         this.tiles = new HashSet<>();
     }
 
+    /**
+     * Récupère le type de terrain de cette Pocket.
+     *
+     * @return Le type de terrain de cette Pocket.
+     */
     public TerrainType getTerrainType() {
         return terrainType;
     }
 
+    /**
+     * Obtient la taille de cette Pocket, c'est-à-dire le nombre de tuiles.
+     *
+     * @return La taille de la Pocket.
+     */
     public int getSize() {
         return tiles.size();
     }
 
+    /**
+     * Ajoute une tuile à cette Pocket à une position donnée.
+     *
+     * @param position La position de la tuile à ajouter.
+     */
     public void addTile(Point position) {
         tiles.add(position);
     }
 
+    /**
+     * Vérifie si une tuile à une position donnée est présente dans cette Pocket.
+     *
+     * @param position La position de la tuile à vérifier.
+     * @return <code>true</code> si la tuile est présente, sinon <code>false</code>.
+     */
     public boolean containsTile(Point position) {
         return tiles.contains(position);
     }
 
+    /**
+     * Fusionne cette Pocket avec une autre Pocket si elles partagent le même type de terrain.
+     *
+     * @param other La Pocket à fusionner.
+     */
     public void merge(Pocket other) {
         if (this.terrainType == other.terrainType) {
             this.tiles.addAll(other.tiles);
         }
     }
 
+    /**
+     * Calcule le score de cette Pocket basé sur la taille au carré.
+     *
+     * @return Le score de la Pocket.
+     */
     public int calculateScore() {
         return getSize() * getSize();  // La taille au carré donne le score
     }

src/main/java/model/TerrainType.java

@@ -1,5 +1,14 @@
+// src/main/java/model/TerrainType.java
 package model;
 
+/**
+ * L'énumération <code>TerrainType</code> représente les différents types de terrains
+ * disponibles dans le jeu.
+ */
 public enum TerrainType {
-    MER, CHAMP, PRE, FORET, MONTAGNE
+    MER,     // Représente le type de terrain "mer"
+    CHAMP,   // Représente le type de terrain "champ"
+    PRE,     // Représente le type de terrain "pré"
+    FORET,   // Représente le type de terrain "forêt"
+    MONTAGNE // Représente le type de terrain "montagne"
 }

src/main/java/model/Tile.java

@@ -1,11 +1,24 @@
+// src/main/java/model/Tile.java
 package model;
 
+/**
+ * La classe <code>Tile</code> représente une tuile dans le jeu, qui peut contenir un ou deux types de terrains.
+ * Chaque tuile a un identifiant unique, un tableau de types de terrains, et gère sa rotation.
+ */
 public class Tile {
     private int id;  // ID de la tuile
     private TerrainType[] terrains;  // Tableau contenant deux types de terrains (ex. MER, FORET)
     private int segmentsForTerrain1;  // Nombre de segments pour le premier terrain
     private int rotation;  // Rotation de la tuile (en multiple de 60 degrés)
 
+    /**
+     * Constructeur pour créer une nouvelle tuile avec deux types de terrains.
+     *
+     * @param id                L'identifiant de la tuile.
+     * @param terrain1         Le premier type de terrain.
+     * @param terrain2         Le deuxième type de terrain.
+     * @param segmentsForTerrain1 Le nombre de segments pour le premier terrain.
+     */
     public Tile(int id, TerrainType terrain1, TerrainType terrain2, int segmentsForTerrain1) {
         this.id = id;
         this.terrains = new TerrainType[]{terrain1, terrain2};
@@ -13,7 +26,12 @@ public class Tile {
         this.rotation = 0;  // Initialisation de la rotation à 0
     }
 
-    // Renvoie le terrain pour l'index donné (0 ou 1)
+    /**
+     * Renvoie le terrain pour l'index donné (0 ou 1).
+     *
+     * @param index L'index du terrain à récupérer.
+     * @return Le type de terrain à l'index spécifié, ou null si l'index est invalide.
+     */
     public TerrainType getTerrain(int index) {
         if (index >= 0 && index < terrains.length) {
             return terrains[index];
@@ -21,7 +39,12 @@ public class Tile {
         return null;  // Retourne null si l'index est invalide
     }
 
-    // Méthode pour obtenir le terrain associé à un segment spécifique (prend en compte la rotation)
+    /**
+     * Méthode pour obtenir le terrain associé à un segment spécifique (prend en compte la rotation).
+     *
+     * @param segmentIndex L'index du segment.
+     * @return Le type de terrain associé au segment spécifié.
+     */
     public TerrainType getTerrainForSegment(int segmentIndex) {
         int adjustedIndex = (segmentIndex - rotation + 6) % 6;
         if (adjustedIndex < segmentsForTerrain1) {
@@ -31,18 +54,34 @@ public class Tile {
         }
     }
 
+    /**
+     * Fait tourner la tuile dans le sens horaire.
+     */
     public void rotateClockwise() {
         rotation = (rotation + 1) % 6;
     }
 
+    /**
+     * Fait tourner la tuile dans le sens antihoraire.
+     */
     public void rotateCounterClockwise() {
         rotation = (rotation + 5) % 6;  // Tourner dans le sens inverse
     }
 
+    /**
+     * Renvoie la rotation actuelle de la tuile.
+     *
+     * @return La rotation de la tuile en multiples de 60 degrés.
+     */
     public int getRotation() {
         return rotation;
     }
 
+    /**
+     * Renvoie l'identifiant de la tuile.
+     *
+     * @return L'identifiant de la tuile.
+     */
     public int getId() {
         return id;
     }

src/main/java/model/TileDatabaseManager.java

@@ -1,14 +1,25 @@
+// src/main/java/model/TileDatabaseManager.java
 package model;
 
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * La classe <code>TileDatabaseManager</code> gère les interactions avec la base de données
+ * pour récupérer les tuiles associées à une série donnée.
+ */
 public class TileDatabaseManager {
     private static final String DB_URL = "jdbc:mariadb://dwarves.iut-fbleau.fr/akagundu";
     private static final String USER = "akagundu";
     private static final String PASSWORD = "dersim62Lodek";
 
+    /**
+     * Récupère les tuiles associées à une série spécifique à partir de la base de données.
+     *
+     * @param idSeries L'identifiant de la série pour laquelle les tuiles doivent être récupérées.
+     * @return Une liste d'objets <code>Tile</code> associés à la série spécifiée.
+     */
     public List<Tile> getTilesBySeries(int idSeries) {
         List<Tile> tiles = new ArrayList<>();
         String query = "SELECT id, couleur1, couleur2, chiffre FROM Tuile WHERE id_serie = ? ORDER BY id ASC";
@@ -38,7 +49,4 @@ public class TileDatabaseManager {
         }
         return tiles;
     }
-    
-    
-    
 }

src/main/java/view/App.java

@@ -3,17 +3,31 @@ package view;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * La classe <code>App</code> représente l'application de jeu qui gère les vues de l'interface utilisateur.
+ * Elle utilise un <code>CardLayout</code> pour naviguer entre différentes vues telles que le menu, le jeu et le score.
+ */
 public class App {
+    /** Nom de la vue du menu. */
     public static final String MENU_VIEW = "MenuView";
+    
+    /** Nom de la vue du jeu. */
     public static final String GAME_VIEW = "GameView";
+    
+    /** Nom de la vue des scores. */
     public static final String SCORE_VIEW = "ScoreView";
 
+    /** La fenêtre principale de l'application. */
     private static JFrame frame;
+    
+    /** Le layout utilisé pour gérer l'affichage des vues. */
     private static CardLayout cardLayout;
+    
+    /** Le panneau principal contenant les différentes vues. */
     private static JPanel mainPanel;
 
     static {
-        frame = new JFrame("DorfJavatik");
+        frame = new JFrame("Application de Jeu");
         cardLayout = new CardLayout();
         mainPanel = new JPanel(cardLayout);
         frame.setContentPane(mainPanel);
@@ -22,16 +36,32 @@ public class App {
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     }
 
+    /**
+     * Retourne l'instance de la fenêtre principale.
+     * 
+     * @return L'instance de <code>JFrame</code> de l'application.
+     */
     public static JFrame getInstance() {
         return frame;
     }
 
+    /**
+     * Ajoute une vue au panneau principal de l'application.
+     * 
+     * @param view Le panneau de la vue à ajouter.
+     * @param viewName Le nom sous lequel la vue sera identifiée.
+     */
     public static void addView(JPanel view, String viewName) {
         mainPanel.add(view, viewName);
     }
 
+    /**
+     * Affiche la vue spécifiée dans le panneau principal.
+     * 
+     * @param viewName Le nom de la vue à afficher.
+     */
     public static void showView(String viewName) {
         cardLayout.show(mainPanel, viewName);
         frame.setVisible(true);
     }
-}
+}

src/main/java/view/BtnPerso.java

@@ -3,12 +3,20 @@ package view;
 import javax.swing.JButton;
 import java.awt.*;
 
-
+/**
+ * La classe <code>BtnPerso</code> représente un bouton personnalisé utilisé dans l'interface utilisateur.
+ * Elle étend la classe <code>JButton</code> et applique des styles spécifiques pour le rendu du bouton.
+ */
 public class BtnPerso extends JButton {
 
+    /**
+     * Constructeur de la classe <code>BtnPerso</code>.
+     * 
+     * @param text Le texte à afficher sur le bouton.
+     */
     public BtnPerso(String text){
         super(text);
-        setFont(new Font("Helvetica", Font.BOLD,25));
+        setFont(new Font("Helvetica", Font.BOLD, 25));
         setContentAreaFilled(false);
         setForeground(Color.BLACK);
         setBorderPainted(false);
@@ -16,9 +24,7 @@ public class BtnPerso extends JButton {
         setFocusPainted(false);
         setBackground(new Color(243, 171, 115, 150));
 
-        Dimension d = new Dimension(200,50);
+        Dimension d = new Dimension(200, 50);
         setPreferredSize(d);
     }
-
-    
 }

src/main/java/view/ButtonHoverListener.java

@@ -4,11 +4,23 @@ import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.awt.Color;
 
+/**
+ * La classe <code>ButtonHoverListener</code> écoute les événements de la souris pour les boutons de type <code>BtnPerso</code>.
+ * Elle change la couleur de fond du bouton lorsque la souris survole ou quitte le bouton.
+ */
 public class ButtonHoverListener extends MouseAdapter {
 
-    private final Color hoverColor = new Color(200, 150, 100, 200); // Couleur de hover avec transparence
+    /** Couleur de survol avec transparence. */
-    private final Color normalColor = new Color(243, 171, 115, 150); // Couleur normale avec transparence
+    private final Color hoverColor = new Color(200, 150, 100, 200);
+    
+    /** Couleur normale avec transparence. */
+    private final Color normalColor = new Color(243, 171, 115, 150);
 
+    /**
+     * Change la couleur de fond du bouton lorsqu'il est survolé par la souris.
+     * 
+     * @param e L'événement de souris déclenché lorsque la souris entre dans le bouton.
+     */
     @Override
     public void mouseEntered(MouseEvent e) {
         if (e.getSource() instanceof BtnPerso) { // Applique uniquement aux boutons de type BtnPerso
@@ -17,6 +29,11 @@ public class ButtonHoverListener extends MouseAdapter {
         }
     }
 
+    /**
+     * Restaure la couleur de fond normale du bouton lorsque la souris quitte le bouton.
+     * 
+     * @param e L'événement de souris déclenché lorsque la souris quitte le bouton.
+     */
     @Override
     public void mouseExited(MouseEvent e) {
         if (e.getSource() instanceof BtnPerso) { // Applique uniquement aux boutons de type BtnPerso

src/main/java/view/GameView.java

@@ -6,15 +6,39 @@ import controller.*;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * La classe <code>GameView</code> représente la vue principale du jeu.
+ * Elle gère l'affichage de la grille hexagonale, la prévisualisation de la prochaine tuile,
+ * et l'affichage du score. Elle implémente l'interface <code>GameEndListener</code>
+ * pour gérer la fin du jeu.
+ */
 public class GameView extends JPanel implements GameEndListener {
+    /** Le panneau de la grille hexagonale. */
     private JPanel gridPanel;
+    
+    /** La prévisualisation de la prochaine tuile. */
     private HexagonTile nextTilePreview;
+    
+    /** Le contrôleur du jeu. */
     private GameController gameController;
+    
+    /** Le contrôleur de la caméra. */
     private CameraController cameraController;
+    
+    /** Le contexte du jeu. */
     private GameContext gameContext;
+    
+    /** Étiquette affichant le score actuel. */
     private JLabel scoreLabel;
+    
+    /** Identifiant de la série de tuiles. */
     private int seriesId;
 
+    /**
+     * Constructeur de la classe <code>GameView</code>.
+     * 
+     * @param seriesId L'identifiant de la série de tuiles à charger.
+     */
     public GameView(int seriesId) {
         this.seriesId = seriesId;
         setLayout(new BorderLayout());
@@ -55,6 +79,11 @@ public class GameView extends JPanel implements GameEndListener {
         controlPanel.add(backButton);
     }
 
+    /**
+     * Crée et retourne un panneau représentant la grille hexagonale.
+     * 
+     * @return Un <code>JPanel</code> configuré pour la grille hexagonale.
+     */
     private JPanel createHexagonGrid() {
         JPanel panel = new JPanel();
         panel.setLayout(null);
@@ -63,6 +92,9 @@ public class GameView extends JPanel implements GameEndListener {
         return panel;
     }
 
+    /**
+     * Centre le panneau de la grille dans la vue.
+     */
     private void centerGridPanel() {
         int centerX = (getWidth() - gridPanel.getPreferredSize().width) / 2;
         int centerY = (getHeight() - gridPanel.getPreferredSize().height) / 2;
@@ -70,6 +102,11 @@ public class GameView extends JPanel implements GameEndListener {
         gameContext.repaintGrid(gridPanel);
     }
 
+    /**
+     * Crée et retourne un panneau de contrôle contenant les informations sur la prochaine tuile et le score.
+     * 
+     * @return Un <code>JPanel</code> configuré pour le panneau de contrôle.
+     */
     private JPanel createControlPanel() {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
@@ -92,6 +129,11 @@ public class GameView extends JPanel implements GameEndListener {
         return panel;
     }
 
+    /**
+     * Méthode appelée lorsque le jeu se termine.
+     * 
+     * @param finalScore Le score final du jeu.
+     */
     @Override
     public void onGameEnd(int finalScore) {
         SwingUtilities.invokeLater(() -> {

src/main/java/view/HexagonTile.java

@@ -7,11 +7,27 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.geom.Path2D;
 
+/**
+ * La classe <code>HexagonTile</code> représente une tuile hexagonale dans le jeu.
+ * Elle gère l'affichage d'une tuile avec ses segments de terrain et 
+ * indique si la tuile est un placeholder.
+ */
 public class HexagonTile extends JPanel {
+    /** La tuile associée à cet hexagone. */
     private Tile tile;
+    
+    /** La position de l'hexagone sur la grille. */
     private Point position;
-    private boolean isPlaceholder;  // Indicateur si l'hexagone est un placeholder
+    
+    /** Indicateur si l'hexagone est un placeholder. */
+    private boolean isPlaceholder;
 
+    /**
+     * Constructeur de la classe <code>HexagonTile</code>.
+     * 
+     * @param position La position de l'hexagone sur la grille.
+     * @param isPlaceholder Indique si cet hexagone est un placeholder.
+     */
     public HexagonTile(Point position, boolean isPlaceholder) {
         this.position = position;
         this.isPlaceholder = isPlaceholder;
@@ -19,24 +35,50 @@ public class HexagonTile extends JPanel {
         setPreferredSize(new Dimension(100, 100));
     }
 
+    /**
+     * Récupère la position de l'hexagone.
+     * 
+     * @return La position de l'hexagone.
+     */
     public Point getPosition() {
         return position;
     }
 
+    /**
+     * Définit la tuile associée à cet hexagone.
+     * 
+     * @param tile La tuile à associer.
+     */
     public void setTile(Tile tile) {
         this.tile = tile;
         this.isPlaceholder = false;  // Une fois la tuile posée, ce n'est plus un placeholder
         repaint();
     }
 
+    /**
+     * Récupère la tuile associée à cet hexagone.
+     * 
+     * @return La tuile associée.
+     */
     public Tile getTile() {
         return tile;
     }
 
+    /**
+     * Vérifie si l'hexagone est rempli avec une tuile.
+     * 
+     * @return <code>true</code> si l'hexagone contient une tuile, sinon <code>false</code>.
+     */
     public boolean isFilled() {
         return this.tile != null;
     }
 
+    /**
+     * Méthode de peinture du composant.
+     * Dessine l'hexagone et ses segments de terrain, ou un placeholder si aucun terrain n'est présent.
+     * 
+     * @param g Le contexte graphique dans lequel dessiner.
+     */
     @Override
     protected void paintComponent(Graphics g) {
         super.paintComponent(g);
@@ -62,6 +104,14 @@ public class HexagonTile extends JPanel {
         g2d.draw(largeHexagon);
     }
 
+    /**
+     * Dessine les segments de terrain associés à la tuile.
+     * 
+     * @param g2d Le contexte graphique dans lequel dessiner.
+     * @param centerX La coordonnée X du centre de l'hexagone.
+     * @param centerY La coordonnée Y du centre de l'hexagone.
+     * @param radius Le rayon de l'hexagone.
+     */
     private void drawTerrainSegments(Graphics2D g2d, int centerX, int centerY, int radius) {
         // Parcourt les segments de 0 à 5 pour dessiner chaque segment en fonction du terrain associé
         for (int i = 0; i < 6; i++) {
@@ -71,6 +121,14 @@ public class HexagonTile extends JPanel {
         }
     }
 
+    /**
+     * Crée un hexagone à partir des coordonnées centrales et du rayon.
+     * 
+     * @param centerX La coordonnée X du centre de l'hexagone.
+     * @param centerY La coordonnée Y du centre de l'hexagone.
+     * @param radius Le rayon de l'hexagone.
+     * @return La forme hexagonale créée.
+     */
     private Shape createHexagon(int centerX, int centerY, int radius) {
         Path2D hexagon = new Path2D.Double();
         for (int i = 0; i < 6; i++) {
@@ -87,6 +145,12 @@ public class HexagonTile extends JPanel {
         return hexagon;
     }
 
+    /**
+     * Récupère la couleur associée à un type de terrain.
+     * 
+     * @param terrain Le type de terrain à évaluer.
+     * @return La couleur correspondant au type de terrain.
+     */
     private Color getTerrainColor(TerrainType terrain) {
         if (terrain == null) {
             return Color.WHITE;

src/main/java/view/HowToPlayView.java

@@ -3,8 +3,17 @@ package view;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * La classe <code>HowToPlayView</code> représente une boîte de dialogue
+ * qui fournit des instructions sur le fonctionnement du jeu.
+ */
 public class HowToPlayView extends JDialog {
 
+    /**
+     * Constructeur de la classe <code>HowToPlayView</code>.
+     * 
+     * @param parent La fenêtre parent qui déclenche cette boîte de dialogue.
+     */
     public HowToPlayView(JFrame parent) {
         super(parent, "Comment Jouer", true);
         
@@ -21,6 +30,7 @@ public class HowToPlayView extends JDialog {
         JLabel instruction2 = new JLabel("Poser des tuiles : clique gauche sur un petit hexagone");
         JLabel instruction3 = new JLabel("Orientation des tuiles : Molette de la souris");
 
+        // Ajoute les instructions à la boîte de dialogue
         for (JLabel label : new JLabel[]{instruction1, instruction2, instruction3}) {
             label.setFont(new Font("Helvetica", Font.PLAIN, 20));
             label.setAlignmentX(Component.CENTER_ALIGNMENT);

src/main/java/view/MenuView.java

@@ -5,6 +5,11 @@ import controller.SeriesSelector;
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * La classe <code>MenuView</code> représente l'interface utilisateur principale
+ * du menu du jeu, incluant des options pour reprendre une partie, démarrer une nouvelle partie,
+ * et afficher les instructions du jeu.
+ */
 public class MenuView extends JPanel {
 
     private BtnPerso resumeButton;
@@ -21,15 +26,26 @@ public class MenuView extends JPanel {
     private ImageIcon quit;
     private JLabel labelImg;
 
+    /**
+     * Constructeur de la classe <code>MenuView</code>.
+     * Initialise le menu et ses composants.
+     */
     public MenuView() {
         initMenu();
     }
 
+    /**
+     * Définit le sélecteur de séries pour le menu.
+     * 
+     * @param seriesSelector Le sélecteur de séries à définir.
+     */
     public void setSeriesSelector(SeriesSelector seriesSelector) {
         this.seriesSelector = seriesSelector;
     }
 
-    // Méthode pour afficher les boutons de sélection de série
+    /**
+     * Affiche les boutons de sélection de série.
+     */
     public void showSeriesButtons() {
         howToPlayPanel.setVisible(false);
         centeredPanel.removeAll();
@@ -40,7 +56,9 @@ public class MenuView extends JPanel {
         repaint();
     }
 
-    // Méthode pour afficher/masquer le panneau "Comment jouer"
+    /**
+     * Affiche ou masque le panneau "Comment jouer".
+     */
     private void toggleHowToPlay() {
         seriesPanel.setVisible(false);
         howToPlayPanel.setVisible(!howToPlayPanel.isVisible());
@@ -51,6 +69,9 @@ public class MenuView extends JPanel {
         repaint();
     }
 
+    /**
+     * Initialise le menu et ses composants.
+     */
     private void initMenu() {
         panelCote = new JPanel(new GridBagLayout());
         GridBagConstraints gbc = new GridBagConstraints();
@@ -116,6 +137,11 @@ public class MenuView extends JPanel {
         add(centeredPanel, BorderLayout.CENTER);
     }
 
+    /**
+     * Crée et retourne le panneau affichant les instructions de jeu.
+     * 
+     * @return Un panneau contenant les instructions de jeu.
+     */
     private JPanel createHowToPlayPanel() {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
@@ -145,6 +171,11 @@ public class MenuView extends JPanel {
         return panel;
     }
 
+    /**
+     * Crée et retourne le panneau de sélection des séries.
+     * 
+     * @return Un panneau contenant les boutons de sélection de séries.
+     */
     private JPanel createSeriesPanel() {
         JPanel panel = new JPanel(new GridLayout(2, 2, 10, 10));
         panel.setOpaque(false);
@@ -172,4 +203,4 @@ public class MenuView extends JPanel {
         super.paintComponent(g);
         g.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this);
     }
-}
+}

src/main/java/view/ScoreView.java

@@ -7,18 +7,33 @@ import java.util.ArrayList;
 import java.util.Collections;
 import controller.AllScore;
 
+/**
+ * La classe <code>ScoreView</code> représente l'interface utilisateur
+ * affichant le score final du joueur ainsi que le top 10 des scores
+ * pour une série spécifique à la fin d'une partie.
+ */
 public class ScoreView extends JPanel {
     private int seriesId;
     private int finalScore;
-    private final Color hoverColor = new Color(200, 150, 100,150);
+    private final Color hoverColor = new Color(200, 150, 100, 150);
     private final Color normalColor = new Color(243, 171, 115, 150); // Couleur avec transparence
 
+    /**
+     * Constructeur de la classe <code>ScoreView</code>.
+     * 
+     * @param seriesId L'identifiant de la série.
+     * @param finalScore Le score final du joueur.
+     */
     public ScoreView(int seriesId, int finalScore) {
         this.seriesId = seriesId;
         this.finalScore = finalScore;
         initScoreView();
     }
 
+    /**
+     * Initialise l'interface utilisateur pour afficher le score final
+     * et le top 10 des scores.
+     */
     private void initScoreView() {
         setLayout(new BorderLayout());
         setBackground(normalColor);