Séparation des classes BoardView et BackgroundLayer

Reviewed-on: #18

.gitignore

@@ -0,0 +1,2 @@
+# Ignorer le répertoire bin
+/bin

Diagrammes/Diagramme_Avalam.mmd

@@ -0,0 +1,218 @@
+---
+title: Avalam - Diagramme de classes (complet)
+---
+classDiagram
+
+    class AvalamBoard{
+        +SIZE: int
+        -MAX_HEIGHT: int
+        -grid: Tower[][]
+        -gameOver: boolean
+        -result: Result
+
+        +AvalamBoard(Tower[][] initialGrid, Player startingPlayer)
+        +AvalamBoard(Tower[][] initialGrid)
+        -AvalamBoard(Tower[][] grid, Player current, boolean gameOver, Result result)
+        +getTowerAt(int row, int col): Tower
+        -inBounds(int r, int c): boolean
+        -areAdjacent(int r1, int c1, int r2, int c2): boolean
+        -colorForPlayer(Player p): Color
+        +isGameOver(): boolean
+        +getResult(): Result
+        +isLegal(AbstractPly c): boolean
+        +doPly(AbstractPly c): void
+        +iterator(): Iterator<AbstractPly>
+        +safeCopy(): IBoard
+    }
+    
+    AvalamBoard "1" *-- "many" Tower
+    AvalamBoard ..> AvalamPly
+    
+    class AvalamPly{
+        -xFrom : int
+        -yFrom : int
+        -xTo : int
+        -yTo : int
+
+        +AvalamPly(Player player, int xFrom, int yFrom, int xTo, int yTo)
+        +getXFrom(): int
+        +getXFrom(): int
+        +getXFrom(): int
+        +getXFrom(): int
+
+        +toString(): String
+    }
+
+    
+    
+    class AvalamWindow{
+        -board : AvalamBoard
+        -scoreView : ScoreView
+        -turnView : TurnView
+        -boardView : BoardView
+        -mode: GameMode 
+        -botPlayer: Player
+        -idiotBot: IdiotBot
+        -alphaBot: AlphaBetaBot
+        -divineBot: Object
+        -botAnimating: boolean
+
+        +AvalamWindow()
+        +AvalamWindow(GameMode mode)
+        +AvalamWindow(GameMode mode, int alphaDepth)
+        +onBoardUpdated(): void
+        -maybePlayBotTurn(): void
+        -computeScore(Color c): int
+        -turnMessage(): String
+    }
+
+    AvalamWindow *-- AvalamBoard
+    AvalamWindow *-- BoardView
+    AvalamWindow *-- ScoreView
+    AvalamWindow *-- TurnView
+    AvalamWindow --> GameMode
+
+    class BoardLoader{
+        +loadFromFile(String resourcePath): Tower[][]
+    }
+    
+    
+
+    class BoardView{
+        -board: AvalamBoard
+        -backgroundLayer: BackgroundLayer
+        -highlightLayer: HighlightLayer
+        -pieceLayer: PieceLayer
+        -controller: InteractionController
+        -size: int
+        -spacing: int
+        -xBase: int
+        -yBase: int
+        -boardUpdateCallback: Runnable
+
+        +BoardView(AvalamBoard board, Runnable boardUpdateCallback)
+        +getController(): InteractionController
+        +setInteractionEnabled(boolean enabled): void
+        +onBoardUpdated(): void
+        +refresh(): void
+        -boardGrid(): Tower[][]
+        -boardGrid(): Tower[][]
+    }
+
+    BoardView *-- BackgroundLayer
+    BoardView *-- HighlightLayer
+    BoardView *-- PieceLayer
+    BoardView *-- InteractionController
+    BoardView --> AvalamBoard
+
+    class BackgroundLayer{
+        -img: Image
+        +BackgroundLayer(String resourcePath)
+        #paintComponent(Graphics g): void
+    }
+
+
+
+    class Color{
+        -YELLOW(int r, int g, int b)
+        -RED(int r, int g, int b)
+        -swingColor: java.awt.Color
+        +Color(int r, int g, int b)
+        +getSwingColor(): java.awt.Color
+        +toPlayer(): fr.iut_fbleau.GameAPI.Player
+    }
+
+    class GameMode{
+        PVP
+        PVBOT
+        PVALPHA
+        PVGOD 
+    }
+    
+    class HighlightLayer{
+        -xBase: int
+        -yBase: int
+        -spacing: int
+        -size: int
+        -legalMoves: List<Point>
+
+        +HighlightLayer(int xBase, int yBase, int spacing, int size)
+        +setLegalMoves(List<Point> moves): void
+        #paintComponent(Graphics g): void
+    }
+
+    class InteractionController{
+        -board: AvalamBoard
+        -selectedRow: int
+        -selectedCol: int
+        -legalMoves: List<Point>
+        -view: BoardView
+
+        +InteractionController(AvalamBoard board, BoardView view)
+        +onPieceClicked(int r, int c): void
+        +selectTower(int r, int c): void
+        -clearSelection(): void
+        -computeLegalMoves(): void
+        -tryMove(int r, int c): void
+    }
+
+    InteractionController --> AvalamBoard
+    InteractionController --> BoardView
+
+    class Main{
+        +main(String[] args): void
+    }
+
+    Main ..> AvalamWindow
+    Main ..> GameMode
+
+    class PieceButton{
+        -color: java.awt.Color
+        -height: int
+        -hover: boolean
+        +row: int
+        +col: int
+
+        +PieceButton(java.awt.Color c, int height, int row, int col)
+        #paintComponent(Graphics g): void
+        +contains(int x, int y): boolean
+
+    }
+    
+    class PieceLayer{
+        +PieceLayer()
+        +displayGrid(Tower[][] grid, int xBase, int yBase, int spacing, int size, java.util.function.BiConsumer<Integer, Integer> clickCallback): void
+    }
+
+    class ScoreView{
+        -scoreY: JLabel
+        -scoreR: JLabel
+
+        +ScoreView(int y, int r)
+        +updateScores(int y, int r): void
+    }
+
+    class Tower{
+        -height: byte
+        -color: Color
+
+        +Tower(int height, Color color)
+        +createTower(Color color): Tower
+        +getHeight(): int
+        +getColor(): Color
+        +mergeTower(Tower src): void
+        +toString(): String
+    }
+
+    Tower --> Color
+
+    class TurnView{
+        -text: JLabel
+
+        +TurnView(String initial)
+        +setTurn(String s): void
+    }
+
+    BoardLoader ..> Tower
+    PieceLayer ..> Tower
+    PieceButton ..> Tower

