mirror of
https://github.com/guezoloic/L3-racing-game.git
synced 2026-03-31 04:11:33 +00:00
feat!: rework de tout le projet
This commit is contained in:
216
src/visual/Track.java
Normal file
216
src/visual/Track.java
Normal file
@@ -0,0 +1,216 @@
|
||||
package visual;
|
||||
import java.awt.Color;
|
||||
import java.awt.Font;
|
||||
import java.awt.FontMetrics;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Point;
|
||||
import java.util.ArrayList;
|
||||
|
||||
import model.Game;
|
||||
import model.car.BasicCar;
|
||||
import model.map.Circuit;
|
||||
import model.map.Map;
|
||||
|
||||
/**
|
||||
* <code>Track</code> est une vue graphique représentant le circuit de course
|
||||
* ainsi que les voitures qui y circulent.
|
||||
* Cette classe hérite de <code>GameView</code> pour être intégrée au système de vues.
|
||||
* <p>
|
||||
* Le rendu est basé sur une grille définie par <code>Map</code> et chaque cellule
|
||||
* est dessinée selon son type. Les voitures sont superposées sur la grille.
|
||||
* </p>
|
||||
*/
|
||||
public class Track extends GameView {
|
||||
/** La carte du circuit */
|
||||
private Map map;
|
||||
/** Liste des voitures à dessiner */
|
||||
private ArrayList<BasicCar> cars;
|
||||
/** Échelle utilisée pour ajuster la taille des voitures dans les cellules */
|
||||
private final int scale = 80;
|
||||
|
||||
/**
|
||||
* Construit la vue Track avec une carte et une liste de voitures.
|
||||
*
|
||||
* @param map La carte du circuit
|
||||
* @param cars Liste des voitures
|
||||
* @param title Titre de la fenêtre
|
||||
* @param width Largeur de la fenêtre
|
||||
* @param height Hauteur de la fenêtre
|
||||
* @param x Position X de la fenêtre
|
||||
* @param y Position Y de la fenêtre
|
||||
*/
|
||||
protected Track(Game game, String title, int width, int height, int x, int y)
|
||||
{
|
||||
super(game, title, width, height, x, y);
|
||||
map = game.getMap();
|
||||
cars = game.getCars();
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode de dessin appelée automatiquement par Swing.
|
||||
* Dessine chaque cellule de la carte ainsi que les voitures.
|
||||
*/
|
||||
@Override
|
||||
protected void paintComponent(Graphics g) {
|
||||
super.paintComponent(g);
|
||||
|
||||
int rows = map.getHeight();
|
||||
int cols = map.getWidth();
|
||||
|
||||
// Calcul de la taille d'une cellule en pixels selon la taille de la fenêtre
|
||||
int[] cellSize = new int[] {
|
||||
(getWidth() + 10) / cols,
|
||||
(getHeight() + 10) / rows
|
||||
};
|
||||
|
||||
// Définir une police monospace en gras pour les caractères du circuit
|
||||
g.setFont(new Font("Monospaced", Font.BOLD, cellSize[1] / 2));
|
||||
|
||||
// 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);
|
||||
drawCell(g, cell, new int[] {x, y}, cellSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la couleur d'une cellule selon son type.
|
||||
*/
|
||||
private Color getCellColor(Circuit.Cell cell) {
|
||||
return switch (cell) {
|
||||
case ROAD -> Color.GRAY;
|
||||
case START -> Color.YELLOW;
|
||||
case FINISH -> Color.YELLOW;
|
||||
case EMPTY -> Color.GREEN;
|
||||
case YROAD -> Color.YELLOW;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne le caractère à afficher pour une cellule du circuit.
|
||||
*/
|
||||
private char getCellChar(Circuit cell) {
|
||||
return switch (cell.getType()) {
|
||||
case ROAD -> '\0';
|
||||
case START -> 'D';
|
||||
case FINISH -> 'A';
|
||||
case EMPTY -> '\0';
|
||||
case YROAD -> (char)('0' + cell.getValue());
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Dessine toutes les voitures sur une cellule donnée.
|
||||
* Les voitures sont légèrement décalées pour ne pas avoir exactement la même taille.
|
||||
*/
|
||||
private void drawCars(Graphics g, int[] cellCoord) {
|
||||
int size = 1;
|
||||
for (BasicCar c : cars) {
|
||||
int i = c.getPos();
|
||||
Point p = this.map.getPath(i);
|
||||
int[] ncoord = new int[] {p.x, p.y};
|
||||
drawInnerBlock(g, ncoord, cellCoord, c.getColor(), scale - size);
|
||||
size += 3; // pour différencier visuellement les voitures
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Dessine une cellule complète avec son contenu (caractère et voitures).
|
||||
*/
|
||||
private void drawCell(Graphics g, Circuit cell, int[] coord, int[] cellCoord) {
|
||||
drawBlock(g, cell, coord, cellCoord);
|
||||
|
||||
char c = getCellChar(cell);
|
||||
if (c != '\0') {
|
||||
drawCharacter(g, coord, cellCoord, c);
|
||||
}
|
||||
|
||||
drawCars(g, cellCoord);
|
||||
}
|
||||
|
||||
/**
|
||||
* Dessine un caractère centré dans une cellule.
|
||||
*/
|
||||
private void drawCharacter(Graphics g, int[] coord, int[] cellCoord, char c) {
|
||||
int x = coord[0];
|
||||
int y = coord[1];
|
||||
|
||||
int cellWidth = cellCoord[0];
|
||||
int cellHeight = cellCoord[1];
|
||||
|
||||
String s = c + "";
|
||||
g.setColor(Color.BLACK);
|
||||
|
||||
FontMetrics fm = g.getFontMetrics();
|
||||
// taille du string + font
|
||||
int textWidth = fm.stringWidth(s);
|
||||
// hauteur haute par exemple: h depasse en haut
|
||||
int textHeight = fm.getAscent();
|
||||
// hauteur basse par exemple: g depasse en bas
|
||||
int descent = fm.getDescent();
|
||||
|
||||
int cx = x * cellWidth + (cellWidth - textWidth) / 2;
|
||||
int cy = y * cellHeight + (cellHeight + textHeight - descent) / 2;
|
||||
|
||||
g.drawString(s, cx, cy);
|
||||
}
|
||||
|
||||
/**
|
||||
* Dessine un bloc intérieur plus petit, utilisé pour représenter une voiture
|
||||
*/
|
||||
private void drawInnerBlock(Graphics g, int[] coord, int[] cellCoord, Color c, int scale) {
|
||||
// scale de la taille du bloc
|
||||
int w = cellCoord[0] * scale / 100;
|
||||
int h = cellCoord[1] * scale / 100;
|
||||
|
||||
// calcul de la position avec la nouvelle taille
|
||||
int ox = coord[0] * cellCoord[0] + (cellCoord[0] - w) / 2;
|
||||
int oy = coord[1] * cellCoord[1] + (cellCoord[1] - h) / 2;
|
||||
|
||||
// dessine le bloc plus petit
|
||||
g.setColor(c);
|
||||
g.fillRect(ox, oy, w, h);
|
||||
}
|
||||
|
||||
/**
|
||||
* Dessine une cellule de base selon son type et ajoute un contour noir.
|
||||
*/
|
||||
private void drawBlock(Graphics g, Circuit cell, int[] coord, int[] cellCoord) {
|
||||
int x = coord[0];
|
||||
int y = coord[1];
|
||||
|
||||
int cellWidth = cellCoord[0];
|
||||
int cellHeight = cellCoord[1];
|
||||
|
||||
switch (cell.getType()) {
|
||||
case YROAD:
|
||||
// dessine le bloc de route
|
||||
g.setColor(getCellColor(Circuit.Cell.ROAD));
|
||||
g.fillRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight);
|
||||
|
||||
// dessine le sous bloc de route
|
||||
drawInnerBlock(g, coord, cellCoord, getCellColor(cell.getType()), scale);
|
||||
break;
|
||||
default:
|
||||
g.setColor(getCellColor(cell.getType()));
|
||||
g.fillRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight);
|
||||
break;
|
||||
}
|
||||
|
||||
// contour noir
|
||||
g.setColor(Color.BLACK);
|
||||
g.drawRect(x * cellWidth, y * cellHeight, cellWidth, cellHeight);
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode appelée automatiquement pour mettre à jour l'affichage.
|
||||
*/
|
||||
@Override
|
||||
public boolean apply()
|
||||
{
|
||||
repaint();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user