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

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());
}
}