Diagrammes/Diagramme_Bot.mmd

@@ -0,0 +1,27 @@
+---
+title: Bot - Diagramme de classes (complet)
+---
+classDiagram
+
+    class AlphaBetaBot{
+        -me: Player
+        -maxDepth: int
+        -rng: Random
+
+        +AlphaBetaBot(Player p, int maxDepth)
+        +giveYourMove(IBoard board): AbstractPly
+        -alphaBeta(IBoard board, int depth, int alpha, int beta): int
+        -terminalValue(IBoard board): int
+        -evaluate(IBoard board): int
+        -listMoves(IBoard board): List<AbstractPly>
+    }
+
+    class DivineBot{
+
+    }
+
+    class IdiotBot{
+        -rng: Random
+        +IdiotBot(Player p)
+        +giveYourMove(IBoard board): AbstractPly
+    }

Diagrammes/Diagramme_GameAPI

@@ -0,0 +1,73 @@
+---
+title: GameAPI - Diagramme de classes (complet)
+---
+classDiagram
+
+    class AbstractBoard{
+        <<abstract>>
+        -currentPlayer: Player
+        -history: Deque<AbstractPly>
+
+        +AbstractBoard(Player p, Deque<AbstractPly> h)
+        #setNextPlayer(): void
+        #addPlyToHistory(AbstractPly c): void
+        #removePlyFromHistory(): AbstractPly
+        #getLastPlyFromHistory(): AbstractPly
+        +getCurrentPlayer()
+        +isGameOver(): boolean
+        +getResult(): Result
+        +isLegal(AbstractPly c): boolean
+        +iterator(): Iterator<AbstractPly>
+        +doPly(AbstractPly c): void
+        +undoPly(): void
+        +safeCopy(): IBoard
+    }
+
+    class AbstractGame{
+        <<abstract>>
+        -currentBoard: IBoard
+        -mapPlayers: EnumMap<Player, AbstractGamePlayer>
+
+        +AbstractGame(IBoard b, EnumMap<Player,AbstractGamePlayer> m)
+        +run(): Result
+    }
+
+    class AbstractGamePlayer{
+        <<abstract>>
+        -iAm: Player
+        
+        +AbstractGamePlayer(Player p)
+        +giveYourMove(IBoard p): AbstractPly
+    }
+
+    class AbstractPly{
+        <<abstract>>
+        -joueur: Player
+        
+        +AbstractPly(Player j)
+        +getPlayer(): Player
+    }
+
+    class IBoard{
+        +getCurrentPlayer(): Player
+        +isGameOver(): boolean
+        +getResult(): Result
+        +isLegal(AbstractPly c): boolean
+        +iterator(): Iterator<AbstractPly>
+        +doPly(AbstractPly c): void
+        +undoPly(): void
+        +safeCopy(): IBoard
+    }
+
+    class Player{
+        <<enumerate>>
+        PLAYER1
+        PLAYER2
+    }
+
+    class Result{
+        <<enumerate>>
+        WIN
+        DRAW
+        LOSS
+    }

