commit c6629a1b6245ce8dc0b6609709a84fb2a25e4fc2 Author: Chahrazad650 Date: Thu Nov 6 20:29:58 2025 +0100 Ajout de la partie view du projet diff --git a/bin/Main.class b/bin/Main.class new file mode 100644 index 0000000..7f0fe75 Binary files /dev/null and b/bin/Main.class differ diff --git a/bin/model/Car.class b/bin/model/Car.class new file mode 100644 index 0000000..82fb67d Binary files /dev/null and b/bin/model/Car.class differ diff --git a/bin/model/Circuit$Cell.class b/bin/model/Circuit$Cell.class new file mode 100644 index 0000000..0a17e55 Binary files /dev/null and b/bin/model/Circuit$Cell.class differ diff --git a/bin/model/Circuit.class b/bin/model/Circuit.class new file mode 100644 index 0000000..592f429 Binary files /dev/null and b/bin/model/Circuit.class differ diff --git a/bin/model/GObserver.class b/bin/model/GObserver.class new file mode 100644 index 0000000..c276b20 Binary files /dev/null and b/bin/model/GObserver.class differ diff --git a/bin/model/Game$Builder.class b/bin/model/Game$Builder.class new file mode 100644 index 0000000..1303bf9 Binary files /dev/null and b/bin/model/Game$Builder.class differ diff --git a/bin/model/Game.class b/bin/model/Game.class new file mode 100644 index 0000000..fa5242a Binary files /dev/null and b/bin/model/Game.class differ diff --git a/bin/model/Map$1.class b/bin/model/Map$1.class new file mode 100644 index 0000000..a89ea3b Binary files /dev/null and b/bin/model/Map$1.class differ diff --git a/bin/model/Map.class b/bin/model/Map.class new file mode 100644 index 0000000..add34b6 Binary files /dev/null and b/bin/model/Map.class differ diff --git a/bin/model/State$DriveMode.class b/bin/model/State$DriveMode.class new file mode 100644 index 0000000..12aa398 Binary files /dev/null and b/bin/model/State$DriveMode.class differ diff --git a/bin/model/State.class b/bin/model/State.class new file mode 100644 index 0000000..513d5bc Binary files /dev/null and b/bin/model/State.class differ diff --git a/bin/view/FenetreJeu.class b/bin/view/FenetreJeu.class new file mode 100644 index 0000000..ad883e0 Binary files /dev/null and b/bin/view/FenetreJeu.class differ diff --git a/bin/view/FenetreTableau.class b/bin/view/FenetreTableau.class new file mode 100644 index 0000000..ea6ed83 Binary files /dev/null and b/bin/view/FenetreTableau.class differ diff --git a/bin/view/PanneauCircuit$1.class b/bin/view/PanneauCircuit$1.class new file mode 100644 index 0000000..beef292 Binary files /dev/null and b/bin/view/PanneauCircuit$1.class differ diff --git a/bin/view/PanneauCircuit.class b/bin/view/PanneauCircuit.class new file mode 100644 index 0000000..f0f7b4b Binary files /dev/null and b/bin/view/PanneauCircuit.class differ diff --git a/bin/view/PanneauClassement.class b/bin/view/PanneauClassement.class new file mode 100644 index 0000000..7920109 Binary files /dev/null and b/bin/view/PanneauClassement.class differ diff --git a/model/Car.java b/model/Car.java new file mode 100644 index 0000000..77b028b --- /dev/null +++ b/model/Car.java @@ -0,0 +1,118 @@ +package model; +import java.util.Random; + +/** + * Car 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. + *

Si la position atteint la fin de la boucle, un nouveau tour est compté.

+ * + * @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; + } +} + diff --git a/model/Circuit.java b/model/Circuit.java new file mode 100644 index 0000000..fbea526 --- /dev/null +++ b/model/Circuit.java @@ -0,0 +1,139 @@ +package model; +/** + * Représente une cellule du circuit. + *

+ * 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). + *

+ */ +public class Circuit +{ + /** + * Cell 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; + } +} \ No newline at end of file diff --git a/model/GObserver.java b/model/GObserver.java new file mode 100644 index 0000000..5051445 --- /dev/null +++ b/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(); +} \ No newline at end of file diff --git a/model/Game.java b/model/Game.java new file mode 100644 index 0000000..632f9d2 --- /dev/null +++ b/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 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; + } +} + + diff --git a/model/Main.java b/model/Main.java new file mode 100644 index 0000000..32dbf58 --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/model/Map.java b/model/Map.java new file mode 100644 index 0000000..f7adec7 --- /dev/null +++ b/model/Map.java @@ -0,0 +1,284 @@ +package model; +import java.awt.Point; +import java.util.ArrayList; +import java.util.function.Function; + +/** + *

Map représente le circuit de course.

+ *

Cette classe contient:

+ * + */ +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 pathMap; + + /** + * Crée une nouvelle instance de Map à partir d'un tableau générique + * et d'une fonction de transformation. + * + * @param 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 Map + */ + public static Map create(Function 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. + *
    + *
  • 0 -> EMPTY
    • + *
  • -1 -> ROAD
    • + *
  • -2 -> START
    • + *
  • -3 -> FINISH
    • + *
  • autres -> YROAD avec la valeur associée
    • + *
+ * + * @param array Tableau 2D d'entiers + * @return Une nouvelle instance de Map + */ + 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. + *
    + *
  • '#' -> ROAD
    • + *
  • 'S' -> START
    • + *
  • 'F' -> FINISH
    • + *
  • '0'-'9' -> YROAD avec valeur correspondante
    • + *
  • autres -> EMPTY
    • + *
+ * + * @param array Tableau 2D de caractères + * @return Une nouvelle instance de Map + */ + 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 Circuit + */ + 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 Circuit + */ + 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 Circuit.Cell + */ + 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(); + } +} diff --git a/model/State.java b/model/State.java new file mode 100644 index 0000000..b2389c0 --- /dev/null +++ b/model/State.java @@ -0,0 +1,40 @@ +package model; +public class State +{ + public static enum DriveMode + { +// + 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; + } +} diff --git a/view/FenetreJeu.java b/view/FenetreJeu.java new file mode 100644 index 0000000..9c101ea --- /dev/null +++ b/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 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; + } +} diff --git a/view/FenetreTableau.java b/view/FenetreTableau.java new file mode 100644 index 0000000..0114fc1 --- /dev/null +++ b/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()); + } +} diff --git a/view/Main.java b/view/Main.java new file mode 100644 index 0000000..e6b5541 --- /dev/null +++ b/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(); + } +} diff --git a/view/PanneauCircuit.java b/view/PanneauCircuit.java new file mode 100644 index 0000000..73a8b95 --- /dev/null +++ b/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; + }; + } +} diff --git a/view/PanneauClassement.java b/view/PanneauClassement.java new file mode 100644 index 0000000..756a97f --- /dev/null +++ b/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 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; + } + } +}