Ajout de la partie view du projet

model/Car.java

@@ -0,0 +1,118 @@
+package model;
+import java.util.Random;
+
+/**
+ * <code>Car</code> représente une voiture qui avance sur un circuit en boucles.
+ * Chaque appel à {@link #makeMove()} avance la voiture d'une position.
+ * Quand la position atteint la fin de la boucle, un nouveau tour est compté.
+ */
+public class Car implements GObserver
+{
+    /** Ajout de la classe Random (Evite de le recreer a chaque fois) */
+    private Random rand = new Random();
+    
+    /** Position actuelle dans la boucle (entre 0 et loop inclus) */
+    private int pos		= 0;
+    
+    /** Nombre de tours complétés */
+    private int round 	= 0;
+    
+    /** Nombre total de cases dans une boucle (doit être > 0) */
+    private final int loop;
+    private final State state;
+    /** Nombre de fuel restant */
+    private int fuel    = 60;
+
+    /**
+     * Construit une nouvelle voiture.
+     *
+     * @param loop nombre de positions par boucle (doit être > 0)
+     * @throws IllegalArgumentException si {@code loop <= 0}
+     */
+    public Car(int loop, State state)
+	{
+        this.state = state;
+
+        if (loop <= 0)
+            throw new IllegalArgumentException("loop must be > 0!");
+        this.loop = loop;
+    }
+
+    /**
+     * Fait avancer la voiture d'une position.
+     * <p>Si la position atteint la fin de la boucle, un nouveau tour est compté.</p>
+     *
+     * @return cette même instance (pour chaînage fluide)
+     */
+    public Car makeMove(int move)
+	{
+        pos += move;
+        if (pos == loop)
+        {
+            round++;
+            pos = 0;
+        }
+        return this;
+    }
+
+    /**
+     * @return la position actuelle dans la boucle
+     */
+    public int getPosition()
+	{
+        return pos;
+    }
+
+    /**
+     * @return le score, calculé comme (nombre de tours + progression du tour) × 100
+     */
+    public int getScore()
+	{
+        return (int) ((round + (float) pos / loop) * 100);
+    }
+
+    /**
+     * @return le nombre de tours complétés
+     */
+    public int getRound()
+	{
+        return round;
+    }
+
+    /**
+     * @return la taille de la boucle (nombre de positions)
+     */
+    public int getLoop()
+	{
+        return loop;
+    }
+
+    public int getFuel()
+    {
+        return fuel;
+    }
+
+    public  Car consumeFuel()
+    {
+        fuel -= state.getConsumption();
+        return this;
+    }
+
+    @Override
+    public boolean apply()
+    {
+        if (this.fuel > 0)
+        {
+            int[] interval = state.getInterval();
+            int random = rand.nextInt(interval[0], interval[1]);
+            makeMove(random).consumeFuel();
+        }
+
+        return true;
+    }
+        /** Retourne l'état de la voiture (State) */
+    public State getState() {
+        return state;
+    }
+}
+

model/Circuit.java

@@ -0,0 +1,139 @@
+package model;
+/**
+ * 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;
+    }
+
+    /**
+     * 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;
+    }
+}

model/GObserver.java

@@ -0,0 +1,14 @@
+package model;
+@FunctionalInterface
+/**
+ * L'interface utilisée pour Game.
+ */
+public interface GObserver
+{
+	/**
+	 * 
+	 * @return true si la fonction s'est bien passé sinon false (le programme va se
+	 *         stopper)
+	 */
+	public boolean apply();
+}

model/Game.java

