feat(Game.java): ajout commentaire et amelioration

- enlever record (meilleur comprehension)
- mis un static pour savoir si il y a un server d'affichage

src/Game.java

@@ -1,89 +1,168 @@
 import java.awt.Color;
+import java.awt.GraphicsEnvironment;
 import java.util.ArrayList;
 
+/**
+ * La classe {@link Game} représente le moteur principal du jeu.
+ * <p>
+ * Elle contient le modèle (les voitures, l'état du jeu, la carte),
+ * la vue (Track, Dashboard, Rankboard) et la logique de contrôle
+ * (pause, boucle de jeu, observateurs).
+ * </p>
+ */
 public class Game
 {
-	public static record CarInfo(String name, Color color) {}
+    /**
+     * {@link CarInfo} est une structure simple qui contient les informations
+     * nécessaires pour créer une voiture dans le jeu : son nom et sa couleur.
+     */
+    public static class CarInfo
+    {
+        /** Nom de la voiture */
+        public final String name;
+        /** Couleur de la voiture */
+        public final Color color;
 
+        public CarInfo(String name, Color color)
+        {
+            this.name = name;
+            this.color = color;
+        }
+    }
+
+    /**
+     * Builder pour créer une instance de {@link Game} de façon fluide.
+     * <p>
+     * Permet d'ajouter des voitures, de définir la carte, l'état initial et
+     * le temps entre les étapes du jeu avant de construire l'objet final.
+     * </p>
+     */
     public static class Builder
     {
-        /**
+        /** Liste des voitures à créer pour le jeu */
-         * Liste des voitures ajoutées au jeu.
-         * On utilise ArrayList pour pouvoir ajouter/supprimer des voitures dynamiquement.
-         */
         private ArrayList<CarInfo> cars = new ArrayList<>();
+        /** État initial du jeu */
         private State state = new State();
+        /** Temps entre chaque "step" du jeu (en millisecondes) */
         private int time = 1000;
-
+        /** Carte sur laquelle se déroule le jeu */
         private Map map = null;
 
+        /** Ajoute une voiture à la liste */
         public Builder addCar(CarInfo car)
         {
             cars.add(car);
             return this;
         }
 
+        /** Supprime une voiture de la liste */
         public Builder remCar(CarInfo car)
         {
             cars.remove(car);
             return this;
         }
 
+        /** Définit la carte du jeu */
         public Builder setMap(Map map)
         {
             this.map = map;
             return this;
         }
 
+        /** Définit l'état initial du jeu */
         public Builder setState(State s)
         {
             this.state = s;
             return this;
         }
 
+        /** Définit le temps entre chaque étape du jeu */
         public Builder setTime(int time)
         {
             this.time = time;
             return this;
         }
 
+        /**
+         * Construit l'instance de {@link Game} avec les paramètres définis.
+         * <p>
+         * Si la carte n'a pas été définie, le programme s'arrête.
+         * </p>
+         */
         public Game build()
         {
             if (map == null)
             {
-				System.err.println("Vous devez declarer la map avant de build!");
+                System.err.println("Vous devez définir une carte avant de construire le jeu !");
                 System.exit(1);
             }
             return new Game(map, cars, state, time);
         }
     }
 
+    /** Carte sur laquelle le jeu se déroule */
     private final Map map;
+    /** État du jeu (par exemple, positions, carburant) */
     private final State state;
+    /** Temps entre chaque étape du jeu en millisecondes */
     private final int time;
 
+    /** Liste des voitures du jeu */
     private final ArrayList<Car> cars = new ArrayList<>();
+    /** Liste des observateurs pour la mise à jour des vues */
     private final ArrayList<GObserver> obs = new ArrayList<>();
 
+    /** Indique si le jeu est en pause */
     private boolean isPaused = false;
 
-	public Game(Map map, ArrayList<CarInfo> cars, State state, int time)
+    /** 
+     * Bloc statique exécuté au chargement de la classe pour vérifier
+     * si le programme dispose d'un environnement graphique.
+     */
+    static {
+        if (GraphicsEnvironment.isHeadless())
+        {
+            System.err.println("Aucun serveur d'affichage trouvé");
+            System.exit(1);
+        }
+    }
+
+    /**
+     * Constructeur principal.
+     *
+     * @param map carte du jeu
+     * @param carInfos liste des informations des voitures à créer
+     * @param state état initial du jeu
+     * @param time temps entre chaque étape du jeu
+     */
+    public Game(Map map, ArrayList<CarInfo> carInfos, State state, int time)
     {
         this.map = map;
         this.state = state;
         this.time = time;
 
-		init(cars);
+        init(carInfos);
     }
 
-	
+    /**
+     * Initialise le jeu en créant les vues et les objets {@link Car}.
+     * <p>
+     * Chaque voiture obtient un Dashboard, la piste est affichée avec Track,
+     * et le Rankboard est créé pour afficher le classement.
+     * </p>
+     *
+     * @param carInfos liste des informations des voitures
+     * @return l'instance de Game
+     */
     private Game init(ArrayList<CarInfo> carInfos)
     {
+        // Création des vues principales
         new Track(map, cars, "Piste Formule 1", 1000, 500, 1, 1);
         new Rankboard("Score", cars, 200, 200, 0, 510);
 
         final int loop = map.getPathSize();
 
+        // Création de chaque voiture avec son Dashboard
         int i = 0;
         for (CarInfo ci : carInfos)
         {
@@ -97,6 +176,14 @@ public class Game
         return this;
     }
 
+    /**
+     * Vérifie si le jeu est terminé.
+     * <p>
+     * Le jeu est fini si au moins une voiture a épuisé son carburant.
+     * </p>
+     *
+     * @return true si le jeu est terminé
+     */
     private boolean isFinish()
     {
         for (Car car : cars)
@@ -107,18 +194,38 @@ public class Game
         return false;
     }
 
+    /**
+     * Ajoute un observateur pour recevoir les mises à jour du jeu.
+     *
+     * @param o observateur
+     * @return instance de Game pour chaîner
+     */
     public Game addObserver(GObserver o)
     {
         obs.add(o);
         return this;
     }
 
+    /**
+     * Supprime un observateur.
+     *
+     * @param o observateur
+     * @return instance de Game pour chaîner
+     */
     public Game remObserver(GObserver o)
     {
         obs.remove(o);
         return this;
     }
 
+    /**
+     * Bascule l'état de pause du jeu.
+     * <p>
+     * Si le jeu était en pause, il est relancé et les threads en attente sont notifiés.
+     * </p>
+     *
+     * @return true si le jeu est maintenant en pause
+     */
     public synchronized boolean togglePause()
     {
         if (isPaused) notifyAll();
@@ -127,11 +234,19 @@ public class Game
         return isPaused;
     }
 
+    /**
+     * Exécute un cycle du jeu
+     * <p>
+     * Chaque voiture effectue son action, puis les observateurs sont notifiés.
+     * La boucle attend si le jeu est en pause.
+     * </p>
+     *
+     * @throws InterruptedException si le thread est interrompu pendant wait()
+     */
     private synchronized void step() throws InterruptedException
     {
         for (int i = 0; i < cars.size(); i++)
         {
-			// pause du jeu, while si on notifyall sans faire exprès un autre bout de code
             while (isPaused)
                 wait();
 
@@ -148,6 +263,13 @@ public class Game
         }
     }
 
+    /**
+     * Boucle principale du jeu.
+     * <p>
+     * Tant que le jeu n'est pas terminé, on exécute les étapes et on met à jour
+     * les vues toutes les 'time' millisecondes.
+     * </p>
+     */
     public void run()
     {
         while (!isFinish())
@@ -159,74 +281,9 @@ public class Game
                 Thread.sleep(time);
             }
             catch (InterruptedException e)
-			{ e.printStackTrace(); }
+            {
+                e.printStackTrace();
+            }
         }
     }
 }