fr/iut_fbleau/Avalam/BackgroundLayer.java

@@ -0,0 +1,37 @@
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+* La classe <code>BackgroundLayer</code>
+* 
+* Sous composant de BoardView affichant l’image de fond.
+*/
+public class BackgroundLayer extends JComponent {
+    private Image img;
+
+    /**
+    * Construit une couche de fond.
+    *
+    * @param resourcePath chemin de l'image de fond
+    */
+    public BackgroundLayer(String resourcePath) {
+        img = Toolkit.getDefaultToolkit().getImage(
+                getClass().getClassLoader().getResource(resourcePath)
+        );
+    }
+
+    /**
+    * Dessine l'image de fond.
+    *
+    * @param g contexte graphique
+    */
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (img != null) {
+            g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
+        }
+    }
+}

fr/iut_fbleau/Avalam/BoardLoader.java

@@ -61,10 +61,10 @@ public class BoardLoader {
 
                     switch (value) {
                         case 1:
-                            grid[row][col] = new Tower(Color.YELLOW);
+                            grid[row][col] = Tower.createTower(Color.YELLOW);
                             break;
                         case 2:
-                            grid[row][col] = new Tower(Color.RED);
+                            grid[row][col] = Tower.createTower(Color.RED);
                             break;
                         default:
                             grid[row][col] = null;

fr/iut_fbleau/Avalam/BoardView.java

@@ -1,192 +1,159 @@
-package fr.iut_fbleau.Avalam;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
-* La classe <code>BoardView</code>
-*
-* Représente la vue principale du plateau Avalam.
-* Elle gère :
-* - l’affichage des tours (PieceLayer)
-* - l’affichage des coups possibles (HighlightLayer)
-* - l’affichage du fond graphique
-* - les clics via InteractionController
-*
-* Cette classe ne contient aucune logique de règles du jeu.
-*
-* @version 1.0
-* Date :
-* Licence :
-*/
-public class BoardView extends JLayeredPane {
-
-    //Attributs
-
-    /** Référence au moteur Avalam. */
-    private AvalamBoard board;
-
-    /** Couche d’affichage du fond. */
-    private BackgroundLayer backgroundLayer;
-
-    /** Couche d’affichage des coups possibles. */
-    private HighlightLayer highlightLayer;
-
-    /** Couche d’affichage des pièces. */
-    private PieceLayer pieceLayer;
-
-    /** Contrôleur des interactions. */
-    private InteractionController controller;
-
-    /** Taille d’un pion en pixels. */
-    private final int size = 50;
-
-    /** Espacement entre les cases. */
-    private final int spacing = 70;
-
-    /** Décalage horizontal du plateau. */
-    private final int xBase = 60;
-
-    /** Décalage vertical du plateau. */
-    private final int yBase = 60;
-
-    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
-    private Runnable boardUpdateCallback;
-
-    //Constructeur
-
-    /**
-    * Construit la vue du plateau.
-    *
-    * @param board moteur du jeu
-    * @param boardUpdateCallback callback à appeler après un coup
-    */
-    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
-        this.board = board;
-        this.boardUpdateCallback = boardUpdateCallback;
-
-        setLayout(null);
-
-        // Contrôleur
-        this.controller = new InteractionController(board, this);
-
-        // Couche fond
-        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
-        backgroundLayer.setBounds(0, 0, 725, 725);
-        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
-
-        // Couche highlight
-        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
-        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
-
-        // Couche pièces
-        pieceLayer = new PieceLayer();
-        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
-
-        setPreferredSize(new Dimension(725, 725));
-
-        refresh();
-    }
-
-    //Méthodes
-
-    /**
-    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
-    *
-    * @return contrôleur
-    */
-    public InteractionController getController() {
-        return controller;
-    }
-
-    /**
-    * Active/désactive les interactions utilisateur sur le plateau.
-    * Utile pendant l'animation du bot pour éviter des clics concurrents.
-    *
-    * @param enabled true pour activer, false pour désactiver
-    */
-    public void setInteractionEnabled(boolean enabled) {
-        // Désactive la couche des pièces (boutons) principalement
-        pieceLayer.setEnabled(enabled);
-        for (Component c : pieceLayer.getComponents()) {
-            c.setEnabled(enabled);
-        }
-    }
-
-    /**
-    * Appelé par le contrôleur après un coup.
-    */
-    public void onBoardUpdated() {
-        if (boardUpdateCallback != null) {
-            boardUpdateCallback.run();
-        }
-    }
-
-    /**
-    * Rafraîchit les couches visuelles.
-    */
-    public void refresh() {
-
-        pieceLayer.displayGrid(
-                boardGrid(),
-                xBase, yBase, spacing, size,
-                (r, c) -> controller.onPieceClicked(r, c)
-        );
-
-        highlightLayer.setLegalMoves(controller.getLegalMoves());
-
-        backgroundLayer.repaint();
-        highlightLayer.repaint();
-        pieceLayer.repaint();
-        repaint();
-    }
-
-    /**
-    * Récupère la grille depuis le moteur.
-    *
-    * @return grille 9x9 de tours
-    */
-    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;
-    }
-
-    //Affichage
-
-    /**
-    * Composant affichant l’image de fond.
-    */
-    private static class BackgroundLayer extends JComponent {
-        private Image img;
-
-        /**
-        * Construit une couche de fond.
-        *
-        * @param resourcePath chemin de l'image de fond
-        */
-        public BackgroundLayer(String resourcePath) {
-            img = Toolkit.getDefaultToolkit().getImage(
-                    getClass().getClassLoader().getResource(resourcePath)
-            );
-        }
-
-        /**
-        * Dessine l'image de fond.
-        *
-        * @param g contexte graphique
-        */
-        @Override
-        protected void paintComponent(Graphics g) {
-            super.paintComponent(g);
-            if (img != null) {
-                g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
-            }
-        }
-    }
-}
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+* La classe <code>BoardView</code>
+*
+* Représente la vue principale du plateau Avalam.
+* Elle gère :
+* - l’affichage des tours (PieceLayer)
+* - l’affichage des coups possibles (HighlightLayer)
+* - l’affichage du fond graphique (BackgroundLayer)
+* - les clics via InteractionController
+*
+* Cette classe ne contient aucune logique de règles du jeu.
+*
+* @version 1.0
+* Date :
+* Licence :
+*/
+public class BoardView extends JLayeredPane {
+
+    //Attributs
+
+    /** Référence au moteur Avalam. */
+    private AvalamBoard board;
+
+    /** Couche d’affichage du fond. */
+    private BackgroundLayer backgroundLayer;
+
+    /** Couche d’affichage des coups possibles. */
+    private HighlightLayer highlightLayer;
+
+    /** Couche d’affichage des pièces. */
+    private PieceLayer pieceLayer;
+
+    /** Contrôleur des interactions. */
+    private InteractionController controller;
+
+    /** Taille d’un pion en pixels. */
+    private final int size = 50;
+
+    /** Espacement entre les cases. */
+    private final int spacing = 70;
+
+    /** Décalage horizontal du plateau. */
+    private final int xBase = 60;
+
+    /** Décalage vertical du plateau. */
+    private final int yBase = 60;
+
+    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
+    private Runnable boardUpdateCallback;
+
+    //Constructeur
+
+    /**
+    * Construit la vue du plateau.
+    *
+    * @param board moteur du jeu
+    * @param boardUpdateCallback callback à appeler après un coup
+    */
+    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
+        this.board = board;
+        this.boardUpdateCallback = boardUpdateCallback;
+
+        setLayout(null);
+
+        // Contrôleur
+        this.controller = new InteractionController(board, this);
+
+        // Couche fond
+        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
+        backgroundLayer.setBounds(0, 0, 725, 725);
+        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
+
+        // Couche highlight
+        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
+        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
+
+        // Couche pièces
+        pieceLayer = new PieceLayer();
+        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
+
+        setPreferredSize(new Dimension(725, 725));
+
+        refresh();
+    }
+
+    //Méthodes
+
+    /**
+    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
+    *
+    * @return contrôleur
+    */
+    public InteractionController getController() {
+        return controller;
+    }
+
+    /**
+    * Active/désactive les interactions utilisateur sur le plateau.
+    * Utile pendant l'animation du bot pour éviter des clics concurrents.
+    *
+    * @param enabled true pour activer, false pour désactiver
+    */
+    public void setInteractionEnabled(boolean enabled) {
+        // Désactive la couche des pièces (boutons) principalement
+        pieceLayer.setEnabled(enabled);
+        for (Component c : pieceLayer.getComponents()) {
+            c.setEnabled(enabled);
+        }
+    }
+
+    /**
+    * Appelé par le contrôleur après un coup.
+    */
+    public void onBoardUpdated() {
+        if (boardUpdateCallback != null) {
+            boardUpdateCallback.run();
+        }
+    }
+
+    /**
+    * Rafraîchit les couches visuelles.
+    */
+    public void refresh() {
+
+        pieceLayer.displayGrid(
+                boardGrid(),
+                xBase, yBase, spacing, size,
+                (r, c) -> controller.onPieceClicked(r, c)
+        );
+
+        highlightLayer.setLegalMoves(controller.getLegalMoves());
+
+        backgroundLayer.repaint();
+        highlightLayer.repaint();
+        pieceLayer.repaint();
+        repaint();
+    }
+
+    /**
+    * Récupère la grille depuis le moteur.
+    *
+    * @return grille 9x9 de tours
+    */
+    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;
+    }
+}