@@ -0,0 +1,144 @@
+package model;
+import java.util.ArrayList;
+
+public class Game
+{
+	private boolean	paused;
+	private Car[]	cars;
+	private Map		map;
+	
+	private ArrayList<GObserver> obs;
+
+	public static class Builder
+	{
+		private	int	pnumber	= 3;
+		private	Map	map		= null;
+		private State state	= new State();
+
+		public Builder setPlayers(int pnumber)
+		{
+			this.pnumber = pnumber;
+			return this;
+		}
+		
+		public Builder setMap(Map map)
+		{
+			this.map = map;
+			return this;
+		}
+		
+		public Builder setState(State s)
+		{
+			this.state = s;
+			return this;
+		}
+		
+		public Builder defaultMap()
+		{
+			Integer[][] map = 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 },
+			};
+			
+			this.map = Map.fromInts(map);
+			return this;
+		}
+		
+		public Game build()
+		{
+			if (map == null) defaultMap();
+			return new Game(pnumber, map, state);
+		}
+	}
+	
+	public Game(int pnumber, Map map, State state)
+	{
+		int loop	= map.getPathSize();
+		this.map	= map;
+
+		cars = new Car[pnumber];
+		obs = new ArrayList<>();
+
+		for (int i = 0; i < pnumber; i++)
+		{
+			Car car = new Car(loop, state);
+			cars[i] = car;
+
+			// Observer pour avancer
+			obs.add(car);
+		}
+	}
+
+	private boolean isFinish()
+	{
+		for (Car car : cars)
+		{
+			if (car.getFuel() == 0)
+				return true;
+		}
+		return false;
+	}
+
+	public synchronized boolean togglePause()
+	{
+		if (paused) notifyAll();
+		paused = !paused;
+		return paused;
+	}
+
+	private void step() throws InterruptedException
+	{
+		for (GObserver o : obs)
+		{
+			synchronized (this)
+			{
+				// pause du jeu, while si on notifyall sans faire exprès un autre bout de code
+				while (paused)
+				{
+					wait();
+				}
+			}
+			boolean isSuccess = o.apply();
+			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(1000);
+			} 
+			catch (InterruptedException e) 
+			{ e.printStackTrace(); }
+		}
+	}
+
+	    /** Retourne la carte du jeu */
+    public Map getMap() {
+        return map;
+    }
+
+    /** Retourne toutes les voitures du jeu */
+    public Car[] getCars() {
+        return cars;
+    }
+}
+
+

model/Main.java

@@ -0,0 +1,37 @@
+import model.*;
+import view.*;
+
+
+public class Main {
+	public static void main(String[] args) throws InterruptedException {
+		// Map m = Map.fromChars(new Character[][] {
+		// 	{'3', '#', '2'},
+		// 	{'#', ' ', 'S'},
+		// 	{'9', '#', 'F'},
+		// });
+
+		Game game = new Game.Builder()
+			.defaultMap()
+			.setPlayers(3)
+			.build();
+
+		Thread t = new Thread(() -> {
+			int i = 0;
+			while (i++ < 10)
+			{
+				try 
+				{
+					Thread.sleep(5000);
+				} 
+				catch (InterruptedException e)
+				{
+					e.printStackTrace();
+				}
+				System.out.println(game.togglePause() ? "stop" : "fini" );
+			}
+		});
+		
+		t.start();
+		game.run();
+	}
+}

model/Map.java

