* 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- * 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: + *
*START et FINISHSTART et FINISH+ * 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 ArrayListMap
*/
- public static 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.
* 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 :
- *