feat!: rework de tout le projet

src/model/Game.java

@@ -0,0 +1,360 @@
+package model;
+
+import java.awt.Color;
+import java.util.ArrayList;
+
+import model.car.Car;
+import model.map.Map;
+
+/**
+ * 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 {
+    @FunctionalInterface
+    /**
+     * L'interface utilisée pour Game.
+     */
+    public static interface Observer {
+        /**
+         * 
+         * @return true si la fonction s'est bien passé sinon false (le programme va se
+         *         stopper)
+         */
+        public boolean apply();
+    }
+
+    /**
+     * {@link VisualInfo} est un enregistrement (record) qui décrit une vue
+     * graphique
+     * à afficher dans le jeu (par exemple un tableau de bord, une piste ou un
+     * classement).
+     * <p>
+     * Chaque instance contient toutes les informations nécessaires pour créer et
+     * positionner
+     * cette vue à l’écran.
+     * </p>
+     *
+     * @param type   le type concret de la vue (classe héritant de {@link Game})
+     * @param title  le titre de la fenêtre ou du panneau associé
+     * @param width  la largeur en pixels de la vue
+     * @param height la hauteur en pixels de la vue
+     * @param x      la position horizontale (en pixels) de la vue sur l’écran
+     * @param y      la position verticale (en pixels) de la vue sur l’écran
+     */
+    private record VisualInfo(Class<? extends Game> type,
+            String title, int width, int height, int x, int y) {
+    }
+
+    public static class GameFactory {
+        public static Map defaultMap() {
+            return Map.fromInts(new Integer[][] {
+                { 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 },
+            });
+        }
+
+        public static Game defaultGame(Map map) {
+            return new Game.Builder()
+			.addCar("Voiture à LUWIK", Color.BLUE)
+			.addCar("Voiture à CHARAZADE", Color.PINK)
+			.addCar("Voiture de UPEC", Color.RED)
+			.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)
+			.setTime(1000)
+			.setMap(map)
+			.build();
+        }
+    }
+
+    /**
+     * 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 */
+        private ArrayList<CarInfo> cars = new ArrayList<>();
+        /** Liste des voitures à créer pour le jeu */
+        private ArrayList<VisualInfo> visuals = new ArrayList<>();
+        /** État initial du jeu */
+        private Car.State state = Car.State.NORMAL;
+        /** Temps entre chaque step du jeu */
+        private int time = 1000;
+        /** Carte sur laquelle se déroule le jeu */
+        private Map map = null;
+
+        /** Ajoute une voiture à la liste */
+        public Builder addCar(String name, Color color) {
+            cars.add(new CarInfo(name, color));
+            return this;
+        }
+
+        /** Supprime une voiture de la liste */
+        public Builder removeCar(String name, Color color) {
+            cars.forEach((car) -> {
+                if (car.name == name && car.color == color)
+                    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(Car.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;
+        }
+
+        public Builder addVisual(Class<? extends Game> type, String title,
+                int width, int height, int x, int y) {
+            visuals.add(new VisualInfo(type, title, width, height, x, y));
+            return this;
+        }
+
+        private void buildVisual(Game game) {
+            for (VisualInfo visual : visuals) {
+                Game view = null;
+
+                if (visual.type == Rankboard.class) {
+                    view = new Rankboard(game, visual.title, visual.width,
+                            visual.height, visual.x, visual.y);
+                } else if (visual.type == Track.class) {
+                    view = new Track(game, visual.title, visual.width,
+                            visual.height, visual.x, visual.y);
+                } else if (visual.type == Dashboard.class) {
+                    Car car = game.getCars().stream()
+                            .filter((e) -> visual.title.equals(e.getName()))
+                            .findFirst()
+                            .orElseThrow();
+
+                    view = new Dashboard(game,
+                            car,
+                            visual.title, visual.width,
+                            visual.height, visual.x, visual.y);
+                }
+                if (view != null)
+                    game.addObserver(view);
+            }
+        }
+
+        /**
+         * 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 définir une carte avant de construire le jeu !");
+                System.exit(1);
+            }
+
+            Game game = new Game(map, cars, state, time);
+            buildVisual(game);
+            return game;
+        }
+    }
+
+    private final Map map;
+    /** État du jeu (par exemple, positions, carburant) */
+    private final Car.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<Observer> obs = new ArrayList<>();
+
+    /** Indique si le jeu est en pause */
+    private boolean isPaused = false;
+
+    /**
+     * 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, Car.State state, int time) {
+        this.map = map;
+        this.state = state;
+        this.time = time;
+
+        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 de chaque voiture avec son Dashboard
+        for (CarInfo ci : carInfos)
+            cars.add(new Car(ci.name, ci.color, map)
+                    .setState(state));
+
+        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) {
+            if (car.getFuel() == 0)
+                return true;
+        }
+        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(Observer o) {
+        obs.add(o);
+        return this;
+    }
+
+    /**
+     * Supprime un observateur.
+     *
+     * @param o observateur
+     * @return instance de Game pour chaîner
+     */
+    public Game remObserver(Observer 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();
+        isPaused = !isPaused;
+        return isPaused;
+    }
+
+    public void notifyObservers() {
+        for (Observer o : obs) {
+            boolean isSuccess = o.apply();
+            if (!isSuccess) {
+                System.err.println("Une erreur s'est produite pendant le jeu.");
+                System.exit(1);
+            }
+        }
+    }
+
+    /**
+     * 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 void step() throws InterruptedException {
+        for (Car car : cars) {
+            synchronized (this) {
+                while (isPaused)
+                    wait();
+            }
+
+            car.run();
+            notifyObservers();
+        }
+    }
+
+    /**
+     * 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()) {
+            try {
+                step();
+                Thread.sleep(time);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        System.out.println("Fini!\nVoici le score :");
+        for (Car c : cars) {
+            System.out.println(c.getName() + "\t" + c.getScore());
+        }
+        System.exit(0);
+    }
+
+    public ArrayList<Car> getCars() {
+        return cars;
+    }
+
+    public Map getMap() {
+        return map;
+    }
+
+    public Car.State getState() {
+        return state;
+    }
+
+    public boolean getPause() {
+        return isPaused;
+    }
+}

src/model/car/BasicCar.java

@@ -0,0 +1,247 @@
+package model.car;
+
+import java.awt.Color;
+import java.awt.Point;
+import java.util.Random;
+
+import model.map.Circuit;
+import model.map.Map;
+
+/**
+ * {@link BasicCar} 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.
+ * 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.
+ * </p>
+ */
+public class BasicCar implements Car {
+    /** Générateur de nombres aléatoires pour simuler la progression */
+    protected static final Random RANDOM = new Random();
+    /** Couleur de la voiture pour l'affichage */
+    private final Color COLOR;
+    /** Nom de la voiture */
+    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 Map MAP;
+    /** Carburant restant */
+    private int fuel = 60;
+
+    private int movement = 1;
+
+    /**
+     * Construit une nouvelle voiture.
+     *
+     * @param name  nom de la voiture
+     * @param color couleur de la voiture
+     * @param map
+     */
+    public BasicCar(String name, Color color, Map map) {
+        this.NAME = name;
+        this.COLOR = color;
+        this.MAP = map;
+    }
+
+    /**
+     * Référence à l'état du jeu, pour récupérer les paramètres comme la
+     * consommation
+     */
+    private State state = State.NORMAL;
+
+    private int damageRound = 0;
+
+    public void setDamage() {
+        damageRound = 5;
+        state = State.DAMAGED;
+    }
+
+    private boolean decreaseDamage() {
+        if (state.isDamaged()) {
+            if (--damageRound <= 0) {
+                state = state.onDamageEnd();
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public BasicCar setState(State state) {
+        this.state = state;
+        return this;
+    }
+
+    /**
+     * @return la position actuelle dans la boucle
+     */
+    public int getPosition() {
+        return pos;
+    }
+
+    /**
+     * @return le score de la voiture, calculé comme :
+     *         (nombre de tours + progression du tour) × 100
+     */
+    public int getScore() {
+        return (int) ((round + (float) pos / MAP.getPathSize()) * 100);
+    }
+
+    /**
+     * @return le nombre de tours complétés
+     */
+    public int getRound() {
+        return round;
+    }
+
+    /**
+     * @return le carburant restant
+     */
+    public int getFuel() {
+        return fuel;
+    }
+
+    /** Retourne l'état courant de la voiture. */
+    public State getState() {
+        return state;
+    }
+
+    /**
+     * Clique sur "Accelerer" : change d'état et retourne un message (si
+     * nécessaire).
+     */
+    @Override
+    public String accelerate() {
+        // Si endommagée => l'énoncé dit qu'on ne peut pas bouger
+        if (state.isDamaged()) {
+            return "Voiture endommagée : impossible d'accélérer";
+        }
+        State next = state.accelerate();
+
+        // Énoncé : en BOOST, si on accélère encore => message "déjà max"
+        if (state == State.BOOST && next == State.BOOST) {
+            return "Déjà à la vitesse maximale";
+        }
+        state = next;
+        return "";
+    }
+
+    /**
+     * Clique sur "Rallentir" : change d'état et retourne un message (si
+     * nécessaire).
+     */
+    @Override
+    public String decelerate() {
+        if (state.isDamaged()) {
+            return "Voiture endommagée : impossible de ralentir";
+        }
+
+        State next = state.decelerate();
+
+        // Énoncé : en STOPPED, si on ralentit encore => message "déjà arrêtée"
+        if (state == State.STOPPED && next == State.STOPPED) {
+            return "Déjà arrêtée";
+        }
+
+        state = next;
+        return "";
+    }
+
+    /**
+     * 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)
+     */
+    @Override
+    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, movement);
+
+            Point point = MAP.getPath(pos);
+            Circuit element = MAP.getElement(point.x, point.y);
+
+            if (hasAccident(element, jump)) {
+                System.out.println(NAME + " a un\taccident");
+                setDamage();
+                return;
+            }
+            round = pos / MAP.getPathSize();
+        }
+    }
+
+    private boolean hasAccident(Circuit element, int jump) {
+        return element.isYRoad() && element.getValue() <= jump;
+    }
+
+    /**
+     * Consomme du carburant en fonction de l'état du jeu.
+     *
+     * @return cette même instance pour chaînage
+     */
+    @Override
+    public void consumeFuel() {
+        fuel = state.fuelConsumption(fuel);
+        if (fuel < 0)
+            fuel = 0; // sécurité
+    }
+
+    /**
+     * 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.
+     * </p>
+     */
+    @Override
+    public void run() {
+        if (fuel > 0) {
+            move();
+            consumeFuel();
+        }
+    }
+
+    @Override
+    public void reverse(boolean active) {
+        movement = (active) ? -1 : 1;
+    }
+
+    /**
+     * @return la position actuelle (synonyme de getPosition)
+     */
+    public int getPos() {
+        return pos;
+    }
+
+    /**
+     * @return la couleur de la voiture
+     */
+    public Color getColor() {
+        return COLOR;
+    }
+
+    /**
+     * @return nom de la voiture
+     */
+    public String getName() {
+        return NAME;
+    }
+}

src/model/car/Car.java

@@ -0,0 +1,23 @@
+package model.car;
+
+import java.awt.Color;
+
+public interface Car {
+    public String accelerate();
+
+    public String decelerate();
+
+    public void move();
+
+    public void consumeFuel();
+
+    public void run();
+
+    public void reverse(boolean active);
+
+    public int getPos();
+
+    public Color getColor();
+
+    public String getName();
+}

src/model/car/DrunkCar.java

@@ -0,0 +1,75 @@
+package model.car;
+
+import java.awt.Color;
+import java.util.Random;
+
+/**
+ * DrunkCar = décorateur "pilote ivre".
+ *
+ * Idée :
+ * - Quand l'utilisateur demande "Accelerer", le pilote peut se tromper
+ * et faire "Rallentir" à la place (au hasard).
+ * - Pareil quand on demande "Rallentir".
+ *
+ * => On modifie seulement les actions utilisateur (accelerate/decelerate),
+ * sans modifier la classe Car.
+ */
+public class DrunkCar implements Car {
+    /** Générateur de nombres aléatoires pour simuler la progression */
+    protected static final Random RANDOM = new Random();
+
+    private Car car;
+
+    public DrunkCar(Car car) {
+        this.car = car;
+    }
+
+    @Override
+    // 50% : fait la bonne action,
+    // 50% : fait l'inverse
+    public void move() {
+        car.reverse(RANDOM.nextBoolean());
+        car.move();
+        car.reverse(false);
+    }
+
+    @Override
+    public void run() {
+        car.run();
+    }
+
+    @Override
+    public String accelerate() {
+        return car.accelerate();
+    }
+
+    @Override
+    public String decelerate() {
+        return car.decelerate();
+    }
+
+    @Override
+    public void consumeFuel() {
+        car.consumeFuel();
+    }
+
+    @Override
+    public void reverse(boolean active) {
+        car.reverse(active);
+    }
+
+    @Override
+    public int getPos() {
+        return car.getPos();
+    }
+
+    @Override
+    public Color getColor() {
+        return car.getColor();
+    }
+
+    @Override
+    public String getName() {
+        return car.getName();
+    }
+}

src/model/car/HybridCar.java

@@ -0,0 +1,91 @@
+package model.car;
+
+import java.awt.Color;
+
+/**
+ * HybridCar = décorateur "voiture hybride".
+ *
+ * Idée :
+ * - La voiture avance à chaque tour
+ * - Mais elle consomme du carburant seulement 1 fois sur 2
+ * => donc elle économise du carburant.
+ */
+public class HybridCar implements Car {
+    private Car car;
+    private int energy = 100; // énergie batterie (0..100)
+
+    public HybridCar(Car car) {
+        this.car = car;
+    }
+
+    /** pour afficher l'énergie dans le Dashboard */
+    public int getEnergy() {
+        return energy;
+    }
+
+    @Override
+    public void run() {
+        // 1) La voiture avance toujours
+        car.move();
+
+        // 2) Gestion énergie : elle perd 10% à chaque boucle
+        energy -= 10;
+        if (energy < 0)
+            energy = 0;
+
+        // 3) Consommation :
+        // - si on a encore de l'énergie, on économise le fuel (pas de conso)
+        // - sinon, on consomme normalement
+        if (energy == 0) {
+            car.consumeFuel();
+        }
+    }
+
+    @Override
+    public String decelerate() {
+        // 1) On applique le ralentissement normal (State pattern)
+        String msg = car.decelerate();
+
+        // 2) Recharge +5% quand on ralentit
+        energy += 5;
+        if (energy > 100)
+            energy = 100;
+
+        return msg;
+    }
+
+    @Override
+    public void consumeFuel() {
+        car.consumeFuel();
+    }
+
+    @Override
+    public void move() {
+        car.move();
+    }
+
+    @Override
+    public String accelerate() {
+        return car.accelerate();
+    }
+
+    @Override
+    public void reverse(boolean active) {
+        car.reverse(active);
+    }
+
+    @Override
+    public int getPos() {
+        return car.getPos();
+    }
+
+    @Override
+    public Color getColor() {
+        return car.getColor();
+    }
+
+    @Override
+    public String getName() {
+        return car.getName();
+    }
+}

src/model/car/SoundCar.java

@@ -0,0 +1,62 @@
+package model.car;
+
+import java.awt.Color;
+
+/**
+ * Décorateur Sound :
+ * affiche un message sonore quand la voiture accélère.
+ */
+public class SoundCar implements Car {
+    private Car car;
+
+    public SoundCar(Car car) {
+        this.car = car;
+    }
+
+    @Override
+    public String accelerate() {
+        System.out.println("VROOOOM VROOOOOOM");
+        return car.accelerate();
+    }
+
+    @Override
+    public void run() {
+        car.run();
+    }
+
+    @Override
+    public String decelerate() {
+        return car.decelerate();
+    }
+
+    @Override
+    public void move() {
+        car.move();
+    }
+
+    @Override
+    public void consumeFuel() {
+        car.consumeFuel();
+    }
+
+    @Override
+    public void reverse(boolean active) {
+        car.reverse(active);
+    }
+
+    @Override
+    public int getPos() {
+        return car.getPos();
+    }
+
+    @Override
+    public Color getColor() {
+        return car.getColor();
+    }
+
+    @Override
+    public String getName() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getName'");
+    }
+}

src/model/car/State.java

@@ -0,0 +1,146 @@
+package model.car;
+
+import java.util.List;
+
+public enum State {
+    /**
+     * L'état NORMAL du Vehicule avance selon un chiffre au alentour de 1 à 6 cases
+     * par tour. Il consomme 2 unités de carburant à chaque tour. Si l'on
+     * accelere, il passe à l'état BOOST. Si on Rallenti, il passe à l'état LOW.
+     */
+    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;
+    }
+
+    public List<Integer> getInterval() {
+        return List.of(MIN, MAX);
+    }
+
+    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();
+}

src/model/map/Circuit.java

@@ -0,0 +1,136 @@
+package model.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 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;
+  }
+}

