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

Pair Programming (bamba, david, vincent ) -fix grille + rotations

Browse Source
This commit is contained in:
Vincent
2024-10-25 22:22:11 +02:00
parent d5825ab8f5
commit 07515d748d
25 changed files with 252 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,36 +1,34 @@
package controller;
import javax.swing.*;
import java.awt.*;
import javax.swing.JPanel;
import java.awt.Point;
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 Point mouseDragStart = null;
private GameContext context;
private JPanel gridPanel;
public CameraController(JPanel gridPanel, GameContext context) {
this.gridPanel = gridPanel;
this.context = context;
setupMouseDragToMove(); // Initialise les écouteurs pour gérer le déplacement
}
public Point getViewOffset() {
return viewOffset;
setupMouseDragToMove(gridPanel); // Initialise les écouteurs pour gérer le déplacement
}
public void updateViewOffset(int deltaX, int deltaY) {
viewOffset.translate(deltaX, deltaY);
gridPanel.setLocation(viewOffset);
// Met à jour uniquement l'offset dans GameContext
context.updateOffset(deltaX, deltaY);
// Repeindre la grille après mise à jour
context.repaintGrid(gridPanel);
// Debug : Affiche l'offset actuel
System.out.println("Nouvel offset dans GameContext : " + context.getOffset());
}
private void setupMouseDragToMove() {
MousePressHandler mousePressHandler = new MousePressHandler(this, context);
MouseDragHandler mouseDragHandler = new MouseDragHandler(this, context);
gridPanel.addMouseListener(mousePressHandler);
gridPanel.addMouseMotionListener(mouseDragHandler);
private void setupMouseDragToMove(JPanel gridPanel) {
gridPanel.addMouseListener(new MousePressHandler(this, context));
gridPanel.addMouseMotionListener(new MouseDragHandler(this, context));
}
public void setMouseDragStart(Point point) {
@@ -45,7 +43,7 @@ public class CameraController {
this.mouseDragStart = null;
}
public JPanel getGridPanel() {
return gridPanel;
public Point getViewOffset() {
return context.getOffset();
}
}

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

@@ -1,12 +1,12 @@
package controller;
import view.HexagonTile;
import java.awt.*;
import java.awt.Point;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.swing.JPanel;
public class GameContext {
private Map<Point, HexagonTile> hexagonMap; // Stocke la grille
@@ -36,4 +36,30 @@ public class GameContext {
public void updateOffset(int deltaX, int deltaY) {
offset.translate(deltaX, deltaY);
}
// Ajout de la méthode pour recalculer les positions de la grille en fonction de l'offset
public void repaintGrid(JPanel gridPanel) {
for (Map.Entry<Point, HexagonTile> entry : hexagonMap.entrySet()) {
Point position = entry.getKey();
HexagonTile tile = entry.getValue();
// Calcule la position avec l'offset
int xOffset = position.x * (int) (50 * 3 / 2); // Ajuste la distance horizontale
int yOffset = position.y * (int) (Math.sqrt(3) * 50); // Ajuste la distance verticale
// Si la colonne est impaire, décale la tuile d'une demi-hauteur d'hexagone
if (position.x % 2 != 0) {
yOffset += (int) (Math.sqrt(3) * 50 / 2);
}
// Applique l'offset de vue
xOffset += offset.x;
yOffset += offset.y;
// Met à jour la position de l'hexagone
tile.setBounds(xOffset, yOffset, 50, 50);
}
gridPanel.revalidate();
gridPanel.repaint();
}
}

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

@@ -4,58 +4,120 @@ import model.Tile;
import view.HexagonTile;
import javax.swing.*;
import java.awt.*;
import java.util.HashMap;
import java.util.HashSet;
import java.awt.Point;
import java.util.Map;
import java.util.Set;
public class GameController {
private Map<Point, HexagonTile> hexagonMap; // Carte pour stocker les tuiles par position
private Set<Point> availablePositions; // Ensemble pour suivre les positions disponibles
private Map<Point, HexagonTile> hexagonMap;
private Set<Point> availablePositions;
private JPanel gridPanel;
private Tile nextTile;
private HexagonTile nextTilePreview;
private GameContext gameContext;
public GameController(GameContext gameContext, JPanel gridPanel, Tile nextTile, HexagonTile nextTilePreview) {
this.gameContext = gameContext;
this.gridPanel = gridPanel;
this.hexagonMap = gameContext.getHexagonMap();
this.availablePositions = gameContext.getAvailablePositions();
this.nextTile = nextTile;
this.nextTilePreview = nextTilePreview;
// Initialiser hexagonMap et availablePositions
this.hexagonMap = new HashMap<>();
this.availablePositions = new HashSet<>();
// Mettre à jour la preview initiale
updatePreview();
}
public void placeTile(Point position) {
// Vérifier si la position est disponible
if (availablePositions.contains(position)) {
HexagonTile hexTile = hexagonMap.get(position);
if (hexTile == null) {
System.out.println("Erreur: hexTile est null à la position : " + position);
return;
}
// Assigner la tuile actuelle
hexTile.setTile(nextTile);
gridPanel.revalidate();
gridPanel.repaint();
// Retirer la position des positions disponibles
availablePositions.remove(position);
// Mettre à jour les positions adjacentes
Point[] adjacentPositions = getAdjacentPositions(position);
for (Point adj : adjacentPositions) {
if (!hexagonMap.containsKey(adj)) {
availablePositions.add(adj);
addHexagonTile(adj, gridPanel, 50, null, null); // Ajouter des placeholders
}
}
// Repeindre la grille
gameContext.repaintGrid(gridPanel);
// Générer une nouvelle tuile pour la prochaine preview
generateNextTile();
}
}
public void initializeGame(CameraController cameraController) {
Tile initialTile = generateRandomTile();
int centerX = gridPanel.getPreferredSize().width / 2;
int centerY = gridPanel.getPreferredSize().height / 2;
Point initialPosition = new Point(0, 0);
initialPosition.setLocation(centerX / 50, centerY / 50);
placeInitialTile(initialPosition, cameraController, initialTile);
// Générer la première tuile pour la preview
generateNextTile();
}
public void placeInitialTile(Point position, CameraController cameraController, Tile tile) {
// Place la première tuile pleine au point central
addHexagonTile(position, gridPanel, 50, cameraController, tile);
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, null); // Passer `null` pour les placeholders
addHexagonTile(adj, gridPanel, 50, cameraController, null);
}
}
}
public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController, Tile tile) {
if (position == null || panel == null) {
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);
Point viewOffset = cameraController.getViewOffset();
xOffset += viewOffset.x;
yOffset += viewOffset.y;
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);
}
HexagonTile hexTile = new HexagonTile(position);
hexTile.setTile(tile); // Place la tuile fournie, ou null pour un placeholder
hexTile.setBounds(xOffset, yOffset, hexSize, hexSize);
if (tile != null) {
hexTile.setTile(tile);
} else {
System.out.println("Aucun tile n'a été fourni pour cette position : " + position);
}
// Ajout de l'écouteur pour gérer le clic sur l'hexagone
hexTile.addMouseListener(new HexagonMouseListener(hexTile, this, availablePositions, cameraController));
hexTile.setBounds(xOffset, yOffset, hexSize, hexSize);
hexTile.addMouseListener(new HexagonMouseListener(hexTile, this, availablePositions));
hexagonMap.put(position, hexTile);
panel.add(hexTile);
@@ -63,14 +125,44 @@ public class GameController {
panel.repaint();
}
public void generateNextTile() {
// Génère une nouvelle tuile pour la prochaine pose
nextTile = new Tile();
updatePreview();
}
private void updatePreview() {
nextTilePreview.setTile(nextTile);
nextTilePreview.repaint();
}
private Point[] getAdjacentPositions(Point position) {
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)
};
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)
};
} 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)
};
}
}
private Tile generateRandomTile() {
return new Tile();
}
public Tile getNextTile() {
return nextTile;
}
}

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