@@ -0,0 +1,284 @@
+package model;
+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;
+
+	/**
+     * 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;
+		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)
+	{
+		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();
+	}
+}

model/State.java

@@ -0,0 +1,40 @@
+package model;
+public class State
+{
+	public static enum DriveMode
+	{
+//		<CARBURANT PERDU>	<PREMIER INTERVAL>	<SECOND INTERVAL>
+		NORMAL(2, 1, 6);
+
+		public	int carbUsed;
+		public	int[] interval;
+
+		private DriveMode(int carbUsed, int fInterval, int sInterval)
+		{
+			this.carbUsed	= carbUsed;
+			interval		= new int[] {fInterval, sInterval};
+		}
+	}
+
+	private DriveMode current = DriveMode.NORMAL;
+
+	public DriveMode get()
+	{
+		return current;
+	}
+
+	public int[] getInterval()
+	{
+		return current.interval;
+	}
+
+	public int getConsumption()
+	{
+		return current.carbUsed;
+	}
+
+	public void set(DriveMode DriveMode)
+	{
+		current = DriveMode;
+	}
+}

view/FenetreJeu.java

@@ -0,0 +1,61 @@
+package view;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.*;
+import model.*;
+
+/**
+ * Fenêtre principale du jeu de course.
+ * Elle affiche :
+ *  - le circuit
+ *  - le classement des voitures
+ *  - et ouvre une fenêtre de tableau de bord pour chaque voiture.
+ */
+public class FenetreJeu extends JFrame {
+
+    private final PanneauCircuit panneauCircuit;
+    private final PanneauClassement panneauClassement;
+    private final java.util.List<FenetreTableau> tableaux = new ArrayList<>();
+
+    private Runnable actionPause; // Action pour pause/reprendre, donnée par le contrôleur
+
+    public FenetreJeu(Game game) {
+        setTitle("🏎️ Jeu de course - Vue principale");
+        setDefaultCloseOperation(EXIT_ON_CLOSE);
+        setLayout(new BorderLayout());
+
+        // Partie centrale : le circuit
+        panneauCircuit = new PanneauCircuit(game);
+        add(panneauCircuit, BorderLayout.CENTER);
+
+        // Partie droite : le classement
+        panneauClassement = new PanneauClassement(game);
+        add(panneauClassement, BorderLayout.EAST);
+
+        // Fenêtres séparées : un tableau de bord par voiture
+        for (Car voiture : game.getCars()) {
+            tableaux.add(new FenetreTableau(voiture, this));
+        }
+
+        setSize(1100, 650);
+        setLocationRelativeTo(null); // centre la fenêtre à l’écran
+        setVisible(true);
+    }
+
+    /** Met à jour tous les affichages à partir du modèle */
+    public void rafraichir(Game game) {
+        panneauCircuit.mettreAJour(game);
+        panneauClassement.mettreAJour(game);
+        tableaux.forEach(FenetreTableau::rafraichir);
+    }
+
+    /** Permet au contrôleur de donner l’action Pause/Reprendre */
+    public void setActionPause(Runnable action) {
+        this.actionPause = action;
+    }
+
+    public Runnable getActionPause() {
+        return actionPause;
+    }
+}

view/FenetreTableau.java

@@ -0,0 +1,53 @@
+package view;
+
+import javax.swing.*;
+import java.awt.*;
+import model.*;
+
+/**
+ * Petite fenêtre qui affiche les informations d'une voiture :
+ * - carburant restant
+ * - nombre de tours
+ * - état (mode de conduite)
+ * et un bouton Pause/Reprendre.
+ */
+public class FenetreTableau extends JFrame {
+
+    private final Car voiture;
+    private final JLabel lblCarburant, lblTours, lblEtat;
+    private final JButton boutonPause;
+
+    public FenetreTableau(Car voiture, FenetreJeu parent) {
+        this.voiture = voiture;
+
+        setTitle("Tableau de bord - Voiture");
+        setLayout(new GridLayout(4, 1));
+        getContentPane().setBackground(Color.LIGHT_GRAY);
+
+        lblCarburant = new JLabel("Carburant : " + voiture.getFuel(), SwingConstants.CENTER);
+        lblTours = new JLabel("Tours : " + voiture.getRound(), SwingConstants.CENTER);
+        lblEtat = new JLabel("État : " + voiture.getState().get(), SwingConstants.CENTER);
+        boutonPause = new JButton("⏸️ Pause / ▶️ Reprendre");
+
+        boutonPause.addActionListener(e -> {
+            if (parent.getActionPause() != null)
+                parent.getActionPause().run();
+        });
+
+        add(lblCarburant);
+        add(lblTours);
+        add(lblEtat);
+        add(boutonPause);
+
+        setSize(250, 180);
+        setLocationByPlatform(true);
+        setVisible(true);
+    }
+
+    /** Met à jour les infos affichées */
+    public void rafraichir() {
+        lblCarburant.setText("Carburant : " + voiture.getFuel());
+        lblTours.setText("Tours : " + voiture.getRound());
+        lblEtat.setText("État : " + voiture.getState().get());
+    }
+}

view/Main.java

