meilleure génération des tuiles

src/main/java/model/Tile.java

@@ -3,47 +3,62 @@ package model;
 import java.util.Random;
 
 public class Tile {
-    private TerrainType[] terrains;  // 4 terrains pour chaque quart de la tuile
+    private TerrainType[] terrains;  // 2 terrains maximum par tuile
+    private int segmentsForTerrain1;  // Nombre de segments pour le premier terrain
     private static final Random random = new Random();
 
     public Tile() {
-        this.terrains = new TerrainType[4];
+        this.terrains = new TerrainType[2];  // Seulement deux terrains
         generateTerrains();
+        assignSegments();
     }
 
-    // Génère des terrains aléatoires pour les 4 parties
+    // Génère deux terrains aléatoires pour la tuile
     private void generateTerrains() {
-        for (int i = 0; i < 4; i++) {
+        terrains[0] = generateRandomTerrain();
-            terrains[i] = generateRandomTerrain();
+        terrains[1] = generateRandomTerrain();
+
+        // Assure que les deux terrains sont différents
+        while (terrains[0] == terrains[1]) {
+            terrains[1] = generateRandomTerrain();
         }
     }
 
-    // Génère un terrain aléatoire selon certaines probabilités
+    // Assigner le nombre de segments pour chaque terrain avec plus de diversité
-    private TerrainType generateRandomTerrain() {
+    private void assignSegments() {
-        int rand = random.nextInt(100);  // Pourcentage pour chaque terrain
+        // Terrain 1 occupe entre 1 et 5 segments, le reste pour le terrain 2
+        this.segmentsForTerrain1 = random.nextInt(5) + 1;
+    }
 
-        if (rand < 20) {
+    // Génère un terrain aléatoire avec plus de variété dans les probabilités
-            return TerrainType.MER;       // 20% MER
+    private TerrainType generateRandomTerrain() {
-        } else if (rand < 40) {
+        int rand = random.nextInt(100);
-            return TerrainType.CHAMP;     // 20% CHAMP
+
-        } else if (rand < 60) {
+        if (rand < 15) {
+            return TerrainType.MER;       // 15% MER
+        } else if (rand < 30) {
+            return TerrainType.CHAMP;     // 15% CHAMP
+        } else if (rand < 50) {
             return TerrainType.PRE;       // 20% PRE
-        } else if (rand < 80) {
+        } else if (rand < 75) {
-            return TerrainType.FORET;     // 20% FORET
+            return TerrainType.FORET;     // 25% FORET
         } else {
-            return TerrainType.MONTAGNE;  // 20% MONTAGNE
+            return TerrainType.MONTAGNE;  // 25% MONTAGNE
         }
     }
 
     public TerrainType getTerrain(int index) {
-        if (index >= 0 && index < 4) {
+        if (index >= 0 && index < 2) {
             return terrains[index];
         }
         return null;
     }
 
-    @Override
+    public int getSegmentsForTerrain(int index) {
-    public String toString() {
+        if (index == 0) {
-        return "Terrains : " + terrains[0] + ", " + terrains[1] + ", " + terrains[2] + ", " + terrains[3];
+            return segmentsForTerrain1;  // Nombre de segments pour le premier terrain
+        } else {
+            return 6 - segmentsForTerrain1;  // Le reste pour le second terrain
+        }
     }
 }

src/main/java/view/GameView.java

@@ -1,6 +1,8 @@
 package view;
 
 import controller.GameController;
+import controller.CameraController;
+import controller.GameContext;
 import model.Tile;
 
 import javax.swing.*;
@@ -16,14 +18,13 @@ public class GameView extends JFrame {
     private Map<Point, HexagonTile> hexagonMap;
     private Set<Point> availablePositions;
     private Tile nextTile;
-    private HexagonTile nextTilePreview; // Tuile de prévisualisation à droite
+    private HexagonTile nextTilePreview;
-    private int tileCount;
     private GameController gameController;
+    private CameraController cameraController;
 
     public GameView() {
         this.hexagonMap = new HashMap<>();
         this.availablePositions = new HashSet<>();
-        this.tileCount = 0;
 
         setTitle("Jeu de Tuiles");
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
@@ -34,21 +35,29 @@ public class GameView extends JFrame {
 
         // Créer la grille d'hexagones à gauche
         gridPanel = createHexagonGrid();
-        JScrollPane scrollPane = new JScrollPane(gridPanel);
+        gridPanel.setLayout(null);  // Permet de placer les éléments sans layout manager
-        scrollPane.setPreferredSize(new Dimension(600, 600));
+        gridPanel.setPreferredSize(new Dimension(800, 800));  // Taille de la grille adaptée
-        add(scrollPane, BorderLayout.CENTER);
+
+        // 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
         add(controlPanel, BorderLayout.EAST);
 
-        // Initialiser le contrôleur
+        // Initialiser GameContext
+        GameContext context = new GameContext(hexagonMap, gameController, availablePositions, cameraController);
+
+        // Initialiser le contrôleur du jeu avec le contexte
         gameController = new GameController(hexagonMap, availablePositions, gridPanel, nextTile, nextTilePreview);
 
-        // Placer la première tuile au centre
+        // 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);
+        gameController.placeInitialTile(initialPosition, cameraController);
-        centerScrollOnPosition(initialPosition, scrollPane);
 
         pack();
         setLocationRelativeTo(null);
@@ -56,29 +65,31 @@ public class GameView extends JFrame {
     }
 
     private JPanel createHexagonGrid() {
-        return new HexagonGridPanel();
+        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
+        return panel;
     }
 
     private Tile generateRandomTile() {
         return new Tile();
     }
 
-    private void centerScrollOnPosition(Point position, JScrollPane scrollPane) {
-        int xCenter = position.x * 50 * 3 / 2;
-        int yCenter = position.y * (int) (Math.sqrt(3) * 50);
-        scrollPane.getViewport().setViewPosition(new Point(xCenter - scrollPane.getViewport().getWidth() / 2,
-                yCenter - scrollPane.getViewport().getHeight() / 2));
-    }
-
     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.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(100, 100));
+        nextTilePreview.setPreferredSize(new Dimension(150, 150));  // Augmenter la taille pour la prévisualisation
+        nextTilePreview.setBackground(Color.GRAY);
+        nextTilePreview.setOpaque(true);  // Rendre le fond opaque pour une meilleure visibilité
         nextTilePreview.setTile(nextTile);
         panel.add(nextTilePreview);
 

src/main/java/view/HexagonTile.java

@@ -45,8 +45,8 @@ public class HexagonTile extends JPanel {
         g2d.setClip(largeHexagon);
 
         if (tile != null) {
-            // Dessiner les 4 quadrants de terrain
+            // Dessiner les 6 segments de terrain en fonction des proportions
-            drawTerrainQuadrants(g2d, centerX, centerY, largeRadius);
+            drawTerrainSegments(g2d, centerX, centerY, largeRadius);
         } else {
             g2d.setColor(Color.LIGHT_GRAY);  // Couleur par défaut pour une case vide
             g2d.fill(largeHexagon);
@@ -59,11 +59,19 @@ public class HexagonTile extends JPanel {
         g2d.draw(largeHexagon);
     }
 
-    // Dessiner les 4 quadrants de terrain
+    // Dessiner les 6 segments de terrain avec une répartition variée
-    private void drawTerrainQuadrants(Graphics2D g2d, int centerX, int centerY, int radius) {
+    private void drawTerrainSegments(Graphics2D g2d, int centerX, int centerY, int radius) {
-        for (int i = 0; i < 4; i++) {
+        // Déterminer combien de segments sont attribués à chaque terrain
-            g2d.setColor(getTerrainColor(tile.getTerrain(i)));
+        int segmentsTerrain1 = tile.getSegmentsForTerrain(0);
-            g2d.fillArc(centerX - radius, centerY - radius, 2 * radius, 2 * radius, 90 * i, 90);
+
+        // Dessiner les segments adjacents pour chaque terrain
+        for (int i = 0; i < 6; i++) {
+            if (i < segmentsTerrain1) {
+                g2d.setColor(getTerrainColor(tile.getTerrain(0)));  // Premier terrain
+            } else {
+                g2d.setColor(getTerrainColor(tile.getTerrain(1)));  // Deuxième terrain
+            }
+            g2d.fillArc(centerX - radius, centerY - radius, 2 * radius, 2 * radius, 60 * i, 60);
         }
     }
 
@@ -86,6 +94,10 @@ public class HexagonTile extends JPanel {
 
     // Obtenir la couleur en fonction du type de terrain
     private Color getTerrainColor(TerrainType terrain) {
+        if (terrain == null) {
+            return Color.WHITE;  // Par défaut si le terrain est nul
+        }
+
         switch (terrain) {
             case MER:
                 return Color.BLUE;

src/main/java/view/MenuView.java

@@ -25,7 +25,7 @@ public class MenuView extends JComponent {
         panelCoté.setBackground(new Color(243,171,115,150));
         panelCoté.setPreferredSize(new Dimension(300,0));
 
-        backgroundImage = new ImageIcon("\\\\wsl.localhost\\Ubuntu-24.04\\home\\topb\\DEV\\SAE31_2024\\src\\main\\java\\view\\img\\bg.png").getImage();
+        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");
         Image quit1 = quit.getImage();