feat: ajout multiple fonction et factorisation

src/Car.java

@@ -1,88 +1,182 @@
 import java.awt.Color;
+import java.awt.Point;
+import java.util.List;
 import java.util.Random;
 
 /**
  * {@link Car} représente une voiture qui avance sur un circuit en boucles.
- * Chaque appel à {@link #run()} avance la voiture d'une certaine position et fait perdre de l'essence.
+ * Chaque appel à {@link #run()} avance la voiture d'une certaine position et
+ * fait perdre de l'essence.
  * Quand la position atteint la fin de la boucle, un nouveau tour est compté.
  * <p>
  * La voiture consomme du carburant à chaque déplacement, et son score
- * est calculé en fonction du nombre de tours complétés et de sa progression sur le tour actuel.
+ * est calculé en fonction du nombre de tours complétés et de sa progression sur
+ * le tour actuel.
  * </p>
  */
-public class Car
+public class Car {
-{
     /** Générateur de nombres aléatoires pour simuler la progression */
-    private final Random rand = new Random();
+    private static final Random RANDOM = new Random();
 
     /** Couleur de la voiture pour l'affichage */
-    private Color color;
+    private final Color COLOR;
     /** Nom de la voiture */
-    private final String name;
+    private final String NAME;
-
     /** Position actuelle dans la boucle (entre 0 et loop) */
     private int pos = 0;
-
     /** Nombre de tours complétés */
     private int round = 0;
-
     /** Nombre de cases dans une boucle (doit être > 0) */
-    private final int loop;
+    private final Map MAP;
-
-    /** Référence à l'état du jeu, pour récupérer les paramètres comme la consommation */
-    private final State state;
-
     /** Carburant restant */
     private int fuel = 60;
 
     /**
      * Construit une nouvelle voiture.
      *
-     * @param name nom de la voiture
+     * @param name  nom de la voiture
      * @param color couleur de la voiture
-     * @param loop nombre de positions par boucle (doit être > 0)
+     * @param map
-     * @param state état global du jeu
      */
-    public Car(String name, Color color, int loop, State state)
+    public Car(String name, Color color, Map map) {
-    {
+        this.NAME = name;
-        if (loop <= 0)
+        this.COLOR = color;
-        {
+        this.MAP = map;
-            System.err.println("le tour de la piste doit etre positif");
+    }
-            System.exit(1);
+
+    public static enum State {
+        /**
+         * L'état NORMAL du Vehicule avance selon un chiffre au alentour de 1 à 6 cases
+         * par tour. Il consomme 6 unités de carburant à chaque tour. Si l'on
+         * accelere, il passe à l'état BOOST. Si on Rallenti, il passe à l'état LOW.
+         */
+        // @formatter:off
+        NORMAL(2, 1, 6) {
+            public State accelerate() { return BOOST; }
+            public State decelerate() { return LOW; }
+        },
+        
+        /**
+         * L'état BOOST du Vehicule avance selon un chiffre au alentour de 5 à 10 cases
+         * par tour. Il consomme 5 unités de carburant à chaque tour. Si l'on
+         * accelere, il reste sur son état et indique un message sur le tableau de bord.
+         * Si on Rallenti, il passe à l'état LOW.
+        */
+        BOOST(5, 5, 10) {
+            public State accelerate() { return this; }
+            public State decelerate() { return NORMAL; }
+        },
+        
+        /**
+         * L'état LOW du Vehicule avance selon un chiffre au alentour de 1 à 3 cases
+         * par tour. Il consomme 1 unités de carburant à chaque tour. Si l'on
+         * accelere, il passe à l'état NORMAL. Si on Rallenti, il passe à l'état STOPPED.
+        */
+        LOW(1, 1, 3) {
+            public State accelerate() { return NORMAL; }
+            public State decelerate() { return STOPPED; }
+        },
+        
+        /**
+         * L'état STOPPED du Vehicule n'avance pas. Il consomme aucune unités de
+         * carburant à chaque tour. Si l'on
+         * accelere, il passe à l'état LOW. Si on Rallenti, il reste sur son état et
+         * indique un message sur le tableau de bord.
+         */
+        STOPPED(0, 0, 0) {
+            public State accelerate() { return LOW; }
+            public State decelerate() { return this; }
+            @Override
+            public int move(int pos, int jump) { return pos; }
+            @Override
+            public int fuelConsumption(int fuel) { return fuel; }
+        },
+        /**
+         * L'état STOPPED du Vehicule n'avance pas. Il consomme aucune unités de
+         * carburant à chaque tour. Il reste immobile.
+         */
+        DAMAGED(0, 0, 0) {
+            public State accelerate() { return this; }
+            public State decelerate() { return this; }
+            
+            @Override
+            public int move(int pos, int jump) { return pos; }
+            @Override
+            public int fuelConsumption(int fuel) { return fuel; }
+            @Override
+            public boolean isDamaged() { return true; }
+            @Override
+            public State onDamageEnd() { return LOW; }
+        };
+        // @formatter:on
+
+        public final int FUELCOST;
+        public final int MAX;
+        public final int MIN;
+
+        private State(int fuelCost, int min, int max) {
+            this.FUELCOST = fuelCost;
+            this.MAX = max + 1;
+            this.MIN = min;
         }
 
-        this.name  = name;
+        public List<Integer> getInterval() {
-        this.color = color;
+            return List.of(MIN, MAX);
-        this.loop  = loop;
+        }
-        this.state = state;
+
+        public int fuelConsumption(int fuel) {
+            return fuel - FUELCOST;
+        }
+
+        public int move(int pos, int jump) {
+            return pos + jump;
+        }
+
+        public boolean isDamaged() {
+            return false;
+        }
+
+        public State onDamageEnd() {
+            return this;
+        }
+
+        public abstract State accelerate();
+
+        public abstract State decelerate();
     }
 
     /**
-     * Fait avancer la voiture d'un certain nombre de positions.
+     * Référence à l'état du jeu, pour récupérer les paramètres comme la
-     * <p>
+     * consommation
-     * Si la position atteint la fin de la boucle, le compteur de tours est incrémenté et
-     * la position revient à zéro.
-     * </p>
-     *
-     * @param move nombre de positions à avancer
-     * @return cette même instance (pour chaînage fluide)
      */
-    public Car makeMove(int move)
+    private State state = State.NORMAL;
-    {
+
-        pos += move;
+    private int damageRound = 0;
-        if (pos >= loop)
+
-        {
+    public void setDamage() {
-            round++;
+        damageRound = 5;
-            pos %= loop;
+        state = State.DAMAGED;
+    }
+
+    private boolean decreaseDamage() {
+        if (state.isDamaged()) {
+            if (--damageRound <= 0) {
+                state = state.onDamageEnd();
+            }
+            return true;
         }
+        return false;
+    }
+
+    public Car setState(State state) {
+        this.state = state;
         return this;
     }
 
     /**
      * @return la position actuelle dans la boucle
      */
-    public int getPosition()
+    public int getPosition() {
-    {
         return pos;
     }
 
@@ -90,62 +184,84 @@ public class Car
      * @return le score de la voiture, calculé comme :
      *         (nombre de tours + progression du tour) × 100
      */
-    public int getScore()
+    public int getScore() {
-    {
+        return (int) ((round + (float) pos / MAP.getPathSize()) * 100);
-        return (int) ((round + (float) pos / loop) * 100);
     }
 
     /**
      * @return le nombre de tours complétés
      */
-    public int getRound()
+    public int getRound() {
-    {
         return round;
     }
 
-    /**
-     * @return le nombre total de positions dans la boucle
-     */
-    public int getLoop()
-    {
-        return loop;
-    }
-
     /**
      * @return le carburant restant
      */
-    public int getFuel()
+    public int getFuel() {
-    {
         return fuel;
     }
 
+    /**
+     * Fait avancer la voiture d'un certain nombre de positions.
+     * <p>
+     * Si la position atteint la fin de la boucle, le compteur de tours est
+     * incrémenté et
+     * la position revient à zéro.
+     * </p>
+     *
+     * @param move nombre de positions à avancer
+     * @return cette même instance (pour chaînage fluide)
+     */
+    public void move() {
+        if (decreaseDamage()) {
+            System.out.println(NAME + " est en\taccident " + damageRound);
+            return;
+        }
+
+        int jump = RANDOM.nextInt(state.MIN, state.MAX);
+
+        for (int i = 0; i < jump; i++) {
+            pos = state.move(pos, 1);
+
+            Point point = MAP.getPath(pos);
+            Map.Circuit element = MAP.getElement(point.x, point.y);
+            
+            if (element.isYRoad() && element.getValue() < jump) {
+                System.out.println(NAME + " a un\taccident");
+                setDamage();
+                return;
+            }
+
+            if (pos >= MAP.getPathSize()) {
+                pos = 0;
+                round++;
+            }
+        }
+    }
+
     /**
      * Consomme du carburant en fonction de l'état du jeu.
      *
      * @return cette même instance pour chaînage
      */
-    public Car consumeFuel()
+    public void consumeFuel() {
-    {
+        fuel = state.fuelConsumption(fuel);
-        fuel -= state.getConsumption();
+        if (fuel < 0)
-        if (fuel < 0) fuel = 0; // sécurité
+            fuel = 0; // sécurité
-        return this;
     }
 
     /**
-     * Exécute une "étape" de la voiture : avance d'une position aléatoire et consomme du carburant.
+     * Exécute une "étape" de la voiture : avance d'une position aléatoire et
+     * consomme du carburant.
      * <p>
-     * La progression est déterminée par un intervalle aléatoire fourni par l'état du jeu.
+     * La progression est déterminée par un intervalle aléatoire fourni par l'état
+     * du jeu.
      * </p>
      */
-    public void run()
+    public void run() {
-    {
+        if (fuel > 0) {
-        if (fuel > 0)
+            move();
-        {
-            int[] interval = state.getInterval();
-            // avance aléatoire en fonction de l'interval
-            int random = rand.nextInt(interval[0], interval[1]);
-            
-            makeMove(random);
             consumeFuel();
         }
     }
@@ -153,34 +269,21 @@ public class Car
     /**
      * @return la position actuelle (synonyme de getPosition)
      */
-    public int getPos()
+    public int getPos() {
-    {
         return pos;
     }
 
     /**
      * @return la couleur de la voiture
      */
-    public Color getColor()
+    public Color getColor() {
-    {
+        return COLOR;
-        return color;
-    }
-
-    /**
-     * Définit la couleur de la voiture
-     *
-     * @param color nouvelle couleur
-     */
-    public void setColor(Color color)
-    {
-        this.color = color;
     }
 
     /**
      * @return nom de la voiture
      */
-    public String getName()
+    public String getName() {
-    {
+        return NAME;
-        return this.name;
     }
 }

src/GameView.java

@@ -9,7 +9,7 @@ import javax.swing.JFrame;
  * Chaque GameView est associée à une fenêtre JFrame et s'inscrit dans
  * la liste globale des vues pour permettre des mises à jour centralisées.
  */
-public abstract class GameView extends JComponent implements GObserver
+public abstract class GameView extends JComponent implements Game.observer 
 {
     /** Fenêtre associée à cette vue */
     protected final JFrame frame;
@@ -54,7 +54,7 @@ public abstract class GameView extends JComponent implements GObserver
 		frame.setContentPane(this);
 		// visibilité de la fenetre
         frame.setVisible(true);
-		// mettre un layout
+		// mettre un layout (la disposition des elements de la fenetre)
 		frame.setLayout(new BorderLayout());
 
         game.addObserver(this);

src/Main.java

@@ -1,37 +1,7 @@
-import java.awt.Color;
-
 public class Main {
-	public static void main(String[] args) throws InterruptedException
+    public static void main(String[] args) throws InterruptedException {
-	{
+        Map map = Game.GameFactory.defaultMap();
-		Integer[][] map = new Integer[][]
+        Game game = Game.GameFactory.defaultGame(map);
-		{
+        game.run();
-			{ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 },
+    }
-			{ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2, -1, -1,  5,  0 },
-			{ 0,  3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  2,  0,  0, -1,  0,  0, -1,  0 },
-			{ 0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1,  0,  0, -1,  0,  0, -1,  0 },
-			{ 0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1,  0,  0, -1,  0,  0, -1,  0 },
-			{ 0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2, -1, -1,  2,  0,  0, -1,  0 },
-			{ 0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1,  0 },
-			{ 0, -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1,  0 },
-			{ 0,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -3,  0 },
-			{ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 },
-		};
-		
-		Map m = Map.fromInts(map);
-
-		Game game = new Game.Builder()
-			.addCar(new Game.CarInfo("Voiture à LUWIK", Color.BLUE))
-			.addCar(new Game.CarInfo("Voiture à CHARAZADE", Color.PINK))
-			.addCar(new Game.CarInfo("Voiture de UPEC", Color.RED))
-			.setTime(1000)
-			.setMap(m)
-			.addVisual(Dashboard.class, "Voiture à LUWIK", 300, 200, 1000, 0)
-			.addVisual(Dashboard.class, "Voiture à CHARAZADE", 300, 200, 1000, 200)
-			.addVisual(Dashboard.class, "Voiture de UPEC", 300, 200, 1000, 400)
-			.addVisual(Track.class, "Piste Formule 1", 1000, 500, 1, 1)
-			.addVisual(Rankboard.class, "Score", 200, 200, 0, 510)
-			.build();
-
-		game.run();
-	}
 }

src/Map.java

@@ -3,179 +3,311 @@ import java.util.ArrayList;
 import java.util.function.Function;
 
 /**
- * <p> <code>Map</code> représente le circuit de course.</p>
+ * <p>
- * <p>Cette classe contient: </p>
+ * <code>Map</code> représente le circuit de course.
+ * </p>
+ * <p>
+ * Cette classe contient:
+ * </p>
  * <ul>
- * 		<li>Un tableau 2D de Circuit.Cell</li>
+ * <li>Un tableau 2D de Circuit.Cell</li>
- * 		<li>Une liste de Points qui représente le chemin pour la voiture entre <code>START</code> et <code>FINISH</code></li>
+ * <li>Une liste de Points qui représente le chemin pour la voiture entre
+ * <code>START</code> et <code>FINISH</code></li>
  * </ul>
  */
-public class Map
+public class Map {
-{
+    /**
-    /** 
+     * Représente une cellule du circuit.
+     * <p>
+     * Chaque cellule possède un type ({@link Cell}) et éventuellement une valeur
+     * numérique (par exemple pour indiquer une intensité, une vitesse, ou un
+     * identifiant de route).
+     * </p>
+     */
+    public static class Circuit {
+        /**
+         * <code>Cell</code> est un enum
+         * représentant les différents types de
+         * cases qui composent le circuit de
+         * course.
+         */
+        public static enum Cell {
+            /**
+             * Case hors piste, non
+             * praticable par les
+             * voitures.
+             */
+            EMPTY,
+
+            /**
+             * Case de route normale
+             * sur laquelle les voitures
+             * peuvent circuler.
+             */
+            ROAD,
+
+            /**
+             * Case correspondant à la
+             * ligne de départ du circuit.
+             */
+            START,
+
+            /**
+             * Case correspondant à la
+             * ligne d'arrivée du circuit.
+             */
+            FINISH,
+
+            /**
+             * Case de route jaune, plus
+             * d'information sur le
+             * livrable 2
+             */
+            YROAD;
+        }
+
+        /** Type de la cellule (vide, route, départ, arrivée, etc.) */
+        private final Cell type;
+
+        /** Valeur associée à la cellule (optionnelle, dépend du type) */
+        private int value;
+
+        /**
+         * Construit une cellule avec un type défini et une valeur par défaut
+         * égale à l’indice ordinal du type.
+         *
+         * @param type le type de la cellule
+         */
+        public Circuit(Cell type) {
+            this.type = type;
+            this.value = type.ordinal();
+        }
+
+        /**
+         * Construit une cellule avec un type et une valeur spécifique.
+         *
+         * @param type  le type de la cellule
+         * @param value la valeur associée à la cellule
+         */
+        public Circuit(Cell type, int value) {
+            this.type = type;
+            this.value = value;
+        }
+
+        /**
+         * Modifie la valeur associée à la cellule.
+         *
+         * @param value la nouvelle valeur
+         * @return cette même instance (pour chaînage fluide)
+         */
+        public Circuit setValue(int value) {
+            this.value = value;
+            return this;
+        }
+
+        /**
+         * @return le type de la cellule
+         */
+        public Cell getType() {
+            return type;
+        }
+
+        /**
+         * @return la valeur associée à la cellule
+         */
+        public int getValue() {
+            return value;
+        }
+
+        /**
+         * Vérifie si la cellule est une route (ROAD ou YROAD).
+         *
+         * @return vrai si la cellule représente une route
+         */
+        public boolean isRoad() {
+            return type == Cell.ROAD || type == Cell.YROAD;
+        }
+
+        public boolean isYRoad() {
+            return type == Cell.YROAD;
+        }
+
+        /**
+         * Vérifie si la cellule est un point de départ.
+         *
+         * @return vrai si la cellule représente le départ
+         */
+        public boolean isStart() {
+            return type == Cell.START;
+        }
+
+        /**
+         * Vérifie si la cellule est un point d’arrivée.
+         *
+         * @return vrai si la cellule représente la fin du circuit
+         */
+        public boolean isFinish() {
+            return type == Cell.FINISH;
+        }
+    }
+
+    /**
      * Tableau 2D représentant le circuit.
      * Chaque élément est une instance de {@link Circuit}.
      */
-	private Circuit[][] map;
+    private Circuit[][] map;
-	/**
+    /**
      * Liste des coordonnées représentant le chemin du START au FINISH.
      */
-	private ArrayList<Point> pathMap;
+    private ArrayList<Point> pathMap;
 
-	private int width, height;
+    private int width, height;
 
-	/**
+    /**
      * Crée une nouvelle instance de Map à partir d'un tableau générique
      * et d'une fonction de transformation.
      *
-     * @param <T>  Type des éléments du tableau source
+     * @param <T>   Type des éléments du tableau source
-     * @param fn   Fonction qui transforme un élément T en Circuit
+     * @param fn    Fonction qui transforme un élément T en Circuit
      * @param array Tableau 2D d'éléments T
      * @return Une nouvelle instance de <code>Map</code>
      */
-	public static <T>Map create(Function<T, Circuit> fn, T[][] map)
+    public static <T> Map create(Function<T, Circuit> fn, T[][] map) {
-	{
+        int lenX = map[0].length;
-		int lenX = map[0].length;
+        int lenY = map.length;
-		int lenY = map.length;
 
-		Circuit[][] newmap = new Circuit[lenY][lenX];
+        Circuit[][] newmap = new Circuit[lenY][lenX];
 
-		for (int y = 0; y < lenY; y++)
+        for (int y = 0; y < lenY; y++) {
-		{
+            for (int x = 0; x < lenX; x++) {
-			for (int x = 0; x < lenX; x++)
+                newmap[y][x] = fn.apply(map[y][x]);
-			{
+            }
-				newmap[y][x] = fn.apply(map[y][x]);
+        }
-			}
-		}
 
-		return new Map(newmap);
+        return new Map(newmap);
-	}
+    }
 
-	/**
+    /**
      * Crée une map à partir d'un tableau d'entiers.
      * <ul>
-     *     <li>0 -> EMPTY</li>
+     * <li>0 -> EMPTY</li>
-     *     <li>-1 -> ROAD</li>
+     * <li>-1 -> ROAD</li>
-     *     <li>-2 -> START</li>
+     * <li>-2 -> START</li>
-     *     <li>-3 -> FINISH</li>
+     * <li>-3 -> FINISH</li>
-     *     <li>autres -> YROAD avec la valeur associée</li>
+     * <li>autres -> YROAD avec la valeur associée</li>
      * </ul>
      *
      * @param array Tableau 2D d'entiers
      * @return Une nouvelle instance de <code>Map</code>
      */
-	public static Map fromInts(Integer[][] map)
+    public static Map fromInts(Integer[][] map) {
-	{
+        return create((i) -> switch (i) {
-		return create((i) -> switch (i) {
+            case 0 -> new Circuit(Circuit.Cell.EMPTY);
-				case 0	-> new Circuit(Circuit.Cell.EMPTY);
+            case -1 -> new Circuit(Circuit.Cell.ROAD);
-				case -1	-> new Circuit(Circuit.Cell.ROAD);
+            case -2 -> new Circuit(Circuit.Cell.START);
-				case -2 -> new Circuit(Circuit.Cell.START);
+            case -3 -> new Circuit(Circuit.Cell.FINISH);
-				case -3	-> new Circuit(Circuit.Cell.FINISH);
+            default -> new Circuit(Circuit.Cell.YROAD, i);
-				default -> new Circuit(Circuit.Cell.YROAD, i);
+        }, map);
-		}, map);
+    }
-	}
 
     /**
      * Crée une map à partir d'un tableau de caractères.
      * <ul>
-     *     <li>'#' -> ROAD</li>
+     * <li>'#' -> ROAD</li>
-     *     <li>'S' -> START</li>
+     * <li>'S' -> START</li>
-     *     <li>'F' -> FINISH</li>
+     * <li>'F' -> FINISH</li>
-     *     <li>'0'-'9' -> YROAD avec valeur correspondante</li>
+     * <li>'0'-'9' -> YROAD avec valeur correspondante</li>
-     *     <li>autres -> EMPTY</li>
+     * <li>autres -> EMPTY</li>
      * </ul>
      *
      * @param array Tableau 2D de caractères
      * @return Une nouvelle instance de <code>Map</code>
      */
-	public static Map fromChars(Character[][] map)
+    public static Map fromChars(Character[][] map) {
-	{
+        return create((i) -> switch (i) {
-		return create((i) -> switch (i) {
+            case '#' -> new Circuit(Circuit.Cell.ROAD);
-				case '#'	-> new Circuit(Circuit.Cell.ROAD);
+            case 'S' -> new Circuit(Circuit.Cell.START);
-				case 'S' 	-> new Circuit(Circuit.Cell.START);
+            case 'F' -> new Circuit(Circuit.Cell.FINISH);
-				case 'F'	-> new Circuit(Circuit.Cell.FINISH);
+            case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' -> new Circuit(Circuit.Cell.YROAD, i - '0');
-				case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 
+            default -> new Circuit(Circuit.Cell.EMPTY);
-					-> new Circuit(Circuit.Cell.YROAD, i - '0');
+        }, map);
-				default -> new Circuit(Circuit.Cell.EMPTY);
+    }
-		}, map);
-	}
 
-	/**
+    /**
      * Constructeur privé utilisé par les méthodes statiques de création.
      * Initialise la map et construit le chemin.
      * Si la map est invalide ou impossible à résoudre, termine le programme.
      *
      * @param map Tableau 2D de <code>Circuit</code>
      */
-	private Map(Circuit[][] map) 
+    private Map(Circuit[][] map) {
-	{
+        this.map = map;
-		this.map = map;
 
-		this.width = map[0].length;
+        this.width = map[0].length;
-		this.height = map.length;
+        this.height = map.length;
 
-		boolean isPossible = this.buildPath();
+        boolean isPossible = this.buildPath();
-		
-		if (!isPossible)
-		{
-			System.err.println("La map contient des doublons ou est impossible à finir!");
-			System.exit(1);
-		}
-	}
 
-	/**
+        if (!isPossible) {
+            System.err.println("La map contient des doublons ou est impossible à finir!");
+            System.exit(1);
+        }
+    }
+
+    /**
      * Construit le chemin entre START et FINISH.
      *
      * @return true si un chemin valide existe, false sinon
      */
-	private boolean buildPath()
+    private boolean buildPath() {
-	{
+        Point[] p = bindPath();
-		Point[] p = bindPath();
 
-		if (p == null)
+        if (p == null)
-			return false;
+            return false;
 
-		Point start	= p[0];
+        Point start = p[0];
-		Point end	= p[1];
+        Point end = p[1];
 
-		this.pathMap = new ArrayList<>();
+        this.pathMap = new ArrayList<>();
-		return followPath(start, end);
+        return followPath(start, end);
-	}
+    }
 
     /**
      * Cherche les points START et FINISH sur la map.
      *
-     * @return Un tableau de 2 éléments : {START, FINISH} ou null si la map est invalide
+     * @return Un tableau de 2 éléments : {START, FINISH} ou null si la map est
+     *         invalide
      */
-	private Point[] bindPath()
+    private Point[] bindPath() {
-	{
+        Point start = null;
-		Point start	= null;
+        Point end = null;
-		Point end	= null;
 
-		for (int i = 0; i < map.length; i++)
+        for (int i = 0; i < map.length; i++) {
-		{
+            for (int j = 0; j < map[0].length; j++) {
-			for (int j = 0; j < map[0].length; j++)
+                switch (map[i][j].getType()) {
-			{
+                    case Circuit.Cell.START:
-				switch (map[i][j].getType())
+                        if (start == null)
-				{
+                            start = new Point(j, i);
-					case Circuit.Cell.START:
+                        else
-						if (start == null) start = new Point(j, i);
+                            return null;
-						else return null;
+                        break;
-						break;
+                    case Circuit.Cell.FINISH:
-					case Circuit.Cell.FINISH:
+                        if (end == null)
-						if (end == null) end = new Point(j, i);
+                            end = new Point(j, i);
-						else return null;
+                        else
-						break;
+                            return null;
-					default:
+                        break;
-						break;	
+                    default:
-				}
+                        break;
-			}
+                }
-		}
+            }
-		if (start == null || end == null) return null;
+        }
-		return new Point[] {start, end};	
+        if (start == null || end == null)
-	}
+            return null;
+        return new Point[] { start, end };
+    }
 
-	/**
+    /**
      * Suivi du chemin depuis START jusqu'à FINISH.
      * Parcours les cases ROAD et YROAD jusqu'à atteindre FINISH.
      *
@@ -183,130 +315,122 @@ public class Map
      * @param end   Point d'arrivée
      * @return true si un chemin complet a été trouvé, false sinon
      */
-	private boolean followPath(Point start, Point end)
+    private boolean followPath(Point start, Point end) {
-	{
+        // remettre à 0 la liste
-		// remettre à 0 la liste
+        pathMap.clear();
-		pathMap.clear();
 
-		// positions
+        // positions
-		Point current	= start;
+        Point current = start;
-		Point previous	= null;
+        Point previous = null;
 
-		int[][] coord = {
+        int[][] coord = {
-			{1,  0},	// haut
+                { 1, 0 }, // haut
-			{-1, 0},	// bas
+                { -1, 0 }, // bas
-			{0, -1},	// gauche
+                { 0, -1 }, // gauche
-			{0,  1}		// droite
+                { 0, 1 } // droite
-		};
+        };
 
-		// sécurité pour éviter les boucles infinie
+        // sécurité pour éviter les boucles infinie
-		int step	= 0;
+        int step = 0;
-		int max		= map.length * map[0].length;
+        int max = map.length * map[0].length;
-		for (; step < max; step++)
+        for (; step < max; step++) {
-		{
+            pathMap.add(current);
-			pathMap.add(current);
 
-			if (current.equals(end))
+            if (current.equals(end))
-				return true;
+                return true;
 
-			boolean moved = false;
+            boolean moved = false;
 
-			for (int[] pos : coord)
+            for (int[] pos : coord) {
-			{
+                int x = current.x + pos[1];
-				int x	= current.x + pos[1];
+                int y = current.y + pos[0];
-				int y	= current.y + pos[0];
 
-				if ((x >= 0 && map[0].length > x) && (y >= 0 && map.length > y))
+                if ((x >= 0 && map[0].length > x) && (y >= 0 && map.length > y)) {
-				{
+                    Point next = new Point(x, y);
-					Point next = new Point(x, y);
-					
-					if (next.equals(previous))
-						continue;
 
-					Circuit element		= getElement(x, y);
+                    if (next.equals(previous))
-					Circuit cElement	= getElement(current.x, current.y);
+                        continue;
-					if (element.isRoad() || (element.isFinish() && cElement.isRoad()))
-					{
-						previous = current;
-						current = next;
-						moved = true;
-						break;
-					}
-				}
-			}
 
-			// Si il est bloqué
+                    Circuit element = getElement(x, y);
-			if (!moved) break;
+                    Circuit cElement = getElement(current.x, current.y);
-		}
+                    if (element.isRoad() || (element.isFinish() && cElement.isRoad())) {
+                        previous = current;
+                        current = next;
+                        moved = true;
+                        break;
+                    }
+                }
+            }
 
-		return false;
+            // Si il est bloqué
-	}
+            if (!moved)
+                break;
+        }
 
-	/**
+        return false;
+    }
+
+    /**
      * Retourne l'objet Circuit à la position (x, y).
      *
      * @param x Coordonnée X
      * @param y Coordonnée Y
      * @return L'objet <code>Circuit</code>
      */
-	public Circuit getElement(int x, int y)
+    public Circuit getElement(int x, int y) {
-	{
+        return map[y][x];
-		return map[y][x];
+    }
-	}
 
-	/**
+    /**
      * Retourne le type de cellule (Circuit.Cell) à la position (x, y).
      *
      * @param x Coordonnée X
      * @param y Coordonnée Y
      * @return Le type de cellule <code>Circuit.Cell</code>
      */
-	public Circuit.Cell getCell(int x, int y)
+    public Circuit.Cell getCell(int x, int y) {
-	{
+        return getElement(x, y).getType();
-		return getElement(x, y).getType();
+    }
-	}
 
-	/**
+    /**
      * Retourne le point du chemin à l'indice donné.
      *
      * @param index Indice dans le chemin
      * @return Point correspondant
      */
-	public Point getPath(int i)
+    public Point getPath(int i) {
-	{
+        if (i < 0)
-		if (i < 0) return this.pathMap.getFirst();
+            return this.pathMap.getFirst();
-		else if (i >= this.pathMap.size()) return this.pathMap.getLast();
+        else if (i >= this.pathMap.size())
-		else return this.pathMap.get(i);
+            return this.pathMap.getLast();
-	}
+        else
+            return this.pathMap.get(i);
+    }
 
     /**
      * Retourne la taille du chemin trouvé.
      *
      * @return Nombre de points dans le chemin
      */
-	public int getPathSize()
+    public int getPathSize() {
-	{
+        return this.pathMap.size();
-		return this.pathMap.size();
+    }
-	}
 
-	/**
+    /**
      * Retourne la taille de la map en largueur.
      *
      * @return Nombre de {@link Cell} sur une largueur
      */
-	public int getWidth()
+    public int getWidth() {
-	{
+        return this.width;
-		return this.width;
+    }
-	}
 
-
+    /**
-	/**
      * Retourne la taille de la map en longueur.
      *
      * @return Nombre de {@link Cell} sur une longueur
      */
-	public int getHeight()
+    public int getHeight() {
-	{
+        return this.height;
-		return this.height;
+    }
-	}
 }

src/State.java

@@ -1,77 +0,0 @@
-/**
- * State représente l'état de conduite d'une voiture.
- * Il gère le mode de conduite actuel et fournit les paramètres associés
- * tels que la consommation de carburant et l'intervalle de mouvement aléatoire.
- */
-public class State
-{
-    /**
-     * Enum représentant les différents modes de conduite.
-     * Chaque mode définit :
-     * <ul>
-     *     <li>carbUsed : carburant consommé par mouvement</li>
-     *     <li>interval : intervalle pour générer un déplacement aléatoire</li>
-     * </ul>
-     */
-	public static enum DriveMode
-	{
-		//<CARBURANT PERDU>	<PREMIER INTERVAL>	<SECOND INTERVAL>
-		NORMAL(2, 1, 6);
-
-		/** Carburant consommé par mouvement dans ce mode */
-        public final int carbUsed;
-
-        /** Intervalle aléatoire de déplacement pour ce mode : [min, max] */
-        public final int[] interval;
-
-        /**
-         * Constructeur du mode de conduite.
-         *
-         * @param carbUsed Carburant consommé par mouvement
-         * @param fInterval Intervalle minimum du déplacement aléatoire
-         * @param sInterval Intervalle maximum du déplacement aléatoire
-         */
-		private DriveMode(int carbUsed, int fInterval, int sInterval)
-		{
-			this.carbUsed	= carbUsed;
-			interval		= new int[] {fInterval, sInterval};
-		}
-	}
-
-	/** Mode de conduite courant */
-	private DriveMode current = DriveMode.NORMAL;
-
-	    /**
-     * @return le mode de conduite actuel
-     */
-    public DriveMode get()
-    {
-        return current;
-    }
-
-    /**
-     * @return l'intervalle de déplacement aléatoire du mode courant
-     */
-    public int[] getInterval()
-    {
-        return current.interval;
-    }
-
-    /**
-     * @return la consommation de carburant du mode courant
-     */
-    public int getConsumption()
-    {
-        return current.carbUsed;
-    }
-
-    /**
-     * Change le mode de conduite actuel.
-     *
-     * @param mode nouveau mode de conduite
-     */
-    public void setDriveMode(DriveMode mode)
-    {
-        current = mode;
-    }
-}

src/Track.java

@@ -63,7 +63,7 @@ public class Track extends GameView {
 		// Parcours de toutes les cellules du circuit
 		for (int y = 0; y < rows; y++) {
 			for (int x = 0; x < cols; x++) {
-				Circuit cell = this.map.getElement(x, y);
+				Map.Circuit cell = this.map.getElement(x, y);
 				drawCell(g, cell, new int[] {x, y}, cellSize);
 			}
 		}
@@ -72,7 +72,7 @@ public class Track extends GameView {
 	/**
 	 * Retourne la couleur d'une cellule selon son type.
 	 */
-	private Color getCellColor(Circuit.Cell cell) {
+	private Color getCellColor(Map.Circuit.Cell cell) {
 		return switch (cell) {
 			case ROAD  	-> Color.GRAY;
 			case START 	-> Color.YELLOW; 
@@ -85,7 +85,7 @@ public class Track extends GameView {
 	/**
 	 * Retourne le caractère à afficher pour une cellule du circuit.
 	 */
-	private char getCellChar(Circuit cell) {
+	private char getCellChar(Map.Circuit cell) {
 		return switch (cell.getType()) {
 			case ROAD  	-> '\0';
 			case START 	-> 'D'; 
@@ -113,7 +113,7 @@ public class Track extends GameView {
 	/**
 	 * Dessine une cellule complète avec son contenu (caractère et voitures).
 	 */
-	private void drawCell(Graphics g, Circuit cell, int[] coord, int[] cellCoord) {
+	private void drawCell(Graphics g, Map.Circuit cell, int[] coord, int[] cellCoord) {
 		drawBlock(g, cell, coord, cellCoord);
 
 		char c = getCellChar(cell);
@@ -171,7 +171,7 @@ public class Track extends GameView {
 	/**
 	 * Dessine une cellule de base selon son type et ajoute un contour noir.
 	 */
-	private void drawBlock(Graphics g, Circuit cell, int[] coord, int[] cellCoord) {
+	private void drawBlock(Graphics g, Map.Circuit cell, int[] coord, int[] cellCoord) {
 		int x = coord[0]; 
 		int y = coord[1];
 
@@ -181,7 +181,7 @@ public class Track extends GameView {
 		switch (cell.getType()) {
 			case YROAD:
 				// dessine le bloc de route
-				g.setColor(getCellColor(Circuit.Cell.ROAD));
+				g.setColor(getCellColor(Map.Circuit.Cell.ROAD));
 				g.fillRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight);
 				
 				// dessine le sous bloc de route