src/model/map/Map.java

@@ -0,0 +1,302 @@
+package model.map;
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.function.Function;
+
+/**
+ * <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>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 {
+    /**
+     * Tableau 2D représentant le circuit.
+     * Chaque élément est une instance de {@link Circuit}.
+     */
+    private Circuit[][] map;
+    /**
+     * Liste des coordonnées représentant le chemin du START au FINISH.
+     */
+    private ArrayList<Point> pathMap;
+
+    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 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) {
+        int lenX = map[0].length;
+        int lenY = map.length;
+
+        Circuit[][] newmap = new Circuit[lenY][lenX];
+
+        for (int y = 0; y < lenY; y++) {
+            for (int x = 0; x < lenX; x++) {
+                newmap[y][x] = fn.apply(map[y][x]);
+            }
+        }
+
+        return new Map(newmap);
+    }
+
+    /**
+     * Crée une map à partir d'un tableau d'entiers.
+     * <ul>
+     * <li>0 -> EMPTY</li>
+     * <li>-1 -> ROAD</li>
+     * <li>-2 -> START</li>
+     * <li>-3 -> FINISH</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) {
+        return create((i) -> switch (i) {
+            case 0 -> new Circuit(Circuit.Cell.EMPTY);
+            case -1 -> new Circuit(Circuit.Cell.ROAD);
+            case -2 -> new Circuit(Circuit.Cell.START);
+            case -3 -> new Circuit(Circuit.Cell.FINISH);
+            default -> new Circuit(Circuit.Cell.YROAD, i);
+        }, map);
+    }
+
+    /**
+     * Crée une map à partir d'un tableau de caractères.
+     * <ul>
+     * <li>'#' -> ROAD</li>
+     * <li>'S' -> START</li>
+     * <li>'F' -> FINISH</li>
+     * <li>'0'-'9' -> YROAD avec valeur correspondante</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) {
+        return create((i) -> switch (i) {
+            case '#' -> new Circuit(Circuit.Cell.ROAD);
+            case 'S' -> new Circuit(Circuit.Cell.START);
+            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');
+            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) {
+        this.map = map;
+
+        this.width = map[0].length;
+        this.height = map.length;
+
+        boolean isPossible = this.buildPath();
+
+        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() {
+        Point[] p = bindPath();
+
+        if (p == null)
+            return false;
+
+        Point start = p[0];
+        Point end = p[1];
+
+        this.pathMap = new ArrayList<>();
+        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
+     */
+    private Point[] bindPath() {
+        Point start = null;
+        Point end = null;
+
+        for (int i = 0; i < map.length; i++) {
+            for (int j = 0; j < map[0].length; j++) {
+                switch (map[i][j].getType()) {
+                    case Circuit.Cell.START:
+                        if (start == null)
+                            start = new Point(j, i);
+                        else
+                            return null;
+                        break;
+                    case Circuit.Cell.FINISH:
+                        if (end == null)
+                            end = new Point(j, i);
+                        else
+                            return null;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        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.
+     *
+     * @param start Point de départ
+     * @param end   Point d'arrivée
+     * @return true si un chemin complet a été trouvé, false sinon
+     */
+    private boolean followPath(Point start, Point end) {
+        // remettre à 0 la liste
+        pathMap.clear();
+
+        // positions
+        Point current = start;
+        Point previous = null;
+
+        int[][] coord = {
+                { 1, 0 }, // haut
+                { -1, 0 }, // bas
+                { 0, -1 }, // gauche
+                { 0, 1 } // droite
+        };
+
+        // sécurité pour éviter les boucles infinie
+        int step = 0;
+        int max = map.length * map[0].length;
+        for (; step < max; step++) {
+            pathMap.add(current);
+
+            if (current.equals(end))
+                return true;
+
+            boolean moved = false;
+
+            for (int[] pos : coord) {
+                int x = current.x + pos[1];
+                int y = current.y + pos[0];
+
+                if ((x >= 0 && map[0].length > x) && (y >= 0 && map.length > y)) {
+                    Point next = new Point(x, y);
+
+                    if (next.equals(previous))
+                        continue;
+
+                    Circuit element = getElement(x, y);
+                    Circuit cElement = getElement(current.x, current.y);
+                    if (element.isRoad() || (element.isFinish() && cElement.isRoad())) {
+                        previous = current;
+                        current = next;
+                        moved = true;
+                        break;
+                    }
+                }
+            }
+
+            // 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) {
+        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) {
+        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) {
+        if (i < 0)
+            return this.pathMap.getFirst();
+        else if (i >= this.pathMap.size())
+            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() {
+        return this.pathMap.size();
+    }
+
+    /**
+     * Retourne la taille de la map en largueur.
+     *
+     * @return Nombre de {@link Cell} sur une largueur
+     */
+    public int getWidth() {
+        return this.width;
+    }
+
+    /**
+     * Retourne la taille de la map en longueur.
+     *
+     * @return Nombre de {@link Cell} sur une longueur
+     */
+    public int getHeight() {
+        return this.height;
+    }
+}