@@ -0,0 +1,24 @@
+import model.*;
+import view.*;
+
+public class Main {
+    public static void main(String[] args) {
+        // Création du modèle (jeu)
+        Game jeu = new Game.Builder()
+                .defaultMap()
+                .setPlayers(3)
+                .build();
+
+        // Création de la vue
+        FenetreJeu vue = new FenetreJeu(jeu);
+
+        // Lier le bouton pause
+        vue.setActionPause(jeu::togglePause);
+
+        // Timer Swing pour actualiser la vue
+        new javax.swing.Timer(1000, e -> vue.rafraichir(jeu)).start();
+
+        // Thread séparé pour exécuter la logique du jeu
+        new Thread(jeu::run).start();
+    }
+}

view/PanneauCircuit.java

@@ -0,0 +1,80 @@
+package view;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.geom.Ellipse2D;
+import model.*;
+
+/**
+ * Panneau qui dessine le circuit et les voitures.
+ * Il se met à jour à chaque étape du jeu.
+ */
+public class PanneauCircuit extends JPanel {
+
+    private Game jeu;
+
+    public PanneauCircuit(Game jeu) {
+        this.jeu = jeu;
+        setBackground(Color.DARK_GRAY);
+    }
+
+    public void mettreAJour(Game jeu) {
+        this.jeu = jeu;
+        repaint();
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Graphics2D g2 = (Graphics2D) g;
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        Map map = jeu.getMap();
+        int tailleCase = 40;
+
+        // Dessin de la grille
+        for (int y = 0; y < 10; y++) {
+            for (int x = 0; x < 20; x++) {
+                Circuit.Cell cell = map.getCell(x, y);
+                g2.setColor(couleurCellule(cell));
+                g2.fillRect(x * tailleCase, y * tailleCase, tailleCase, tailleCase);
+                g2.setColor(Color.BLACK);
+                g2.drawRect(x * tailleCase, y * tailleCase, tailleCase, tailleCase);
+            }
+        }
+
+        // Dessin des voitures
+        Car[] voitures = jeu.getCars();
+        for (int i = 0; i < voitures.length; i++) {
+            Car v = voitures[i];
+            int pos = v.getPosition();
+            Point p = map.getPath(pos);
+            int px = p.x * tailleCase + 5;
+            int py = p.y * tailleCase + 5;
+
+            g2.setColor(couleurVoiture(i));
+            g2.fill(new Ellipse2D.Double(px, py, tailleCase - 10, tailleCase - 10));
+        }
+    }
+
+    /** Couleur en fonction du type de cellule */
+    private Color couleurCellule(Circuit.Cell cell) {
+        return switch (cell) {
+            case ROAD -> Color.GRAY;
+            case START -> Color.GREEN;
+            case FINISH -> Color.RED;
+            case YROAD -> Color.YELLOW;
+            default -> Color.WHITE;
+        };
+    }
+
+    /** Couleur de chaque voiture */
+    private Color couleurVoiture(int i) {
+        return switch (i) {
+            case 0 -> Color.RED;
+            case 1 -> Color.BLUE;
+            case 2 -> Color.ORANGE;
+            default -> Color.MAGENTA;
+        };
+    }
+}

view/PanneauClassement.java

@@ -0,0 +1,47 @@
+package view;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.*;
+import model.*;
+
+/**
+ * Panneau latéral affichant le classement des voitures.
+ */
+public class PanneauClassement extends JPanel {
+
+    private Game jeu;
+
+    public PanneauClassement(Game jeu) {
+        this.jeu = jeu;
+        setPreferredSize(new Dimension(250, 0));
+    }
+
+    public void mettreAJour(Game jeu) {
+        this.jeu = jeu;
+        repaint();
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.setFont(new Font("Arial", Font.BOLD, 14));
+        g.drawString("🏆 Classement :", 20, 30);
+
+        java.util.List<Car> liste = new ArrayList<>(Arrays.asList(jeu.getCars()));
+        liste.sort(Comparator.comparingInt(Car::getScore).reversed());
+
+        int y = 60;
+        for (int i = 0; i < liste.size(); i++) {
+            Car c = liste.get(i);
+            String medal = switch (i) {
+                case 0 -> "🥇";
+                case 1 -> "🥈";
+                case 2 -> "🥉";
+                default -> "";
+            };
+            g.drawString(medal + " Voiture " + (i + 1) + " - Score : " + c.getScore(), 20, y);
+            y += 25;
+        }
+    }
+}