mirror of
https://github.com/guezoloic/racing-game.git
synced 2026-03-28 18:03:50 +00:00
feat: ajout multiple fonction et factorisation
This commit is contained in:
291
src/Car.java
291
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é.
|
||||
* <p>
|
||||
* La voiture consomme du carburant à chaque déplacement, et son score
|
||||
* est calculé en fonction du nombre de tours complétés et de sa progression sur le tour actuel.
|
||||
* est calculé en fonction du nombre de tours complétés et de sa progression sur
|
||||
* le tour actuel.
|
||||
* </p>
|
||||
*/
|
||||
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<Integer> getInterval() {
|
||||
return List.of(MIN, MAX);
|
||||
}
|
||||
|
||||
public int fuelConsumption(int fuel) {
|
||||
return fuel - FUELCOST;
|
||||
}
|
||||
|
||||
public int move(int pos, int jump) {
|
||||
return pos + jump;
|
||||
}
|
||||
|
||||
public boolean isDamaged() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public State onDamageEnd() {
|
||||
return this;
|
||||
}
|
||||
|
||||
public abstract State accelerate();
|
||||
|
||||
public abstract State decelerate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Fait avancer la voiture d'un certain nombre de positions.
|
||||
* <p>
|
||||
* Si la position atteint la fin de la boucle, le compteur de tours est incrémenté et
|
||||
* la position revient à zéro.
|
||||
* </p>
|
||||
*
|
||||
* @param move nombre de positions à avancer
|
||||
* @return cette même instance (pour chaînage fluide)
|
||||
* 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.
|
||||
* <p>
|
||||
* Si la position atteint la fin de la boucle, le compteur de tours est
|
||||
* incrémenté et
|
||||
* la position revient à zéro.
|
||||
* </p>
|
||||
*
|
||||
* @param move nombre de positions à avancer
|
||||
* @return cette même instance (pour chaînage fluide)
|
||||
*/
|
||||
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.
|
||||
* <p>
|
||||
* 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.
|
||||
* </p>
|
||||
*/
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
504
src/Map.java
504
src/Map.java
@@ -3,179 +3,311 @@ 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>
|
||||
* <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>
|
||||
* <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
|
||||
{
|
||||
public class Map {
|
||||
/**
|
||||
* Représente une cellule du circuit.
|
||||
* <p>
|
||||
* Chaque cellule possède un type ({@link Cell}) et éventuellement une valeur
|
||||
* numérique (par exemple pour indiquer une intensité, une vitesse, ou un
|
||||
* identifiant de route).
|
||||
* </p>
|
||||
*/
|
||||
public static class Circuit {
|
||||
/**
|
||||
* <code>Cell</code> est un enum
|
||||
* représentant les différents types de
|
||||
* cases qui composent le circuit de
|
||||
* course.
|
||||
*/
|
||||
public static enum Cell {
|
||||
/**
|
||||
* Case hors piste, non
|
||||
* praticable par les
|
||||
* voitures.
|
||||
*/
|
||||
EMPTY,
|
||||
|
||||
/**
|
||||
* Case de route normale
|
||||
* sur laquelle les voitures
|
||||
* peuvent circuler.
|
||||
*/
|
||||
ROAD,
|
||||
|
||||
/**
|
||||
* Case correspondant à la
|
||||
* ligne de départ du circuit.
|
||||
*/
|
||||
START,
|
||||
|
||||
/**
|
||||
* Case correspondant à la
|
||||
* ligne d'arrivée du circuit.
|
||||
*/
|
||||
FINISH,
|
||||
|
||||
/**
|
||||
* Case de route jaune, plus
|
||||
* d'information sur le
|
||||
* livrable 2
|
||||
*/
|
||||
YROAD;
|
||||
}
|
||||
|
||||
/** Type de la cellule (vide, route, départ, arrivée, etc.) */
|
||||
private final Cell type;
|
||||
|
||||
/** Valeur associée à la cellule (optionnelle, dépend du type) */
|
||||
private int value;
|
||||
|
||||
/**
|
||||
* Construit une cellule avec un type défini et une valeur par défaut
|
||||
* égale à l’indice ordinal du type.
|
||||
*
|
||||
* @param type le type de la cellule
|
||||
*/
|
||||
public Circuit(Cell type) {
|
||||
this.type = type;
|
||||
this.value = type.ordinal();
|
||||
}
|
||||
|
||||
/**
|
||||
* Construit une cellule avec un type et une valeur spécifique.
|
||||
*
|
||||
* @param type le type de la cellule
|
||||
* @param value la valeur associée à la cellule
|
||||
*/
|
||||
public Circuit(Cell type, int value) {
|
||||
this.type = type;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifie la valeur associée à la cellule.
|
||||
*
|
||||
* @param value la nouvelle valeur
|
||||
* @return cette même instance (pour chaînage fluide)
|
||||
*/
|
||||
public Circuit setValue(int value) {
|
||||
this.value = value;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return le type de la cellule
|
||||
*/
|
||||
public Cell getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return la valeur associée à la cellule
|
||||
*/
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si la cellule est une route (ROAD ou YROAD).
|
||||
*
|
||||
* @return vrai si la cellule représente une route
|
||||
*/
|
||||
public boolean isRoad() {
|
||||
return type == Cell.ROAD || type == Cell.YROAD;
|
||||
}
|
||||
|
||||
public boolean isYRoad() {
|
||||
return type == Cell.YROAD;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si la cellule est un point de départ.
|
||||
*
|
||||
* @return vrai si la cellule représente le départ
|
||||
*/
|
||||
public boolean isStart() {
|
||||
return type == Cell.START;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si la cellule est un point d’arrivée.
|
||||
*
|
||||
* @return vrai si la cellule représente la fin du circuit
|
||||
*/
|
||||
public boolean isFinish() {
|
||||
return type == Cell.FINISH;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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<Point> pathMap;
|
||||
private ArrayList<Point> 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 <T> Type des éléments du tableau source
|
||||
* @param fn Fonction qui transforme un élément T en Circuit
|
||||
* @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;
|
||||
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];
|
||||
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.
|
||||
* <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>
|
||||
* <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);
|
||||
}
|
||||
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>
|
||||
* <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);
|
||||
}
|
||||
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;
|
||||
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();
|
||||
boolean isPossible = this.buildPath();
|
||||
|
||||
if (!isPossible)
|
||||
{
|
||||
System.err.println("La map contient des doublons ou est impossible à finir!");
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
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 ((x >= 0 && map[0].length > x) && (y >= 0 && map.length > y)) {
|
||||
Point next = new Point(x, y);
|
||||
|
||||
if (next.equals(previous))
|
||||
continue;
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
// Si il est bloqué
|
||||
if (!moved)
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
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];
|
||||
}
|
||||
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();
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 :
|
||||
* <ul>
|
||||
* <li>carbUsed : carburant consommé par mouvement</li>
|
||||
* <li>interval : intervalle pour générer un déplacement aléatoire</li>
|
||||
* </ul>
|
||||
*/
|
||||
public static enum DriveMode
|
||||
{
|
||||
//<CARBURANT PERDU> <PREMIER INTERVAL> <SECOND INTERVAL>
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user