fr/iut_fbleau/Avalam/Tower.java

@@ -9,33 +9,21 @@ package fr.iut_fbleau.Avalam;
 * - une hauteur (nombre de pions empilés)
 *
 * Cette version est volontairement compatible avec le reste du projet :
-* - constructeur Tower(Color) utilisé par BoardLoader
 * - constructeur Tower(int, Color) utilisé dans d'autres parties possibles
+* - usine createTower(Color) utilisé par BoardLoader
 * - méthode mergeTower(Tower) utilisée par AvalamBoard
-* - méthode merge(Tower) conservée (si elle est utilisée ailleurs)
 */
 public class Tower {
-
     //Attributs
 
     /** Hauteur de la tour (nombre de pions empilés). */
-    private int height;
+    private byte height;
 
     /** Couleur du sommet de la tour (propriétaire actuel). */
     private Color color;
 
     //Constructeur
 
-    /**
-    * Construit une tour de hauteur 1 avec la couleur donnée.
-    * (Constructeur attendu par BoardLoader dans ton projet.)
-    *
-    * @param color couleur du sommet
-    */
-    public Tower(Color color) {
-        this(1, color);
-    }
-
     /**
     * Construit une tour avec une hauteur et une couleur données.
     *
@@ -43,10 +31,20 @@ public class Tower {
     * @param color couleur du sommet
     */
     public Tower(int height, Color color) {
-        this.height = height;
+        this.height = (byte) height;
         this.color = color;
     }
 
+    /**
+    * Construit une tour de hauteur 1 avec la couleur donnée.
+    * (Constructeur attendu par BoardLoader dans le projet.)
+    *
+    * @param color couleur du sommet
+    */
+    public static Tower createTower(Color color) {
+        return new Tower(1, color);
+    }
+
     //Méthodes
 
     /**
@@ -73,20 +71,11 @@ public class Tower {
     *
     * @param src tour source empilée sur la destination
     */
-    public void merge(Tower src) {
+    public void mergeTower(Tower src) {
         this.height += src.height;
         this.color = src.color;
     }
 
-    /**
-    * Alias de merge() pour compatibilité avec d'autres classes.
-    *
-    * @param src tour source empilée sur la destination
-    */
-    public void mergeTower(Tower src) {
-        merge(src);
-    }
-
     //Affichage
 
     /**