teissier/SAE31_2024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changements UI

Browse Source
This commit is contained in:
Vincent
2024-10-27 16:58:15 +01:00
parent 70acc18573
commit 50d9ee2f58
33 changed files with 514 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/main/Main.java
View File

@@ -1,7 +1,8 @@
package main;
import model.MenuModel;
import controller.*;
import controller.MenuController;
import controller.SeriesSelector;
import view.*;
import javax.sound.sampled.AudioInputStream;
@@ -16,31 +17,31 @@ public class Main {
MenuModel model = new MenuModel();
MenuView view = new MenuView();
// Initialiser SeriesSelector et le passer à MenuView
SeriesSelector seriesSelector = new SeriesSelector();
view.setSeriesSelector(seriesSelector);
// Créer MenuController avec model, view et seriesSelector
new MenuController(model, view, seriesSelector);
JFrame frame = App.getInstance();
frame.add(view);
// Créer le contrôleur
new MenuController(model, view);
frame.setVisible(true);
// Chargement de la musique
PlayMusic("/Music/audio.wav");
});
}
public static void PlayMusic(String location){
public static void PlayMusic(String location) {
try {
// Utilisation de getResource pour charger l'audio
URL url = Main.class.getResource(location);
if (url != null) {
AudioInputStream audioInput = AudioSystem.getAudioInputStream(url);
Clip clip = AudioSystem.getClip();
clip.open(audioInput);
clip.start();
} else {
System.out.println("fichier introuvable");
System.out.println("Fichier audio introuvable");
}
} catch (Exception e) {
System.out.println(e);

79
src/main/java/controller/GameController.java
View File

@@ -20,8 +20,9 @@ public class GameController implements TilePlacer {
private TileDatabaseManager dbManager;
private List<Tile> currentTiles;
private int tileIndex;
private ScoreGameContext scoreGameContext; // Nouveau contexte pour le score
public GameController(GameContext gameContext, JPanel gridPanel, HexagonTile nextTilePreview) {
public GameController(GameContext gameContext, JPanel gridPanel, HexagonTile nextTilePreview, JLabel scoreLabel) {
this.gameContext = gameContext;
this.gridPanel = gridPanel;
this.hexagonMap = gameContext.getHexagonMap();
@@ -31,6 +32,9 @@ public class GameController implements TilePlacer {
this.dbManager = new TileDatabaseManager();
this.tileIndex = 0;
// Initialisation de ScoreGameContext
this.scoreGameContext = new ScoreGameContext(gameContext, scoreLabel);
loadSeries(1); // Charger la série par défaut (ex. série 1)
updatePreview();
}
@@ -40,7 +44,6 @@ public class GameController implements TilePlacer {
tileIndex = 0;
System.out.println("Série " + idSeries + " chargée avec " + currentTiles.size() + " tuiles.");
}
@Override
public void placeTile(Point position) {
@@ -52,7 +55,7 @@ public class GameController implements TilePlacer {
}
System.out.println("Placement de la tuile avec ID : " + (nextTile != null ? nextTile.getId() : "null") + " à la position : " + position);
hexTile.setTile(nextTile); // Place la tuile actuelle
gridPanel.revalidate();
gridPanel.repaint();
@@ -69,46 +72,49 @@ public class GameController implements TilePlacer {
gameContext.repaintGrid(gridPanel);
generateNextTile(); // Génère la tuile suivante
// Calcul et mise à jour du score
scoreGameContext.calculateScore();
}
}
public void initializeGame(CameraController cameraController) {
generateNextTile(); // Génère la première tuile et assigne une tuile valide à `nextTile`
Tile initialTile = getNextTile(); // Récupère la tuile générée
if (initialTile == null) {
System.out.println("Erreur : aucune tuile initiale générée.");
return; // Arrête l'initialisation si aucune tuile n'a été générée
}
System.out.println("ID de la tuile initiale générée : " + initialTile.getId()); // Affiche l'ID de la tuile initiale
int centerX = gridPanel.getPreferredSize().width / 2;
int centerY = gridPanel.getPreferredSize().height / 2;
Point initialPosition = new Point(0, 0);
initialPosition.setLocation(centerX / 50, centerY / 50); // Calcule la position centrale
placeInitialTile(initialPosition, cameraController, initialTile); // Place la première tuile
generateNextTile();
// Calculer et mettre à jour le score incluant la première tuile
scoreGameContext.calculateScore();
generateNextTile(); // Génère la tuile suivante
}
public void placeInitialTile(Point position, CameraController cameraController, Tile tile) {
if (tile == null) {
System.out.println("Erreur : tuile initiale non définie.");
return;
}
System.out.println("Placement de la tuile initiale avec ID : " + tile.getId() + " à la position : " + position);
addHexagonTile(position, gridPanel, 50, cameraController, tile); // Place la première tuile
availablePositions.remove(position); // Marque la position comme occupée
Point[] adjacentPositions = getAdjacentPositions(position);
for (Point adj : adjacentPositions) {
if (!hexagonMap.containsKey(adj)) {
@@ -123,38 +129,37 @@ public class GameController implements TilePlacer {
System.out.println("Erreur : position ou panel est null");
return;
}
int xOffset = position.x * (int) (hexSize * 3 / 2);
int yOffset = position.y * (int) (Math.sqrt(3) * hexSize);
if (cameraController != null) {
Point viewOffset = cameraController.getViewOffset();
xOffset += viewOffset.x;
yOffset += viewOffset.y;
}
if (position.x % 2 != 0) {
yOffset += (int) (Math.sqrt(3) * hexSize / 2);
}
boolean isPlaceholder = (tile == null); // Si tile est null, c'est un placeholder
HexagonTile hexTile = new HexagonTile(position, isPlaceholder);
if (tile != null) {
hexTile.setTile(tile);
} else {
System.out.println("Aucun tile n'a été fourni pour cette position : " + position);
}
hexTile.setBounds(xOffset, yOffset, hexSize, hexSize);
hexTile.addMouseListener(new HexagonMouseListener(hexTile, this, availablePositions));
hexagonMap.put(position, hexTile);
panel.add(hexTile);
panel.revalidate();
panel.repaint();
}
public void generateNextTile() {
if (tileIndex < currentTiles.size()) {
@@ -167,9 +172,6 @@ public class GameController implements TilePlacer {
System.out.println("Fin de la série. Plus de tuiles à placer.");
}
}
private void updatePreview() {
if (nextTilePreview != null) {
@@ -181,7 +183,6 @@ public class GameController implements TilePlacer {
nextTilePreview.repaint();
}
}
public Tile getNextTile() {
return nextTile;
@@ -190,21 +191,21 @@ public class GameController implements TilePlacer {
private Point[] getAdjacentPositions(Point position) {
if (position.x % 2 == 0) {
return new Point[]{
new Point(position.x + 1, position.y),
new Point(position.x - 1, position.y),
new Point(position.x, position.y + 1),
new Point(position.x, position.y - 1),
new Point(position.x + 1, position.y - 1),
new Point(position.x - 1, position.y - 1)
new Point(position.x + 1, position.y),
new Point(position.x - 1, position.y),
new Point(position.x, position.y + 1),
new Point(position.x, position.y - 1),
new Point(position.x + 1, position.y - 1),
new Point(position.x - 1, position.y - 1)
};
} else {
return new Point[]{
new Point(position.x + 1, position.y),
new Point(position.x - 1, position.y),
new Point(position.x, position.y + 1),
new Point(position.x, position.y - 1),
new Point(position.x + 1, position.y + 1),
new Point(position.x - 1, position.y + 1)
new Point(position.x + 1, position.y),
new Point(position.x - 1, position.y),
new Point(position.x, position.y + 1),
new Point(position.x, position.y - 1),
new Point(position.x + 1, position.y + 1),
new Point(position.x - 1, position.y + 1)
};
}
}

20
src/main/java/controller/HowToPlayListener.java Normal file
View File

@@ -0,0 +1,20 @@
package controller;
import view.HowToPlayView;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class HowToPlayListener implements ActionListener {
private JFrame parent;
public HowToPlayListener(JFrame parent) {
this.parent = parent;
}
@Override
public void actionPerformed(ActionEvent e) {
HowToPlayView howToPlayDialog = new HowToPlayView(parent);
howToPlayDialog.setVisible(true);
}
}

14
src/main/java/controller/MenuController.java
View File

@@ -1,15 +1,15 @@
package controller;
import model.*;
import view.*;
import model.MenuModel;
import view.MenuView;
public class MenuController {
public MenuController(MenuModel model, MenuView view) {
public MenuController(MenuModel model, MenuView view, SeriesSelector seriesSelector) {
// Assignation des action listeners aux boutons du menu
view.getQuiButton().addActionListener(new QuiListener()); // Quitte l'application
view.getResumeButton().addActionListener(new ResListener());
view.getNewGameButton().addActionListener(new NewListener());
view.getQuiButton().addActionListener(new QuiListener());
// Définir le sélecteur de séries
view.setSeriesSelector(seriesSelector);
}
}

3
src/main/java/controller/QuiListener.java
View File

@@ -1,12 +1,11 @@
package controller;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class QuiListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}

17
src/main/java/controller/ResListener.java
View File

@@ -1,17 +0,0 @@
package controller;
import view.App;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.SwingUtilities;
import view.GameView;
public class ResListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
SwingUtilities.invokeLater(() -> new GameView());
App.getInstance().dispose();
}
}

142
src/main/java/controller/ScoreGameContext.java Normal file
View File

@@ -0,0 +1,142 @@
package controller;
import model.Tile;
import model.TerrainType;
import model.Pocket;
import view.HexagonTile;
import javax.swing.*;
import java.awt.Point;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class ScoreGameContext {
private GameContext gameContext;
private int score;
private JLabel scoreLabel;
private Map<Point, Pocket> pocketMap; // Map des Pockets pour chaque tuile
private Set<Pocket> pockets; // Ensemble de toutes les Pockets
public ScoreGameContext(GameContext gameContext, JLabel scoreLabel) {
this.gameContext = gameContext;
this.scoreLabel = scoreLabel;
this.pocketMap = new HashMap<>();
this.pockets = new HashSet<>();
this.score = 0;
}
// Méthode principale pour recalculer le score en reconstruisant toutes les Pockets
public void calculateScore() {
score = 0;
pockets.clear();
pocketMap.clear();
// Parcourt chaque tuile dans la grille pour créer des Pockets par type de terrain
for (Map.Entry<Point, HexagonTile> entry : gameContext.getHexagonMap().entrySet()) {
Point position = entry.getKey();
HexagonTile hexTile = entry.getValue();
if (hexTile.isFilled()) {
Tile tile = hexTile.getTile();
// Crée ou fusionne une Pocket pour chaque type de terrain de la tuile
for (int segment = 0; segment < 6; segment++) {
TerrainType terrainType = tile.getTerrainForSegment(segment);
if (terrainType != null) {
Pocket pocket = findOrCreatePocket(position, segment, terrainType);
pocketMap.put(position, pocket);
}
}
}
}
// Calcule le score total en additionnant le score de chaque Pocket
System.out.println("Pockets and their sizes:");
for (Pocket pocket : pockets) {
System.out.println("Pocket with terrain " + pocket.getTerrainType() + " has size " + pocket.getSize());
score += pocket.calculateScore();
}
updateScoreDisplay();
}
// Recherche ou crée une Pocket pour un terrain spécifique dans une tuile
private Pocket findOrCreatePocket(Point position, int segment, TerrainType terrainType) {
Pocket newPocket = new Pocket(terrainType);
newPocket.addTile(position);
// Vérifie les voisins pour fusionner les Pockets si les segments se touchent
for (int adjSegment = 0; adjSegment < 6; adjSegment++) {
Point neighborPos = getAdjacentPositionForSegment(position, adjSegment);
Pocket neighborPocket = pocketMap.get(neighborPos);
if (neighborPocket != null && neighborPocket.getTerrainType() == terrainType) {
// Vérifie si les segments de terrain se touchent avant de fusionner les Pockets
if (areSegmentsConnected(position, neighborPos, segment, adjSegment, terrainType)) {
System.out.println("Merging pocket at " + position + " with pocket at " + neighborPos + " for terrain " + terrainType);
neighborPocket.merge(newPocket);
pockets.remove(newPocket); // Supprime la Pocket fusionnée
return neighborPocket; // Retourne la Pocket fusionnée
}
}
}
System.out.println("New pocket created at " + position + " for terrain " + terrainType);
pockets.add(newPocket); // Ajoute la nouvelle Pocket si aucune fusion n'a eu lieu
return newPocket;
}
// Vérifie si les segments de deux tuiles se touchent et partagent le même type de terrain
private boolean areSegmentsConnected(Point position1, Point position2, int segment1, int segment2, TerrainType terrainType) {
Tile tile1 = gameContext.getHexagonMap().get(position1).getTile();
Tile tile2 = gameContext.getHexagonMap().get(position2).getTile();
if (tile1 == null || tile2 == null) return false;
TerrainType terrainSegment1 = tile1.getTerrainForSegment(segment1);
TerrainType terrainSegment2 = tile2.getTerrainForSegment(segment2);
boolean connected = terrainSegment1 == terrainType && terrainSegment2 == terrainType;
if (connected) {
System.out.println("Segments connected between " + position1 + " and " + position2 + " for terrain " + terrainType);
}
return connected;
}
// Obtenir la position adjacente pour un segment spécifique (0 à 5)
private Point getAdjacentPositionForSegment(Point position, int segment) {
if (position.x % 2 == 0) {
switch (segment) {
case 0: return new Point(position.x + 1, position.y);
case 1: return new Point(position.x + 1, position.y - 1);
case 2: return new Point(position.x, position.y - 1);
case 3: return new Point(position.x - 1, position.y - 1);
case 4: return new Point(position.x - 1, position.y);
case 5: return new Point(position.x, position.y + 1);
default: return position;
}
} else {
switch (segment) {
case 0: return new Point(position.x + 1, position.y);
case 1: return new Point(position.x + 1, position.y + 1);
case 2: return new Point(position.x, position.y + 1);
case 3: return new Point(position.x - 1, position.y + 1);
case 4: return new Point(position.x - 1, position.y);
case 5: return new Point(position.x, position.y - 1);
default: return position;
}
}
}
// Met à jour l'affichage du score dans GameView
private void updateScoreDisplay() {
System.out.println("Updated Score: " + score); // Débogage du score
scoreLabel.setText("Score: " + score);
}
public int getScore() {
return score;
}
}

19
src/main/java/controller/SerieListener.java Normal file
View File

@@ -0,0 +1,19 @@
package controller;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class SerieListener implements ActionListener {
private final GameController gameController;
private final int seriesNumber;
public SerieListener(GameController gameController, int seriesNumber) {
this.gameController = gameController;
this.seriesNumber = seriesNumber;
}
@Override
public void actionPerformed(ActionEvent e) {
gameController.loadSeries(seriesNumber);
}
}

12
src/main/java/controller/SeriesSelector.java Normal file
View File

@@ -0,0 +1,12 @@
package controller;
import view.GameView;
import javax.swing.SwingUtilities;
public class SeriesSelector {
public void startGameWithSeries(int seriesId) {
SwingUtilities.invokeLater(() -> new GameView(seriesId)); // Démarre GameView avec l'ID de série donné
System.out.println("Série " + seriesId + " sélectionnée et jeu démarré.");
}
}

41
src/main/java/model/Pocket.java Normal file
View File

@@ -0,0 +1,41 @@
package model;
import java.awt.Point;
import java.util.HashSet;
import java.util.Set;
public class Pocket {
private TerrainType terrainType; // Type de terrain de cette Pocket
private Set<Point> tiles; // Ensemble des positions des tuiles de la Pocket
public Pocket(TerrainType terrainType) {
this.terrainType = terrainType;
this.tiles = new HashSet<>();
}
public TerrainType getTerrainType() {
return terrainType;
}
public int getSize() {
return tiles.size();
}
public void addTile(Point position) {
tiles.add(position);
}
public boolean containsTile(Point position) {
return tiles.contains(position);
}
public void merge(Pocket other) {
if (this.terrainType == other.terrainType) {
this.tiles.addAll(other.tiles);
}
}
public int calculateScore() {
return getSize() * getSize(); // La taille au carré donne le score
}
}

40
src/main/java/model/Tile.java
View File

@@ -1,17 +1,34 @@
package model;
public class Tile {
private int id; // Ajoute l'attribut id
private TerrainType[] terrains; // 2 terrains maximum par tuile
private int segmentsForTerrain1;
private int rotation;
private int id; // ID de la tuile
private TerrainType[] terrains; // Tableau contenant deux types de terrains (ex. MER, FORET)
private int segmentsForTerrain1; // Nombre de segments pour le premier terrain
private int rotation; // Rotation de la tuile (en multiple de 60 degrés)
// Constructeur modifié pour inclure l'ID
public Tile(int id, TerrainType terrain1, TerrainType terrain2, int segmentsForTerrain1) {
this.id = id;
this.terrains = new TerrainType[]{terrain1, terrain2};
this.segmentsForTerrain1 = segmentsForTerrain1;
this.rotation = 0;
this.rotation = 0; // Initialisation de la rotation à 0
}
// Renvoie le terrain pour l'index donné (0 ou 1)
public TerrainType getTerrain(int index) {
if (index >= 0 && index < terrains.length) {
return terrains[index];
}
return null; // Retourne null si l'index est invalide
}
// Méthode pour obtenir le terrain associé à un segment spécifique (prend en compte la rotation)
public TerrainType getTerrainForSegment(int segmentIndex) {
int adjustedIndex = (segmentIndex - rotation + 6) % 6;
if (adjustedIndex < segmentsForTerrain1) {
return terrains[0];
} else {
return terrains[1];
}
}
public void rotateClockwise() {
@@ -19,9 +36,8 @@ public class Tile {
}
public void rotateCounterClockwise() {
rotation = (rotation + 5) % 6; // Tourner dans le sens inverse, équivalent à -1 dans un modulo 6
rotation = (rotation + 5) % 6; // Tourner dans le sens inverse
}
public int getRotation() {
return rotation;
@@ -30,12 +46,4 @@ public class Tile {
public int getId() {
return id;
}
public TerrainType getTerrain(int index) {
return index >= 0 && index < 2 ? terrains[index] : null;
}
public int getSegmentsForTerrain(int index) {
return index == 0 ? segmentsForTerrain1 : 6 - segmentsForTerrain1;
}
}

15
src/main/java/view/ButtonHoverListener.java
View File

@@ -1,28 +1,27 @@
package view;
import javax.swing.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.Color;
public class ButtonHoverListener extends MouseAdapter {
private Color hoverColor = new Color(200, 150, 100);
private Color normalColor = new Color(243, 171, 115, 150);
private final Color hoverColor = new Color(200, 150, 100, 200); // Couleur de hover avec transparence
private final Color normalColor = new Color(243, 171, 115, 150); // Couleur normale avec transparence
@Override
public void mouseEntered(MouseEvent e) {
if (e.getSource() instanceof JButton) {
JButton button = (JButton) e.getSource();
if (e.getSource() instanceof BtnPerso) { // Applique uniquement aux boutons de type BtnPerso
BtnPerso button = (BtnPerso) e.getSource();
button.setBackground(hoverColor);
}
}
@Override
public void mouseExited(MouseEvent e) {
if (e.getSource() instanceof JButton) {
JButton button = (JButton) e.getSource();
if (e.getSource() instanceof BtnPerso) { // Applique uniquement aux boutons de type BtnPerso
BtnPerso button = (BtnPerso) e.getSource();
button.setBackground(normalColor);
}
}
}
}

43
src/main/java/view/GameView.java
View File

@@ -14,52 +14,48 @@ public class GameView extends JFrame {
private GameController gameController;
private CameraController cameraController;
private GameContext gameContext;
private JLabel scoreLabel;
public GameView() {
// Couleurs pour le style
private final Color hoverColor = new Color(200, 150, 100); // Couleur de hover avec transparence
private final Color normalColor = new Color(243, 171, 115); // Couleur normale avec transparence
public GameView(int seriesId) {
setTitle("Jeu de Tuiles");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
setSize(1500, 750);
setLocationRelativeTo(null);
// Initialiser le contexte de jeu
gameContext = new GameContext();
// Créer la grille d'hexagones
gridPanel = createHexagonGrid();
// Calculer et centrer la grille dans GameView
centerGridPanel();
add(gridPanel, BorderLayout.CENTER);
// Initialiser la preview pour la prochaine tuile
nextTilePreview = new HexagonTile(null, false);
scoreLabel = new JLabel("Score: 0");
scoreLabel.setForeground(Color.BLACK); // Texte noir pour contraste
JPanel controlPanel = createControlPanel();
controlPanel.setPreferredSize(new Dimension(200, 600));
add(controlPanel, BorderLayout.EAST);
// Initialiser les contrôleurs avec le contexte de jeu
gameController = new GameController(gameContext, gridPanel, nextTilePreview);
gameController = new GameController(gameContext, gridPanel, nextTilePreview, scoreLabel);
gameController.loadSeries(seriesId); // Charge la série
cameraController = new CameraController(gridPanel, gameContext);
// Ajouter un écouteur pour la molette de la souris
MouseWheelController wheelController = new MouseWheelController(nextTilePreview, gameController);
addMouseWheelListener(wheelController);
// Appeler l'initialisation du jeu
gameController.initializeGame(cameraController);
setVisible(true);
}
private JPanel createHexagonGrid() {
JPanel panel = new JPanel();
panel.setLayout(null); // Permet de placer des composants avec des coordonnées absolues
panel.setBackground(Color.WHITE);
panel.setPreferredSize(new Dimension(800, 800)); // Peut être ajusté si nécessaire
panel.setLayout(null);
panel.setBackground(normalColor); // Couleur de fond de la grille
panel.setPreferredSize(new Dimension(800, 800));
return panel;
}
@@ -67,23 +63,28 @@ public class GameView extends JFrame {
int centerX = (getWidth() - gridPanel.getPreferredSize().width) / 2;
int centerY = (getHeight() - gridPanel.getPreferredSize().height) / 2;
gameContext.updateOffset(centerX, centerY);
gameContext.repaintGrid(gridPanel); // Rappel pour centrer initialement les tuiles
gameContext.repaintGrid(gridPanel);
}
private JPanel createControlPanel() {
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setBackground(Color.LIGHT_GRAY);
panel.setBackground(normalColor); // Couleur normale pour le panneau de contrôle
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
panel.add(new JLabel("Prochaine tuile : "));
JLabel nextTileLabel = new JLabel("Prochaine tuile : ");
nextTileLabel.setForeground(Color.BLACK); // Texte noir pour contraste
panel.add(nextTileLabel);
panel.add(Box.createRigidArea(new Dimension(0, 10)));
nextTilePreview.setPreferredSize(new Dimension(150, 150));
nextTilePreview.setBackground(Color.GRAY);
nextTilePreview.setBackground(hoverColor); // Couleur hover pour différencier
nextTilePreview.setOpaque(true);
panel.add(nextTilePreview);
panel.add(Box.createRigidArea(new Dimension(0, 30)));
panel.add(scoreLabel);
return panel;
}
}

14
src/main/java/view/HexagonTile.java
View File

@@ -10,7 +10,7 @@ import java.awt.geom.Path2D;
public class HexagonTile extends JPanel {
private Tile tile;
private Point position;
private boolean isPlaceholder; // Nouveau champ pour indiquer si l'hexagone est un placeholder
private boolean isPlaceholder; // Indicateur si l'hexagone est un placeholder
public HexagonTile(Point position, boolean isPlaceholder) {
this.position = position;
@@ -50,7 +50,7 @@ public class HexagonTile extends JPanel {
g2d.setClip(largeHexagon);
if (tile != null) {
drawTerrainSegments(g2d, centerX, centerY, largeRadius, tile.getRotation());
drawTerrainSegments(g2d, centerX, centerY, largeRadius);
} else {
g2d.setColor(Color.LIGHT_GRAY);
g2d.fill(largeHexagon);
@@ -62,13 +62,11 @@ public class HexagonTile extends JPanel {
g2d.draw(largeHexagon);
}
private void drawTerrainSegments(Graphics2D g2d, int centerX, int centerY, int radius, int rotation) {
int segmentsTerrain1 = tile.getSegmentsForTerrain(0);
private void drawTerrainSegments(Graphics2D g2d, int centerX, int centerY, int radius) {
// Parcourt les segments de 0 à 5 pour dessiner chaque segment en fonction du terrain associé
for (int i = 0; i < 6; i++) {
int segmentIndex = (i + rotation) % 6;
g2d.setColor(segmentIndex < segmentsTerrain1 ?
getTerrainColor(tile.getTerrain(0)) :
getTerrainColor(tile.getTerrain(1)));
TerrainType terrain = tile.getTerrainForSegment(i); // Récupère le terrain du segment, en prenant en compte la rotation
g2d.setColor(getTerrainColor(terrain));
g2d.fillArc(centerX - radius, centerY - radius, 2 * radius, 2 * radius, 60 * i, 60);
}
}

35
src/main/java/view/HowToPlayView.java Normal file
View File

@@ -0,0 +1,35 @@
package view;
import javax.swing.*;
import java.awt.*;
public class HowToPlayView extends JDialog {
public HowToPlayView(JFrame parent) {
super(parent, "Comment Jouer", true);
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setBackground(new Color(243, 171, 115, 200));
JLabel titleLabel = new JLabel("COMMENT JOUER");
titleLabel.setFont(new Font("Helvetica", Font.BOLD, 30));
titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
panel.add(titleLabel);
JLabel instruction1 = new JLabel("Déplacer la caméra : clique droit enfoncé");
JLabel instruction2 = new JLabel("Poser des tuiles : clique gauche sur un petit hexagone");
JLabel instruction3 = new JLabel("Orientation des tuiles : Molette de la souris");
for (JLabel label : new JLabel[]{instruction1, instruction2, instruction3}) {
label.setFont(new Font("Helvetica", Font.PLAIN, 20));
label.setAlignmentX(Component.CENTER_ALIGNMENT);
panel.add(Box.createRigidArea(new Dimension(0, 10)));
panel.add(label);
}
add(panel);
setSize(600, 400);
setLocationRelativeTo(parent);
}
}

156
src/main/java/view/MenuView.java
View File

@@ -2,79 +2,177 @@ package view;
import javax.swing.*;
import java.awt.*;
import controller.SeriesSelector;
public class MenuView extends JComponent {
private BtnPerso resumeButton;
private BtnPerso newGameButton;
private JButton quitButton;
private JPanel panelCote;
private JPanel howToPlayPanel;
private JPanel centeredPanel;
private JPanel seriesPanel;
private SeriesSelector seriesSelector;
private Image backgroundImage;
private ImageIcon logo;
private ImageIcon quit;
private JPanel panelCoté;
private JLabel labelImg;
private JLabel labelImg; // Déclaration de labelImg
public MenuView() {
initMenu();
}
panelCoté = new JPanel(new GridBagLayout());
public void setSeriesSelector(SeriesSelector seriesSelector) {
this.seriesSelector = seriesSelector;
}
// Méthode pour afficher les boutons de sélection de série
public void showSeriesButtons() {
howToPlayPanel.setVisible(false);
centeredPanel.removeAll();
centeredPanel.add(seriesPanel);
seriesPanel.setVisible(true);
revalidate();
repaint();
}
// Méthode pour afficher/masquer le panneau "Comment jouer"
private void toggleHowToPlay() {
seriesPanel.setVisible(false);
howToPlayPanel.setVisible(!howToPlayPanel.isVisible());
centeredPanel.removeAll();
centeredPanel.add(howToPlayPanel);
revalidate();
repaint();
}
private void initMenu() {
// Initialisation du panneau latéral
panelCote = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
panelCoté.setBackground(new Color(243, 171, 115, 150));
panelCoté.setPreferredSize(new Dimension(300, 0));
panelCote.setBackground(new Color(243, 171, 115, 150));
panelCote.setPreferredSize(new Dimension(300, 0));
// Utilisation de getResource pour charger les images
// Charger les images
backgroundImage = new ImageIcon(getClass().getResource("/java/view/img/bg.png")).getImage();
logo = new ImageIcon(getClass().getResource("/java/view/img/D.png"));
quit = new ImageIcon(getClass().getResource("/java/view/img/quit.png"));
// Redimensionnement des images
Image quit1 = quit.getImage();
Image lg = logo.getImage();
Image resizedlg = lg.getScaledInstance(300, 300, Image.SCALE_SMOOTH);
ImageIcon logoIcon = new ImageIcon(resizedlg);
labelImg = new JLabel(logoIcon);
resumeButton = new BtnPerso("RESUME");
newGameButton = new BtnPerso("NEW GAME");
labelImg = new JLabel(new ImageIcon(resizedlg)); // Initialisation de labelImg
// Configuration du bouton "Quitter" avec une icône redimensionnée
int buttonWidth = 65;
int buttonHeight = 40;
Image resizedImage = quit1.getScaledInstance(buttonWidth, buttonHeight, Image.SCALE_SMOOTH);
ImageIcon resizedIcon = new ImageIcon(resizedImage);
// Boutons
resumeButton = new BtnPerso("JOUER");
newGameButton = new BtnPerso("COMMENT JOUER");
quitButton = new JButton(resizedIcon);
// Configurer le bouton "Quitter" pour enlever le fond et la bordure
quitButton.setPreferredSize(new Dimension(buttonWidth, buttonHeight));
quitButton.setPreferredSize(new Dimension(50, 50));
quitButton.setBackground(new Color(243, 171, 115, 150));
quitButton.setBorderPainted(false);
quitButton.setOpaque(true);
quitButton.setFocusPainted(false);
quitButton.setBackground(new Color(243, 171, 115, 150)); // Fond transparent similaire
quitButton.setBorderPainted(false); // Enlever la bordure pour un look plus propre
quitButton.setOpaque(true); // Rendre le fond visible
quitButton.setFocusPainted(false); // Enlever le focus autour du bouton
ButtonHoverListener hoverListener = new ButtonHoverListener();
resumeButton.addMouseListener(hoverListener);
newGameButton.addMouseListener(hoverListener);
quitButton.addMouseListener(hoverListener);
// Ajout des listeners pour les boutons
resumeButton.addActionListener(e -> showSeriesButtons());
newGameButton.addActionListener(e -> toggleHowToPlay());
// Créer le panneau "Comment jouer" et le panneau de séries
howToPlayPanel = createHowToPlayPanel();
howToPlayPanel.setVisible(false);
seriesPanel = createSeriesPanel();
seriesPanel.setVisible(false);
// Panneau centré pour le contenu dynamique
centeredPanel = new JPanel(new GridBagLayout());
centeredPanel.setOpaque(false);
centeredPanel.add(howToPlayPanel);
// Ajout des composants au panneau latéral
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.insets = new Insets(10, 10, 10, 10);
gbc.weightx = 1.0;
gbc.gridx = 0;
// Ajouter l'image de logo
gbc.gridy = 0;
panelCote.add(labelImg, gbc); // Ajout de labelImg ici
panelCoté.add(labelImg, gbc);
// Ajouter les boutons
gbc.gridy = 1;
panelCoté.add(resumeButton, gbc);
panelCote.add(resumeButton, gbc);
gbc.gridy = 2;
panelCoté.add(newGameButton, gbc);
panelCote.add(newGameButton, gbc);
gbc.gridy = 3;
panelCoté.add(quitButton, gbc);
panelCote.add(quitButton, gbc);
setLayout(new BorderLayout());
add(panelCoté, BorderLayout.WEST);
add(panelCote, BorderLayout.WEST);
add(centeredPanel, BorderLayout.CENTER);
}
private JPanel createHowToPlayPanel() {
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setBackground(new Color(243, 171, 115, 200));
panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
JLabel titleLabel = new JLabel("COMMENT JOUER");
titleLabel.setFont(new Font("Helvetica", Font.BOLD, 30));
titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
panel.add(titleLabel);
String[] instructions = {
"Déplacer la caméra : clique droit enfoncé",
"Poser des tuiles : clique gauche sur un petit hexagone",
"Orientation des tuiles : Molette de la souris"
};
for (String text : instructions) {
JLabel label = new JLabel(text);
label.setFont(new Font("Helvetica", Font.PLAIN, 20));
label.setAlignmentX(Component.CENTER_ALIGNMENT);
panel.add(Box.createRigidArea(new Dimension(0, 10)));
panel.add(label);
}
panel.setPreferredSize(new Dimension(700, 350));
return panel;
}
private JPanel createSeriesPanel() {
JPanel panel = new JPanel(new GridLayout(2, 2, 10, 10));
panel.setOpaque(false);
for (int i = 1; i <= 4; i++) {
int seriesId = i;
BtnPerso seriesButton = new BtnPerso("Série " + seriesId);
seriesButton.addActionListener(e -> {
if (seriesSelector != null) {
seriesSelector.startGameWithSeries(seriesId);
}
});
seriesButton.addMouseListener(new ButtonHoverListener());
panel.add(seriesButton);
}
return panel;
}
@Override