Jeu jouable avec fin de parti

fr/iut_fbleau/Avalam/ui/BoardView.java

@@ -1,84 +1,118 @@
 package fr.iut_fbleau.Avalam.ui;
 
-import fr.iut_fbleau.Avalam.logic.GameState;
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.Tower;
 
 import javax.swing.*;
+import java.awt.*;
 
 /**
- * La classe <code>BoardView</code> représente l'affichage complet du plateau Avalam.
- * Elle s’appuie sur une architecture en couches (layered pane) pour séparer proprement :
+ * BoardView est la vue principale du plateau Avalam.
  *
- * <ul>
- *     <li><b>HighlightLayer</b> : les cases jouables mises en surbrillance</li>
- *     <li><b>PieceLayer</b> : les pions affichés sous forme de boutons ronds</li>
- * </ul>
+ * Elle gère :
+ *  - l’affichage des tours (PieceLayer)
+ *  - l’affichage des coups possibles (HighlightLayer)
+ *  - les clics via InteractionController
  *
- * La vue ne contient pas la logique de jeu : elle la délègue entièrement
- * à un <code>InteractionController</code>.
- *
- * @author
- * @version 1.0
+ * Toute la logique de jeu est déléguée au moteur AvalamBoard
+ * et au contrôleur InteractionController.
  */
 public class BoardView extends JLayeredPane {
 
-    /** Taille des pions affichés. */
-    private final int size = 50;
+    /** Référence au moteur Avalam */
+    private AvalamBoard board;
 
-    /** Distance entre deux cases de la grille. */
-    private final int spacing = 70;
-
-    /** Décalages pour centrer l'affichage. */
-    private final int xBase = 60, yBase = 60;
-
-    /** Accès à l'état du jeu. */
-    private GameState state;
-
-    /** Couche d'affichage des ronds verts. */
+    /** Couche d’affichage des rond verts */
     private HighlightLayer highlightLayer;
 
-    /** Couche d'affichage des pions. */
+    /** Couche d’affichage des tours */
     private PieceLayer pieceLayer;
 
-    /** Gestionnaire d'interactions utilisateur. */
+    /** Contrôleur des interactions */
     private InteractionController controller;
 
+    /** Décalages et dimensions pour l'affichage */
+    private final int size = 50;
+    private final int spacing = 70;
+    private final int xBase = 60;
+    private final int yBase = 60;
+
+    /** Callback vers AvalamWindow pour mises à jour (score, tour, fin de partie) */
+    private Runnable boardUpdateCallback;
+
     /**
      * Constructeur de la vue du plateau.
      *
-     * @param state l'état du jeu Avalam
+     * @param board moteur Avalam utilisé pour afficher la grille
+     * @param boardUpdateCallback callback appelé après chaque coup
      */
-    public BoardView(GameState state) {
-        this.state = state;
+    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
+        this.board = board;
+        this.boardUpdateCallback = boardUpdateCallback;
+
         setLayout(null);
 
-        controller = new InteractionController(state);
+        // Contrôleur
+        this.controller = new InteractionController(board, this);
 
+        // Couche Highlight
         highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
-        pieceLayer = new PieceLayer();
-
         add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
+
+        // Couche des pièces
+        pieceLayer = new PieceLayer();
         add(pieceLayer, JLayeredPane.PALETTE_LAYER);
 
+        setPreferredSize(new Dimension(800, 800));
+
         refresh();
     }
 
     /**
-     * Met à jour l'affichage des couches en fonction de l'état actuel du jeu.
+     * Appelée par InteractionController quand un coup est joué.
+     * Permet à AvalamWindow de rafraîchir :
+     *  - scores
+     *  - affichage du joueur courant
+     *  - détection fin de partie
+     */
+    public void onBoardUpdated() {
+        if (boardUpdateCallback != null) {
+            boardUpdateCallback.run();
+        }
+    }
+
+    /**
+     * Met à jour toutes les couches visuelles.
      */
     public void refresh() {
 
+        // Mise à jour des pièces
         pieceLayer.displayGrid(
-            state.getGrid(),
-            xBase, yBase, spacing, size,
-
-            // Callback appelé lorsqu’un pion est cliqué
-            (r, c) -> {
-                controller.onPieceClicked(r, c);
-                highlightLayer.setLegalMoves(controller.getLegalMoves());
-                highlightLayer.repaint();
-            }
+                boardGrid(),
+                xBase, yBase, spacing, size,
+                (r, c) -> controller.onPieceClicked(r, c)
         );
 
+        // Mise à jour des highlights
+        highlightLayer.setLegalMoves(controller.getLegalMoves());
+
         highlightLayer.repaint();
+        pieceLayer.repaint();
+        repaint();
+    }
+
+    /**
+     * Renvoie la grille de tours depuis AvalamBoard.
+     */
+    private Tower[][] boardGrid() {
+        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+
+        for (int r = 0; r < AvalamBoard.SIZE; r++) {
+            for (int c = 0; c < AvalamBoard.SIZE; c++) {
+                grid[r][c] = board.getTowerAt(r, c);
+            }
+        }
+
+        return grid;
     }
 }