From 82d360b1d9aa43bae28a35e2e317feaa6827ce22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20GUEZO?= Date: Wed, 10 Dec 2025 20:44:01 +0100 Subject: [PATCH] feat: ajout multiple fonction et factorisation --- src/Car.java | 291 +++++++++++++++++--------- src/GameView.java | 4 +- src/Main.java | 40 +--- src/Map.java | 510 ++++++++++++++++++++++++++++------------------ src/State.java | 77 ------- src/Track.java | 12 +- 6 files changed, 527 insertions(+), 407 deletions(-) delete mode 100644 src/State.java diff --git a/src/Car.java b/src/Car.java index 09e77d1..d5e1e6d 100644 --- a/src/Car.java +++ b/src/Car.java @@ -1,88 +1,182 @@ import java.awt.Color; +import java.awt.Point; +import java.util.List; import java.util.Random; /** * {@link Car} représente une voiture qui avance sur un circuit en boucles. - * Chaque appel à {@link #run()} avance la voiture d'une certaine position et fait perdre de l'essence. + * Chaque appel à {@link #run()} avance la voiture d'une certaine position et + * fait perdre de l'essence. * Quand la position atteint la fin de la boucle, un nouveau tour est compté. *

* La voiture consomme du carburant à chaque déplacement, et son score - * est calculé en fonction du nombre de tours complétés et de sa progression sur le tour actuel. + * est calculé en fonction du nombre de tours complétés et de sa progression sur + * le tour actuel. *

*/ -public class Car -{ +public class Car { /** Générateur de nombres aléatoires pour simuler la progression */ - private final Random rand = new Random(); + private static final Random RANDOM = new Random(); /** Couleur de la voiture pour l'affichage */ - private Color color; + private final Color COLOR; /** Nom de la voiture */ - private final String name; - + private final String NAME; /** Position actuelle dans la boucle (entre 0 et loop) */ private int pos = 0; - /** Nombre de tours complétés */ private int round = 0; - /** Nombre de cases dans une boucle (doit être > 0) */ - private final int loop; - - /** Référence à l'état du jeu, pour récupérer les paramètres comme la consommation */ - private final State state; - + private final Map MAP; /** Carburant restant */ private int fuel = 60; /** * Construit une nouvelle voiture. * - * @param name nom de la voiture + * @param name nom de la voiture * @param color couleur de la voiture - * @param loop nombre de positions par boucle (doit être > 0) - * @param state état global du jeu + * @param map */ - public Car(String name, Color color, int loop, State state) - { - if (loop <= 0) - { - System.err.println("le tour de la piste doit etre positif"); - System.exit(1); + public Car(String name, Color color, Map map) { + this.NAME = name; + this.COLOR = color; + this.MAP = map; + } + + public static enum State { + /** + * L'état NORMAL du Vehicule avance selon un chiffre au alentour de 1 à 6 cases + * par tour. Il consomme 6 unités de carburant à chaque tour. Si l'on + * accelere, il passe à l'état BOOST. Si on Rallenti, il passe à l'état LOW. + */ + // @formatter:off + NORMAL(2, 1, 6) { + public State accelerate() { return BOOST; } + public State decelerate() { return LOW; } + }, + + /** + * L'état BOOST du Vehicule avance selon un chiffre au alentour de 5 à 10 cases + * par tour. Il consomme 5 unités de carburant à chaque tour. Si l'on + * accelere, il reste sur son état et indique un message sur le tableau de bord. + * Si on Rallenti, il passe à l'état LOW. + */ + BOOST(5, 5, 10) { + public State accelerate() { return this; } + public State decelerate() { return NORMAL; } + }, + + /** + * L'état LOW du Vehicule avance selon un chiffre au alentour de 1 à 3 cases + * par tour. Il consomme 1 unités de carburant à chaque tour. Si l'on + * accelere, il passe à l'état NORMAL. Si on Rallenti, il passe à l'état STOPPED. + */ + LOW(1, 1, 3) { + public State accelerate() { return NORMAL; } + public State decelerate() { return STOPPED; } + }, + + /** + * L'état STOPPED du Vehicule n'avance pas. Il consomme aucune unités de + * carburant à chaque tour. Si l'on + * accelere, il passe à l'état LOW. Si on Rallenti, il reste sur son état et + * indique un message sur le tableau de bord. + */ + STOPPED(0, 0, 0) { + public State accelerate() { return LOW; } + public State decelerate() { return this; } + @Override + public int move(int pos, int jump) { return pos; } + @Override + public int fuelConsumption(int fuel) { return fuel; } + }, + /** + * L'état STOPPED du Vehicule n'avance pas. Il consomme aucune unités de + * carburant à chaque tour. Il reste immobile. + */ + DAMAGED(0, 0, 0) { + public State accelerate() { return this; } + public State decelerate() { return this; } + + @Override + public int move(int pos, int jump) { return pos; } + @Override + public int fuelConsumption(int fuel) { return fuel; } + @Override + public boolean isDamaged() { return true; } + @Override + public State onDamageEnd() { return LOW; } + }; + // @formatter:on + + public final int FUELCOST; + public final int MAX; + public final int MIN; + + private State(int fuelCost, int min, int max) { + this.FUELCOST = fuelCost; + this.MAX = max + 1; + this.MIN = min; } - this.name = name; - this.color = color; - this.loop = loop; - this.state = state; + public List 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(); } /** - * Fait avancer la voiture d'un certain nombre de positions. - *

- * Si la position atteint la fin de la boucle, le compteur de tours est incrémenté et - * la position revient à zéro. - *

- * - * @param move nombre de positions à avancer - * @return cette même instance (pour chaînage fluide) + * Référence à l'état du jeu, pour récupérer les paramètres comme la + * consommation */ - public Car makeMove(int move) - { - pos += move; - if (pos >= loop) - { - round++; - pos %= loop; + 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 Car setState(State state) { + this.state = state; return this; } /** * @return la position actuelle dans la boucle */ - public int getPosition() - { + public int getPosition() { return pos; } @@ -90,62 +184,84 @@ public class Car * @return le score de la voiture, calculé comme : * (nombre de tours + progression du tour) × 100 */ - public int getScore() - { - return (int) ((round + (float) pos / loop) * 100); + public int getScore() { + return (int) ((round + (float) pos / MAP.getPathSize()) * 100); } /** * @return le nombre de tours complétés */ - public int getRound() - { + public int getRound() { return round; } - /** - * @return le nombre total de positions dans la boucle - */ - public int getLoop() - { - return loop; - } - /** * @return le carburant restant */ - public int getFuel() - { + public int getFuel() { return fuel; } + /** + * Fait avancer la voiture d'un certain nombre de positions. + *

+ * Si la position atteint la fin de la boucle, le compteur de tours est + * incrémenté et + * la position revient à zéro. + *

+ * + * @param move nombre de positions à avancer + * @return cette même instance (pour chaînage fluide) + */ + public void move() { + if (decreaseDamage()) { + System.out.println(NAME + " est en\taccident " + damageRound); + return; + } + + int jump = RANDOM.nextInt(state.MIN, state.MAX); + + for (int i = 0; i < jump; i++) { + pos = state.move(pos, 1); + + Point point = MAP.getPath(pos); + Map.Circuit element = MAP.getElement(point.x, point.y); + + if (element.isYRoad() && element.getValue() < jump) { + System.out.println(NAME + " a un\taccident"); + setDamage(); + return; + } + + if (pos >= MAP.getPathSize()) { + pos = 0; + round++; + } + } + } + /** * Consomme du carburant en fonction de l'état du jeu. * * @return cette même instance pour chaînage */ - public Car consumeFuel() - { - fuel -= state.getConsumption(); - if (fuel < 0) fuel = 0; // sécurité - return this; + 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. + * Exécute une "étape" de la voiture : avance d'une position aléatoire et + * consomme du carburant. *

- * La progression est déterminée par un intervalle aléatoire fourni par l'état du jeu. + * La progression est déterminée par un intervalle aléatoire fourni par l'état + * du jeu. *

*/ - public void run() - { - if (fuel > 0) - { - int[] interval = state.getInterval(); - // avance aléatoire en fonction de l'interval - int random = rand.nextInt(interval[0], interval[1]); - - makeMove(random); + public void run() { + if (fuel > 0) { + move(); consumeFuel(); } } @@ -153,34 +269,21 @@ public class Car /** * @return la position actuelle (synonyme de getPosition) */ - public int getPos() - { + public int getPos() { return pos; } /** * @return la couleur de la voiture */ - public Color getColor() - { - return color; - } - - /** - * Définit la couleur de la voiture - * - * @param color nouvelle couleur - */ - public void setColor(Color color) - { - this.color = color; + public Color getColor() { + return COLOR; } /** * @return nom de la voiture */ - public String getName() - { - return this.name; + public String getName() { + return NAME; } } \ No newline at end of file diff --git a/src/GameView.java b/src/GameView.java index 63dbf5a..86e511a 100644 --- a/src/GameView.java +++ b/src/GameView.java @@ -9,7 +9,7 @@ import javax.swing.JFrame; * Chaque GameView est associée à une fenêtre JFrame et s'inscrit dans * la liste globale des vues pour permettre des mises à jour centralisées. */ -public abstract class GameView extends JComponent implements GObserver +public abstract class GameView extends JComponent implements Game.observer { /** Fenêtre associée à cette vue */ protected final JFrame frame; @@ -54,7 +54,7 @@ public abstract class GameView extends JComponent implements GObserver frame.setContentPane(this); // visibilité de la fenetre frame.setVisible(true); - // mettre un layout + // mettre un layout (la disposition des elements de la fenetre) frame.setLayout(new BorderLayout()); game.addObserver(this); diff --git a/src/Main.java b/src/Main.java index 07ae54f..a15303f 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,37 +1,7 @@ -import java.awt.Color; - public class Main { - public static void main(String[] args) throws InterruptedException - { - 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 }, - }; - - Map m = Map.fromInts(map); - - Game game = new Game.Builder() - .addCar(new Game.CarInfo("Voiture à LUWIK", Color.BLUE)) - .addCar(new Game.CarInfo("Voiture à CHARAZADE", Color.PINK)) - .addCar(new Game.CarInfo("Voiture de UPEC", Color.RED)) - .setTime(1000) - .setMap(m) - .addVisual(Dashboard.class, "Voiture à LUWIK", 300, 200, 1000, 0) - .addVisual(Dashboard.class, "Voiture à CHARAZADE", 300, 200, 1000, 200) - .addVisual(Dashboard.class, "Voiture de UPEC", 300, 200, 1000, 400) - .addVisual(Track.class, "Piste Formule 1", 1000, 500, 1, 1) - .addVisual(Rankboard.class, "Score", 200, 200, 0, 510) - .build(); - - game.run(); - } + public static void main(String[] args) throws InterruptedException { + Map map = Game.GameFactory.defaultMap(); + Game game = Game.GameFactory.defaultGame(map); + game.run(); + } } \ No newline at end of file diff --git a/src/Map.java b/src/Map.java index 0b8aed7..162df49 100644 --- a/src/Map.java +++ b/src/Map.java @@ -3,179 +3,311 @@ import java.util.ArrayList; import java.util.function.Function; /** - *

Map représente le circuit de course.

- *

Cette classe contient:

+ *

+ * Map représente le circuit de course. + *

+ *

+ * Cette classe contient: + *

* */ -public class Map -{ - /** +public class Map { + /** + * 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 static 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; + } + + public boolean isYRoad() { + return type == Cell.YROAD; + } + + /** + * Vérifie si la cellule est un point de départ. + * + * @return vrai si la cellule représente le départ + */ + public boolean isStart() { + return type == Cell.START; + } + + /** + * Vérifie si la cellule est un point d’arrivée. + * + * @return vrai si la cellule représente la fin du circuit + */ + public boolean isFinish() { + return type == Cell.FINISH; + } + } + + /** * Tableau 2D représentant le circuit. * Chaque élément est une instance de {@link Circuit}. */ - private Circuit[][] map; - /** + private Circuit[][] map; + /** * Liste des coordonnées représentant le chemin du START au FINISH. */ - private ArrayList pathMap; + private ArrayList pathMap; - private int width, height; + private int width, height; - /** + /** * Crée une nouvelle instance de Map à partir d'un tableau générique * et d'une fonction de transformation. * - * @param Type des éléments du tableau source - * @param fn Fonction qui transforme un élément T en Circuit + * @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; + public static Map create(Function fn, T[][] map) { + int lenX = map[0].length; + int lenY = map.length; - Circuit[][] newmap = new Circuit[lenY][lenX]; + Circuit[][] newmap = new Circuit[lenY][lenX]; - for (int y = 0; y < lenY; y++) - { - for (int x = 0; x < lenX; x++) - { - newmap[y][x] = fn.apply(map[y][x]); - } - } + 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); - } + 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
    • + *
  • 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); - } + 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
    • + *
  • '#' -> 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); - } + 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; + private Map(Circuit[][] map) { + this.map = map; - this.width = map[0].length; - this.height = map.length; + 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); - } - } + 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(); + private boolean buildPath() { + Point[] p = bindPath(); - if (p == null) - return false; + if (p == null) + return false; - Point start = p[0]; - Point end = p[1]; + Point start = p[0]; + Point end = p[1]; - this.pathMap = new ArrayList<>(); - return followPath(start, end); - } + 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 + * @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; + 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}; - } + 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. * @@ -183,130 +315,122 @@ public class Map * @param end Point d'arrivée * @return true si un chemin complet a été trouvé, false sinon */ - private boolean followPath(Point start, Point end) - { - // remettre à 0 la liste - pathMap.clear(); + private boolean followPath(Point start, Point end) { + // remettre à 0 la liste + pathMap.clear(); - // positions - Point current = start; - Point previous = null; + // positions + Point current = start; + Point previous = null; - int[][] coord = { - {1, 0}, // haut - {-1, 0}, // bas - {0, -1}, // gauche - {0, 1} // droite - }; + 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); + // 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; + if (current.equals(end)) + return true; - boolean moved = false; + boolean moved = false; - for (int[] pos : coord) - { - int x = current.x + pos[1]; - int y = current.y + pos[0]; + 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; + if ((x >= 0 && map[0].length > x) && (y >= 0 && map.length > y)) { + Point next = new Point(x, y); - 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; - } - } - } + if (next.equals(previous)) + continue; - // Si il est bloqué - if (!moved) break; - } + 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; + } + } + } - return false; - } + // Si il est bloqué + if (!moved) + break; + } - /** + return false; + } + + /** * Retourne l'objet Circuit à la position (x, y). * * @param x Coordonnée X * @param y Coordonnée Y * @return L'objet Circuit */ - public Circuit getElement(int x, int y) - { - return map[y][x]; - } + 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(); - } + 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); - } + 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(); - } + 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; - } + 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; - } + public int getHeight() { + return this.height; + } } diff --git a/src/State.java b/src/State.java deleted file mode 100644 index 74470e4..0000000 --- a/src/State.java +++ /dev/null @@ -1,77 +0,0 @@ -/** - * State représente l'état de conduite d'une voiture. - * Il gère le mode de conduite actuel et fournit les paramètres associés - * tels que la consommation de carburant et l'intervalle de mouvement aléatoire. - */ -public class State -{ - /** - * Enum représentant les différents modes de conduite. - * Chaque mode définit : - *
    - *
  • carbUsed : carburant consommé par mouvement
    • - *
  • interval : intervalle pour générer un déplacement aléatoire
    • - *
- */ - public static enum DriveMode - { - // - NORMAL(2, 1, 6); - - /** Carburant consommé par mouvement dans ce mode */ - public final int carbUsed; - - /** Intervalle aléatoire de déplacement pour ce mode : [min, max] */ - public final int[] interval; - - /** - * Constructeur du mode de conduite. - * - * @param carbUsed Carburant consommé par mouvement - * @param fInterval Intervalle minimum du déplacement aléatoire - * @param sInterval Intervalle maximum du déplacement aléatoire - */ - private DriveMode(int carbUsed, int fInterval, int sInterval) - { - this.carbUsed = carbUsed; - interval = new int[] {fInterval, sInterval}; - } - } - - /** Mode de conduite courant */ - private DriveMode current = DriveMode.NORMAL; - - /** - * @return le mode de conduite actuel - */ - public DriveMode get() - { - return current; - } - - /** - * @return l'intervalle de déplacement aléatoire du mode courant - */ - public int[] getInterval() - { - return current.interval; - } - - /** - * @return la consommation de carburant du mode courant - */ - public int getConsumption() - { - return current.carbUsed; - } - - /** - * Change le mode de conduite actuel. - * - * @param mode nouveau mode de conduite - */ - public void setDriveMode(DriveMode mode) - { - current = mode; - } -} diff --git a/src/Track.java b/src/Track.java index bad5816..46a7a21 100644 --- a/src/Track.java +++ b/src/Track.java @@ -63,7 +63,7 @@ public class Track extends GameView { // Parcours de toutes les cellules du circuit for (int y = 0; y < rows; y++) { for (int x = 0; x < cols; x++) { - Circuit cell = this.map.getElement(x, y); + Map.Circuit cell = this.map.getElement(x, y); drawCell(g, cell, new int[] {x, y}, cellSize); } } @@ -72,7 +72,7 @@ public class Track extends GameView { /** * Retourne la couleur d'une cellule selon son type. */ - private Color getCellColor(Circuit.Cell cell) { + private Color getCellColor(Map.Circuit.Cell cell) { return switch (cell) { case ROAD -> Color.GRAY; case START -> Color.YELLOW; @@ -85,7 +85,7 @@ public class Track extends GameView { /** * Retourne le caractère à afficher pour une cellule du circuit. */ - private char getCellChar(Circuit cell) { + private char getCellChar(Map.Circuit cell) { return switch (cell.getType()) { case ROAD -> '\0'; case START -> 'D'; @@ -113,7 +113,7 @@ public class Track extends GameView { /** * Dessine une cellule complète avec son contenu (caractère et voitures). */ - private void drawCell(Graphics g, Circuit cell, int[] coord, int[] cellCoord) { + private void drawCell(Graphics g, Map.Circuit cell, int[] coord, int[] cellCoord) { drawBlock(g, cell, coord, cellCoord); char c = getCellChar(cell); @@ -171,7 +171,7 @@ public class Track extends GameView { /** * Dessine une cellule de base selon son type et ajoute un contour noir. */ - private void drawBlock(Graphics g, Circuit cell, int[] coord, int[] cellCoord) { + private void drawBlock(Graphics g, Map.Circuit cell, int[] coord, int[] cellCoord) { int x = coord[0]; int y = coord[1]; @@ -181,7 +181,7 @@ public class Track extends GameView { switch (cell.getType()) { case YROAD: // dessine le bloc de route - g.setColor(getCellColor(Circuit.Cell.ROAD)); + g.setColor(getCellColor(Map.Circuit.Cell.ROAD)); g.fillRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight); // dessine le sous bloc de route