-
-
-// 	private Game init(int pnumber, State state)
-// 	{
-// 		// ajout de voiture
-// 		int loop = map.getPathSize();
-
-// 		for (int i = 0; i < pnumber; i++) 
-// 		{
-// 			cars[i] = new Car(loop, state);
-
-// 			Color color = (i < colors.size()) ? colors.get(i) : Color.BLUE;
-// 			// new Dashboard(cars[i], "Voiture " + (i+1), this::togglePause, color, 300, 300, 300, 300*i);
-// 		}
-		
-// 		// new Track();
-// 		// new Rankboard();
-// 		return this;
-// 	}
-
-// 	private boolean isFinish()
-// 	{
-// 		for (Car car : cars)
-// 		{
-// 			if (car.getFuel() == 0)
-// 				return true;
-// 		}
-// 		return false;
-// 	}
-
-
-// 	private void step() throws InterruptedException
-// 	{
-// 		for (Car c : cars)
-// 		{
-// 			synchronized (this)
-// 			{
-// 				// pause du jeu, while si on notifyall sans faire exprès un autre bout de code
-// 				while (paused)
-// 				{
-// 					wait();
-// 				}
-// 			}
-// 			c.run();
-
-// 			if (!isSuccess)
-// 			{
-// 				System.err.println("Une erreur s'est produite pendant le jeu.");
-// 				System.exit(1);
-// 			}
-// 		}
-// 	}
-
-// 	public void run()
-// 	{
-// 		while (!isFinish())
-// 		{
-// 			try 
-// 			{
-// 				step();
-// 				Thread.sleep(time);
-// 			} 
-// 			catch (InterruptedException e) 
-// 			{ e.printStackTrace(); }
-// 		}
-// 	}
-// }

src/Main.java

@@ -1,10 +1,7 @@
 import java.awt.Color;
-import java.awt.GraphicsEnvironment;
 
 public class Main {
 	public static void main(String[] args) throws InterruptedException
-	{
-		if (!GraphicsEnvironment.isHeadless())
 	{
 		Integer[][] map = new Integer[][]
 		{
@@ -30,5 +27,4 @@ public class Main {
 							.build();
 		game.run();
 	}
-	}
 }