@@ -1,18 +1,19 @@
package controller;
import view.HexagonTile;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.Point;
import java.util.Set;
public class HexagonMouseListener extends MouseAdapter {
private final HexagonTile hexTile;
private final GameController gameController;
private final Set<Point> availablePositions;
public HexagonMouseListener(HexagonTile hexTile, GameController gameController, Set<Point> availablePositions, CameraController cameraController) {
public HexagonMouseListener(HexagonTile hexTile, GameController gameController, Set<Point> availablePositions) {
this.hexTile = hexTile;
this.gameController = gameController;
this.availablePositions = availablePositions;
}
@@ -21,8 +22,12 @@ public class HexagonMouseListener extends MouseAdapter {
Point position = hexTile.getPosition();
if (availablePositions.contains(position)) {
System.out.println("Hexagone cliqué à la position : " + position);
// 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
// Appeler le GameController pour placer une nouvelle tuile à cet emplacement
gameController.placeTile(position);
// Générer la prochaine tuile après avoir placé celle-ci
gameController.generateNextTile();
} else {
System.out.println("Position non disponible pour le placement");
}

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

@@ -4,12 +4,8 @@ import view.*;
public class MenuController {
private MenuModel model;
private MenuView view;
public MenuController(MenuModel model, MenuView view) {
this.model = model;
this.view = view;
view.getResumeButton().addActionListener(new ResListener());
view.getNewGameButton().addActionListener(new NewListener());

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

@@ -1,6 +1,5 @@
package controller;
import view.HexagonTile;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.Point;
@@ -9,11 +8,9 @@ import javax.swing.SwingUtilities;
public class MouseDragHandler extends MouseAdapter {
private CameraController controller;
private GameContext context;
public MouseDragHandler(CameraController controller, GameContext context) {
this.controller = controller;
this.context = context;
}
@Override
@@ -23,18 +20,11 @@ public class MouseDragHandler extends MouseAdapter {
int deltaX = current.x - controller.getMouseDragStart().x;
int deltaY = current.y - controller.getMouseDragStart().y;
// 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);
}
// Déplacement dans CameraController
controller.updateViewOffset(deltaX, deltaY);
// Mettre à jour la position initiale pour le prochain déplacement
// Met à jour la position de départ
controller.setMouseDragStart(current);
// Rafraîchir la vue
controller.getGridPanel().revalidate();
controller.getGridPanel().repaint();
}
}

31
src/main/java/controller/MouseWheelController.java Normal file
View File

@@ -0,0 +1,31 @@
package controller;
import model.Tile;
import view.HexagonTile;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
public class MouseWheelController implements MouseWheelListener {
private HexagonTile previewTile;
private GameController gameController;
public MouseWheelController(HexagonTile previewTile, GameController gameController) {
this.previewTile = previewTile;
this.gameController = gameController;
}
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
Tile nextTile = gameController.getNextTile();
if (e.getWheelRotation() < 0) {
nextTile.rotateClockwise();
} else if (e.getWheelRotation() > 0) {
nextTile.rotateClockwise();
}
previewTile.repaint(); // Mettre à jour l'aperçu avec la nouvelle rotation
}
}