Placement de tuiles avec les cliques

TestV2/src/fr/monkhanny/dorfromantik/game/Board.java

@@ -7,14 +7,17 @@ import java.util.List;
 import java.util.Random;
 import java.awt.Graphics;
 import javax.swing.JPanel;
-import java.awt.Graphics;
 import javax.swing.JFrame;
+import java.awt.Point;
+import java.awt.Color;
+
 
 /**
  * Représente le plateau de jeu.
  */
 public class Board extends JPanel{
     private List<Tile> tiles;
+    private List<Point> availablePositions;
     private Random random;
     private Game game;
     private JFrame gameFrame;
@@ -24,6 +27,7 @@ public class Board extends JPanel{
     public Board(JFrame gameFrame, long seed) {
         this.gameFrame = gameFrame;
         this.tiles = new ArrayList<>();
+        this.availablePositions = new ArrayList<>();
         this.random = new Random(seed);
         this.game = new Game(seed);
 
@@ -32,8 +36,25 @@ public class Board extends JPanel{
 
         // Ajouter un écouteur de redimensionnement pour redessiner les tuiles
         gameFrame.addComponentListener(new GameResizeListener(this));
+
+        this.addMouseListener(new java.awt.event.MouseAdapter() {
+        public void mousePressed(java.awt.event.MouseEvent e) {
+            handleMouseClick(e);
+        }
+    });
     }
 
+    private void handleMouseClick(java.awt.event.MouseEvent e) {
+        Point clickedPoint = e.getPoint();
+
+        // Vérifiez si la position cliquée est dans la liste des positions disponibles et si la distance est suffisante
+        for (Point position : availablePositions) {
+            if (clickedPoint.distance(position) < 20) {  // Assurez-vous que le clic est plus éloigné du point
+                placeTileAtPosition(position);  // Place une tuile à cette position
+                break;  // Si une tuile est ajoutée, on peut sortir de la boucle
+            }
+        }
+    }
 
     private void initializeCentralTile() {
         int centerX = gameFrame.getWidth() / 2;
@@ -41,6 +62,9 @@ public class Board extends JPanel{
 
         this.centralTile = new Tile(this, centerX, centerY, 50);
         addTile(centralTile);
+
+        // Calculer les positions disponibles autour de la tuile centrale
+        calculateAvailablePositions(centralTile);
     }
 
     public void repositionCentralTile() {
@@ -63,12 +87,87 @@ public class Board extends JPanel{
         return game;
     }
 
+    /**
+     * Calcule les positions disponibles autour de la tuile donnée.
+     * Les points rouges seront générés autour de cette tuile.
+     *
+     * @param tile La tuile pour laquelle on calcule les positions disponibles
+     */
+    private void calculateAvailablePositions(Tile tile) {
+    int tileX = tile.getXCoord();
+    int tileY = tile.getYCoord();
+    int radius = (int) (tile.getRadius() * 1.72);  // Utiliser un rayon uniforme pour toutes les directions
 
+    // Définir les directions possibles autour de la tuile (6 directions pour une tuile hexagonale)
+    Point[] directions = {
+        new Point(0, -radius),  // Nord 
+        new Point((int)(radius * Math.sqrt(3) / 2), -radius / 2),  // Nord-Est (ajuster horizontalement)
+        new Point((int)(radius * Math.sqrt(3) / 2), radius / 2),  // Sud-Est (ajuster horizontalement)
+        new Point(0, radius),  // Sud
+        new Point(-(int)(radius * Math.sqrt(3) / 2), radius / 2),  // Sud-Ouest (ajuster horizontalement)
+        new Point(-(int)(radius * Math.sqrt(3) / 2), -radius / 2)  // Nord-Ouest (ajuster horizontalement)
+    };
+
+    // Calculer les positions disponibles autour de la tuile
+    for (Point direction : directions) {
+        Point newPoint = new Point(tileX + direction.x, tileY + direction.y);
+        if (!isTileAtPosition(newPoint)) {
+            availablePositions.add(newPoint);  // Ajouter la position si une tuile n'est pas déjà là
+        }
+    }
+}
+
+
+    /**
+     * Vérifie si une tuile existe déjà à la position donnée.
+     *
+     * @param position La position à vérifier
+     * @return true si une tuile est présente à cette position, false sinon
+     */
+    private boolean isTileAtPosition(Point position) {
+        for (Tile t : tiles) {
+            if (t.getXCoord() == position.x && t.getYCoord() == position.y) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Lorsqu'un utilisateur clique, ajoute une nouvelle tuile à la position sélectionnée.
+     *
+     * @param position La position où ajouter la tuile
+     */
+    public void placeTileAtPosition(Point position) {
+        // Vérifie si la position est disponible et que la tuile n'est pas déjà placée à cet endroit
+        if (availablePositions.contains(position) && !isTileAtPosition(position)) {
+            Tile newTile = new Tile(this, position.x, position.y, 50);
+
+            // Vérifier que la tuile ne se chevauche pas avec l'ancienne tuile
+            if (!isTileAtPosition(new Point(newTile.getXCoord(), newTile.getYCoord()))) {
+                addTile(newTile);
+                calculateAvailablePositions(newTile);  // Calculer de nouvelles positions disponibles
+                repaint();  // Re-dessiner le plateau
+            }
+        }
+    }
+
+    /**
+     * Afficher les points rouges pour indiquer les positions disponibles.
+     *
+     * @param g Le contexte graphique
+     */
+    @Override
     public void paintComponent(Graphics g) {
         super.paintComponent(g);
+        for (Point position : availablePositions) {
+            g.setColor(Color.RED);
+            g.fillOval(position.x - 5, position.y - 5, 10, 10);  // Dessiner un point rouge
+        }
+        
+        // Dessiner les tuiles existantes
         for (Tile tile : tiles) {
             tile.paintTileWithPosition(g, 1f);
         }
     }
 }
-