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

ajout ui

Browse Source
This commit is contained in:
Vincent TEISSIER
2024-10-25 20:22:35 +02:00
parent abc4da1bed
commit d5825ab8f5
44 changed files with 175 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/main/java/Main.java
View File

@@ -1,54 +0,0 @@
import model.*;
import controller.*;
import view.*;
import java.io.File;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.swing.*;
public class Main {
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
MenuModel model = new MenuModel();
MenuView view = new MenuView();
JFrame frame = new JFrame(" Menu");
frame.setSize(1500, 750);
frame.setLocation(0, 0);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(view);
// Créer le contrôleur
new MenuController(model, view);
frame.setVisible(true);
String filepath = "Music/audio.wav";
PlayMusic(filepath);
});
}
public static void PlayMusic(String location){
try {
// System.out.println(location);
File musicPath = new File(location);
if(musicPath.exists()){
AudioInputStream audioInput = AudioSystem.getAudioInputStream(musicPath);
Clip clip = AudioSystem.getClip();
clip.open(audioInput);
clip.start();
} else {
System.out.println("fichier introuvable");
}
} catch (Exception e) {
System.out.println(e);
}
}
}

13
src/main/java/controller/CameraController.java
View File

@@ -8,12 +8,12 @@ public class CameraController {
private Point mouseDragStart = null; // Stocke la position de départ du clic droit
private Point viewOffset = new Point(0, 0); // Stocke le décalage actuel de la vue
private JPanel gridPanel;
private GameContext context; // Ajout de GameContext
private GameContext context;
public CameraController(JPanel gridPanel, GameContext context) {
this.gridPanel = gridPanel;
this.context = context; // Initialisation du contexte
setupMouseDragToMove();
this.context = context;
setupMouseDragToMove(); // Initialise les écouteurs pour gérer le déplacement
}
public Point getViewOffset() {
@@ -21,15 +21,14 @@ public class CameraController {
}
public void updateViewOffset(int deltaX, int deltaY) {
viewOffset.translate(deltaX, deltaY); // Mettre à jour le décalage de la vue
gridPanel.setLocation(viewOffset); // Déplacer le panneau en fonction du décalage
viewOffset.translate(deltaX, deltaY);
gridPanel.setLocation(viewOffset);
}
private void setupMouseDragToMove() {
// Utilisation de GameContext dans les gestionnaires de la souris
MousePressHandler mousePressHandler = new MousePressHandler(this, context);
MouseDragHandler mouseDragHandler = new MouseDragHandler(this, context);
gridPanel.addMouseListener(mousePressHandler);
gridPanel.addMouseMotionListener(mouseDragHandler);
}

38
src/main/java/controller/GameContext.java
View File

@@ -1,21 +1,39 @@
package controller;
import view.HexagonTile;
import java.awt.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class GameContext {
public Map<Point, HexagonTile> hexagonMap;
public GameController gameController;
public Set<Point> availablePositions;
public CameraController cameraController;
private Map<Point, HexagonTile> hexagonMap; // Stocke la grille
private Set<Point> availablePositions; // Positions libres pour les placeholders
private Point offset; // Offset global pour la grille
public GameContext(Map<Point, HexagonTile> hexagonMap, GameController gameController,
Set<Point> availablePositions, CameraController cameraController) {
this.hexagonMap = hexagonMap;
this.gameController = gameController;
this.availablePositions = availablePositions;
this.cameraController = cameraController;
public GameContext() {
this.hexagonMap = new HashMap<>();
this.availablePositions = new HashSet<>();
this.offset = new Point(0, 0); // Initialisation de l’offset à (0, 0)
}
// Getters pour la grille, les positions et l'offset
public Map<Point, HexagonTile> getHexagonMap() {
return hexagonMap;
}
public Set<Point> getAvailablePositions() {
return availablePositions;
}
public Point getOffset() {
return offset;
}
// Méthode pour mettre à jour l'offset de la grille
public void updateOffset(int deltaX, int deltaY) {
offset.translate(deltaX, deltaY);
}
}

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

@@ -3,98 +3,65 @@ package controller;
import model.Tile;
import view.HexagonTile;
import javax.swing.*;
import java.awt.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.swing.JPanel;
public class GameController {
private Map<Point, HexagonTile> hexagonMap;
private Set<Point> availablePositions;
private Tile nextTile;
private HexagonTile nextTilePreview;
private Map<Point, HexagonTile> hexagonMap; // Carte pour stocker les tuiles par position
private Set<Point> availablePositions; // Ensemble pour suivre les positions disponibles
private JPanel gridPanel;
public GameController(Map<Point, HexagonTile> hexagonMap, Set<Point> availablePositions, JPanel gridPanel, Tile nextTile, HexagonTile nextTilePreview) {
this.hexagonMap = hexagonMap;
this.availablePositions = availablePositions;
public GameController(GameContext gameContext, JPanel gridPanel, Tile nextTile, HexagonTile nextTilePreview) {
this.gridPanel = gridPanel;
this.nextTile = nextTile;
this.nextTilePreview = nextTilePreview;
// Initialiser hexagonMap et availablePositions
this.hexagonMap = new HashMap<>();
this.availablePositions = new HashSet<>();
}
public void placeInitialTile(Point position, CameraController cameraController) {
addHexagonTile(position, gridPanel, 50, cameraController); // Utilise CameraController
public void placeInitialTile(Point position, CameraController cameraController, Tile tile) {
// Place la première tuile pleine au point central
addHexagonTile(position, gridPanel, 50, cameraController, tile);
availablePositions.remove(position);
// Ajouter des placeholders autour de la première tuile
Point[] adjacentPositions = getAdjacentPositions(position);
for (Point adj : adjacentPositions) {
if (!hexagonMap.containsKey(adj)) {
availablePositions.add(adj);
addHexagonTile(adj, gridPanel, 50, cameraController); // Utilise CameraController
addHexagonTile(adj, gridPanel, 50, cameraController, null); // Passer `null` pour les placeholders
}
}
}
public void placeTile(Point position, CameraController cameraController) {
if (availablePositions.contains(position)) {
HexagonTile hexTile = hexagonMap.get(position);
if (hexTile != null && !hexTile.isFilled()) {
hexTile.setTile(nextTile); // Placer la tuile
gridPanel.revalidate(); // Forcer le rafraîchissement de l'interface graphique
gridPanel.repaint();
// Générer une nouvelle tuile et mettre à jour la prévisualisation
nextTile = generateRandomTile();
nextTilePreview.setTile(nextTile);
// Mettre à jour les positions adjacentes
updateAdjacentPositions(position, cameraController);
// Supprimer la position de la liste des positions disponibles
availablePositions.remove(position);
}
}
}
public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController) {
public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController, Tile tile) {
int xOffset = position.x * (int) (hexSize * 3 / 2);
int yOffset = position.y * (int) (Math.sqrt(3) * hexSize);
Point viewOffset = cameraController.getViewOffset();
xOffset += viewOffset.x;
yOffset += viewOffset.y;
if (position.x % 2 != 0) {
yOffset += (int) (Math.sqrt(3) * hexSize / 2);
}
HexagonTile hexTile = new HexagonTile(position);
hexTile.setTile(tile); // Place la tuile fournie, ou null pour un placeholder
hexTile.setBounds(xOffset, yOffset, hexSize, hexSize);
// Ajout de l'écouteur pour gérer le clic sur l'hexagone
hexTile.addMouseListener(new HexagonMouseListener(hexTile, this, availablePositions, cameraController));
hexagonMap.put(position, hexTile);
panel.add(hexTile);
panel.revalidate();
panel.repaint();
}
private void updateAdjacentPositions(Point position, CameraController cameraController) {
Point[] adjacentPositions = getAdjacentPositions(position);
for (Point adj : adjacentPositions) {
if (!hexagonMap.containsKey(adj)) {
availablePositions.add(adj);
addHexagonTile(adj, gridPanel, 50, cameraController); // Utilise les nouvelles positions logiques
}
}
}
private Point[] getAdjacentPositions(Point position) {
return new Point[]{
@@ -106,8 +73,4 @@ public class GameController {
new Point(position.x - 1, position.y + 1)
};
}
private Tile generateRandomTile() {
return new Tile();
}
}

10
src/main/java/controller/HexagonMouseListener.java
View File

@@ -9,15 +9,11 @@ import java.util.Set;
public class HexagonMouseListener extends MouseAdapter {
private final HexagonTile hexTile;
private final GameController gameController;
private final Set<Point> availablePositions;
private final CameraController cameraController; // Ajouter CameraController
public HexagonMouseListener(HexagonTile hexTile, GameController gameController, Set<Point> availablePositions, CameraController cameraController) {
this.hexTile = hexTile;
this.gameController = gameController;
this.availablePositions = availablePositions;
this.cameraController = cameraController; // Initialiser CameraController
}
@Override
@@ -25,12 +21,10 @@ public class HexagonMouseListener extends MouseAdapter {
Point position = hexTile.getPosition();
if (availablePositions.contains(position)) {
System.out.println("Hexagone cliqué à la position : " + position);
gameController.placeTile(position, cameraController); // Appelle la méthode pour placer une tuile
// Logique de placement de la tuile ou appel à GameController ici si nécessaire
// Par exemple, nous pourrions générer la tuile suivante directement ici
} else {
System.out.println("Position non disponible pour le placement");
}
}
}

43
src/main/java/controller/MouseDragHandler.java
View File

@@ -1,18 +1,15 @@
package controller;
import view.HexagonTile;
import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import java.util.Map;
import java.awt.Point;
import javax.swing.SwingUtilities;
public class MouseDragHandler extends MouseAdapter {
private CameraController controller;
private GameContext context; // Utiliser GameContext pour regrouper les données
private GameContext context;
public MouseDragHandler(CameraController controller, GameContext context) {
this.controller = controller;
@@ -26,8 +23,8 @@ public class MouseDragHandler extends MouseAdapter {
int deltaX = current.x - controller.getMouseDragStart().x;
int deltaY = current.y - controller.getMouseDragStart().y;
// Déplacer uniquement les coordonnées visuelles, pas les coordonnées logiques
for (HexagonTile hexTile : context.hexagonMap.values()) {
// Déplace chaque tuile dans le contexte de la grille
for (HexagonTile hexTile : context.getHexagonMap().values()) {
Point currentPos = hexTile.getLocation();
hexTile.setLocation(currentPos.x + deltaX, currentPos.y + deltaY);
}
@@ -44,37 +41,7 @@ public class MouseDragHandler extends MouseAdapter {
@Override
public void mouseReleased(MouseEvent e) {
if (SwingUtilities.isRightMouseButton(e)) {
// Recalculer les positions logiques lorsque la souris est relâchée
Map<Point, HexagonTile> newHexagonMap = new HashMap<>();
for (Map.Entry<Point, HexagonTile> entry : context.hexagonMap.entrySet()) {
HexagonTile hexTile = entry.getValue();
Point newLogicalPosition = calculateNewLogicalPosition(hexTile.getLocation());
// Mettre à jour les écouteurs de la souris
hexTile.removeMouseListener(hexTile.getMouseListeners()[0]); // Supprimer l'ancien écouteur
hexTile.addMouseListener(new HexagonMouseListener(hexTile, context.gameController, context.availablePositions, context.cameraController));
// Ajouter la nouvelle position logique dans la nouvelle carte
newHexagonMap.put(newLogicalPosition, hexTile);
}
// Remplacer la carte hexagonMap avec la nouvelle carte
context.hexagonMap.clear();
context.hexagonMap.putAll(newHexagonMap);
controller.resetMouseDragStart();
}
}
private Point calculateNewLogicalPosition(Point visualPosition) {
int logicalX = visualPosition.x / (int) (50 * 3 / 2); // Ajuste pour la largeur de l'hexagone
int logicalY = visualPosition.y / (int) (Math.sqrt(3) * 50); // Ajuste pour la hauteur de l'hexagone
if (logicalX % 2 != 0) {
logicalY -= (int) (Math.sqrt(3) * 50 / 2); // Ajustement pour les colonnes impaires
}
return new Point(logicalX, logicalY);
}
}

42
src/main/java/controller/MousePressHandler.java
View File

@@ -1,22 +1,14 @@
package controller;
import view.HexagonTile;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.HashMap;
import java.util.Map;
import javax.swing.SwingUtilities;
public class MousePressHandler extends MouseAdapter {
private CameraController controller;
private GameContext context; // Ajout du GameContext
public MousePressHandler(CameraController controller, GameContext context) {
this.controller = controller;
this.context = context; // Utilisation du contexte
}
@Override
@@ -28,37 +20,9 @@ public class MousePressHandler extends MouseAdapter {
}
@Override
public void mouseReleased(MouseEvent e) {
if (SwingUtilities.isRightMouseButton(e)) {
// Créer une nouvelle carte pour stocker les nouvelles positions logiques
Map<Point, HexagonTile> newHexagonMap = new HashMap<>();
for (Map.Entry<Point, HexagonTile> entry : context.hexagonMap.entrySet()) {
HexagonTile hexTile = entry.getValue();
Point newLogicalPosition = calculateNewLogicalPosition(hexTile.getLocation());
// Ajouter la nouvelle position logique dans la nouvelle carte
newHexagonMap.put(newLogicalPosition, hexTile);
public void mouseReleased(MouseEvent e) {
if (SwingUtilities.isRightMouseButton(e)) {
controller.resetMouseDragStart();
}
// Remplacer l'ancienne carte après avoir terminé l'itération
Map<Point, HexagonTile> oldHexagonMap = context.hexagonMap; // Sauvegarder l'ancienne référence
context.hexagonMap = newHexagonMap; // Réassigner la nouvelle carte
oldHexagonMap.clear(); // Vider l'ancienne carte (maintenant non utilisée)
controller.resetMouseDragStart();
}
}
private Point calculateNewLogicalPosition(Point visualPosition) {
int logicalX = visualPosition.x / (int) (50 * 3 / 2);
int logicalY = visualPosition.y / (int) (Math.sqrt(3) * 50);
if (logicalX % 2 != 0) {
logicalY -= (int) (Math.sqrt(3) * 50 / 2);
}
return new Point(logicalX, logicalY);
}
}

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

@@ -2,10 +2,14 @@ package controller;
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) {
System.out.println("Juste pour tester ");
SwingUtilities.invokeLater(() -> new GameView());
}
}

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

@@ -7,90 +7,90 @@ import model.Tile;
import javax.swing.*;
import java.awt.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class GameView extends JFrame {
private JPanel gridPanel;
private Map<Point, HexagonTile> hexagonMap;
private Set<Point> availablePositions;
private Tile nextTile;
private HexagonTile nextTilePreview;
private GameController gameController;
private CameraController cameraController;
private GameContext gameContext;
public GameView() {
this.hexagonMap = new HashMap<>();
this.availablePositions = new HashSet<>();
setTitle("Jeu de Tuiles");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
setSize(1500, 750);
setLocationRelativeTo(null);
// Générer la première tuile aléatoire
nextTile = generateRandomTile();
// Initialiser le contexte de jeu
gameContext = new GameContext();
// Créer la grille d'hexagones à gauche
// Créer la grille d'hexagones
gridPanel = createHexagonGrid();
gridPanel.setLayout(null); // Permet de placer les éléments sans layout manager
gridPanel.setPreferredSize(new Dimension(800, 800)); // Taille de la grille adaptée
// Calculer et centrer la grille dans GameView
centerGridPanel();
// Ajout de la grille sans JScrollPane
add(gridPanel, BorderLayout.CENTER);
// Créer le panneau de contrôle à droite
JPanel controlPanel = createControlPanel();
controlPanel.setPreferredSize(new Dimension(200, 600)); // Taille fixe pour le panneau de contrôle
controlPanel.setPreferredSize(new Dimension(200, 600));
add(controlPanel, BorderLayout.EAST);
// Initialiser GameContext
GameContext context = new GameContext(hexagonMap, gameController, availablePositions, cameraController);
// Initialiser les contrôleurs avec le contexte de jeu
gameController = new GameController(gameContext, gridPanel, nextTile, nextTilePreview);
cameraController = new CameraController(gridPanel, gameContext);
// Initialiser le contrôleur du jeu avec le contexte
gameController = new GameController(hexagonMap, availablePositions, gridPanel, nextTile, nextTilePreview);
// Générer une première tuile pleine et la placer au centre
placeInitialTileWithRandomTile();
// Initialiser le contrôleur de la souris pour le glissement de la grille avec le contexte
cameraController = new CameraController(gridPanel, context);
// Placer la première tuile au centre en passant CameraController
Point initialPosition = new Point(0, 0);
gameController.placeInitialTile(initialPosition, cameraController);
pack();
setLocationRelativeTo(null);
setVisible(true);
}
private JPanel createHexagonGrid() {
JPanel panel = new JPanel();
panel.setLayout(null); // Layout libre pour placer les hexagones
panel.setBackground(Color.WHITE); // S'assurer que le fond est blanc pour mieux voir les hexagones
panel.setPreferredSize(new Dimension(1000, 1000)); // Taille initiale suffisamment grande
panel.setLayout(null);
panel.setBackground(Color.WHITE);
panel.setPreferredSize(new Dimension(800, 800));
return panel;
}
private void centerGridPanel() {
int gridX = (getWidth() - gridPanel.getPreferredSize().width) / 2;
int gridY = (getHeight() - gridPanel.getPreferredSize().height) / 2;
gridPanel.setLocation(gridX, gridY);
gameContext.updateOffset(gridX, gridY); // Mettre à jour l'offset dans GameContext
}
private Tile generateRandomTile() {
return new Tile();
return new Tile(); // Génère une tuile aléatoire avec des caractéristiques définies dans Tile.java
}
private void placeInitialTileWithRandomTile() {
// Générer une première tuile pleine de manière aléatoire
Tile initialTile = generateRandomTile();
// Utiliser `placeInitialTile` pour placer cette tuile au centre de la grille
Point initialPosition = new Point(0, 0);
gameController.placeInitialTile(initialPosition, cameraController, initialTile);
}
private JPanel createControlPanel() {
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
panel.setBackground(Color.LIGHT_GRAY); // Améliorer la visibilité du panneau de contrôle
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // Ajout d'espacement interne
panel.setBackground(Color.LIGHT_GRAY);
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
panel.add(new JLabel("Prochaine tuile : "));
panel.add(Box.createRigidArea(new Dimension(0, 10)));
// Afficher la prévisualisation de la prochaine tuile
nextTilePreview = new HexagonTile(null);
nextTilePreview.setPreferredSize(new Dimension(150, 150)); // Augmenter la taille pour la prévisualisation
nextTilePreview.setPreferredSize(new Dimension(150, 150));
nextTilePreview.setBackground(Color.GRAY);
nextTilePreview.setOpaque(true); // Rendre le fond opaque pour une meilleure visibilité
nextTilePreview.setTile(nextTile);
nextTilePreview.setOpaque(true);
panel.add(nextTilePreview);
return panel;

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

@@ -3,7 +3,6 @@ package view;
import javax.swing.*;
import java.awt.*;
public class MenuView extends JComponent {
private BtnPerso resumeButton;
private BtnPerso newGameButton;
@@ -14,42 +13,38 @@ public class MenuView extends JComponent {
private ImageIcon quit;
private JPanel panelCoté;
private JLabel labelImg;
public MenuView(){
public MenuView() {
panelCoté = new JPanel(new GridBagLayout());
panelCoté = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
panelCoté.setBackground(new Color(243,171,115,150));
panelCoté.setPreferredSize(new Dimension(300,0));
panelCoté.setBackground(new Color(243, 171, 115, 150));
panelCoté.setPreferredSize(new Dimension(300, 0));
backgroundImage = new ImageIcon("./view/img/bg.png").getImage();
logo = new ImageIcon("\\\\wsl.localhost\\Ubuntu-24.04\\home\\topb\\DEV\\SAE31_2024\\src\\main\\java\\view\\img\\D.png");
quit = new ImageIcon("\\\\wsl.localhost\\Ubuntu-24.04\\home\\topb\\DEV\\SAE31_2024\\src\\main\\java\\view\\img\\quit.png");
// Utilisation de getResource pour charger les images
backgroundImage = new ImageIcon(getClass().getResource("/view/img/bg.png")).getImage();
logo = new ImageIcon(getClass().getResource("/view/img/D.png"));
quit = new ImageIcon(getClass().getResource("/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");
int buttonWidth = 65;
int buttonHeight = 40;
Image resizedImage = quit1.getScaledInstance(buttonWidth, buttonHeight, Image.SCALE_SMOOTH);
Image resizedImage = quit1.getScaledInstance(buttonWidth, buttonHeight, Image.SCALE_SMOOTH);
ImageIcon resizedIcon = new ImageIcon(resizedImage);
quitButton = new JButton(resizedIcon);
quitButton.setPreferredSize(new Dimension(buttonWidth, buttonHeight));
quitButton.setPreferredSize(new Dimension(50,50));
quitButton.setPreferredSize(new Dimension(50, 50));
quitButton.setBackground(new Color(243, 171, 115, 150));
quitButton.setBorderPainted(false);
quitButton.setOpaque(true);
@@ -66,13 +61,11 @@ public class MenuView extends JComponent {
gbc.gridx = 0;
gbc.gridy = 0;
panelCoté.add(labelImg,gbc);
panelCoté.add(labelImg, gbc);
gbc.gridy = 1;
panelCoté.add(resumeButton,gbc);
panelCoté.add(resumeButton, gbc);
gbc.gridy = 2;
panelCoté.add(newGameButton, gbc);
@@ -80,12 +73,8 @@ public class MenuView extends JComponent {
gbc.gridy = 3;
panelCoté.add(quitButton, gbc);
setLayout(new BorderLayout());
add(panelCoté,BorderLayout.WEST);
add(panelCoté, BorderLayout.WEST);
}
@Override
@@ -93,6 +82,7 @@ public class MenuView extends JComponent {
super.paintComponent(g);
g.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this);
}
public BtnPerso getResumeButton() {
return resumeButton;
}
@@ -101,8 +91,7 @@ public class MenuView extends JComponent {
return newGameButton;
}
public JButton getQuiButton(){
public JButton getQuiButton() {
return quitButton;
}
}