Merge pull request 'Menu game mode + bot idiot' (#17) from bot into master

Reviewed-on: #17

fr/iut_fbleau/Avalam/AvalamBoard.java

@@ -9,15 +9,44 @@ import fr.iut_fbleau.GameAPI.Result;
 import java.util.ArrayDeque;
 import java.util.Iterator;
 
+/**
+* La classe <code>AvalamBoard</code>
+*
+* Représente le plateau et les règles du jeu Avalam.
+* Cette classe étend <code>AbstractBoard</code> (GameAPI) et fournit :
+* - la génération des coups (iterator)
+* - le test de légalité (isLegal)
+* - l’application d’un coup (doPly)
+* - la détection de fin de partie (isGameOver)
+* - le calcul du résultat (getResult)
+*/
 public class AvalamBoard extends AbstractBoard {
 
+    //Attributs
+
+    /** Taille du plateau Avalam (9x9). */
     public static final int SIZE = 9;
+
+    /** Hauteur maximale autorisée pour une tour après fusion. */
     private static final int MAX_HEIGHT = 5;
 
+    /** Grille du plateau : chaque case contient une tour (Tower) ou null si vide. */
     private final Tower[][] grid;
+
+    /** Indique si la partie est terminée (mémoïsation). */
     private boolean gameOver = false;
+
+    /** Résultat de la partie si elle est terminée (mémoïsation). */
     private Result result = null;
 
+    //Constructeur
+
+    /**
+    * Construit un plateau Avalam à partir d’une grille initiale et d’un joueur qui commence.
+    *
+    * @param initialGrid grille initiale (Tower ou null)
+    * @param startingPlayer joueur qui commence (PLAYER1 ou PLAYER2)
+    */
     public AvalamBoard(Tower[][] initialGrid, Player startingPlayer) {
         super(startingPlayer, new ArrayDeque<>());
         this.grid = new Tower[SIZE][SIZE];
@@ -27,10 +56,24 @@ public class AvalamBoard extends AbstractBoard {
                 this.grid[r][c] = initialGrid[r][c];
     }
 
+    /**
+    * Construit un plateau Avalam à partir d’une grille initiale.
+    * Par défaut, PLAYER1 commence.
+    *
+    * @param initialGrid grille initiale (Tower ou null)
+    */
     public AvalamBoard(Tower[][] initialGrid) {
         this(initialGrid, Player.PLAYER1);
     }
 
+    /**
+    * Constructeur interne utilisé par safeCopy().
+    *
+    * @param grid grille à réutiliser
+    * @param current joueur courant
+    * @param gameOver état “partie terminée”
+    * @param result résultat mémorisé
+    */
     private AvalamBoard(Tower[][] grid, Player current, boolean gameOver, Result result) {
         super(current, new ArrayDeque<>());
         this.grid = grid;
@@ -38,24 +81,61 @@ public class AvalamBoard extends AbstractBoard {
         this.result = result;
     }
 
+    //Méthodes
+
+    /**
+    * Retourne la tour située à la position (row, col), ou null si hors bornes ou vide.
+    *
+    * @param row ligne
+    * @param col colonne
+    * @return tour présente ou null
+    */
     public Tower getTowerAt(int row, int col) {
         return inBounds(row, col) ? grid[row][col] : null;
     }
 
+    /**
+    * Teste si une position est à l’intérieur du plateau.
+    *
+    * @param r ligne
+    * @param c colonne
+    * @return true si (r,c) est dans [0..SIZE-1]
+    */
     private boolean inBounds(int r, int c) {
         return r >= 0 && r < SIZE && c >= 0 && c < SIZE;
     }
 
+    /**
+    * Teste si deux cases sont adjacentes (8-voisinage).
+    *
+    * @param r1 ligne source
+    * @param c1 colonne source
+    * @param r2 ligne destination
+    * @param c2 colonne destination
+    * @return true si les cases sont voisines et différentes
+    */
     private boolean areAdjacent(int r1, int c1, int r2, int c2) {
         int dr = Math.abs(r1 - r2);
         int dc = Math.abs(c1 - c2);
         return (dr <= 1 && dc <= 1 && !(dr == 0 && dc == 0));
     }
 
+    /**
+    * Associe un joueur GameAPI à une couleur Avalam.
+    *
+    * @param p joueur (PLAYER1/PLAYER2)
+    * @return couleur correspondante (YELLOW/RED)
+    */
     private Color colorForPlayer(Player p) {
         return (p == Player.PLAYER1 ? Color.YELLOW : Color.RED);
     }
 
+    /**
+    * Indique si la partie est terminée.
+    * Ici : fin lorsque l’itérateur de coups légaux ne produit plus aucun coup.
+    *
+    * @return true si aucun coup n’est possible
+    */
     @Override
     public boolean isGameOver() {
         if (gameOver) return true;
@@ -67,6 +147,12 @@ public class AvalamBoard extends AbstractBoard {
         return true;
     }
 
+    /**
+    * Retourne le résultat si la partie est terminée.
+    * Règle utilisée ici : comparaison du nombre de tours contrôlées par chaque couleur.
+    *
+    * @return WIN / LOSS / DRAW ou null si partie non terminée
+    */
     @Override
     public Result getResult() {
         if (!isGameOver()) return null;
@@ -91,6 +177,19 @@ public class AvalamBoard extends AbstractBoard {
         return result;
     }
 
+    /**
+    * Teste si un coup est légal selon les règles implémentées :
+    * - coup de type AvalamPly
+    * - source/destination dans le plateau et différentes
+    * - source et destination non null
+    * - la tour source appartient au joueur courant (couleur du sommet)
+    * - cases adjacentes
+    * - couleurs différentes entre source et destination (règle de ce projet)
+    * - hauteur finale <= MAX_HEIGHT
+    *
+    * @param c coup à tester
+    * @return true si le coup est légal
+    */
     @Override
     public boolean isLegal(AbstractPly c) {
         if (!(c instanceof AvalamPly)) return false;
@@ -114,6 +213,14 @@ public class AvalamBoard extends AbstractBoard {
         return true;
     }
 
+    /**
+    * Applique un coup légal :
+    * - fusion de la tour source sur la destination
+    * - la case source devient vide
+    * - passage au joueur suivant via super.doPly
+    *
+    * @param c coup à jouer
+    */
     @Override
     public void doPly(AbstractPly c) {
         if (!isLegal(c)) throw new IllegalArgumentException("Coup illégal : " + c);
@@ -135,6 +242,12 @@ public class AvalamBoard extends AbstractBoard {
         result = null;
     }
 
+    /**
+    * Retourne un itérateur sur tous les coups légaux du joueur courant.
+    * Génération brute : pour chaque case et chaque voisin (8 directions), on teste isLegal().
+    *
+    * @return itérateur de coups possibles (AbstractPly)
+    */
     @Override
     public Iterator<AbstractPly> iterator() {
         java.util.List<AbstractPly> moves = new java.util.ArrayList<>();
@@ -159,6 +272,12 @@ public class AvalamBoard extends AbstractBoard {
         return moves.iterator();
     }
 
+    /**
+    * Retourne une copie “sûre” de l’état du plateau.
+    * Ici, la grille est recopiée case par case (copie des références Tower).
+    *
+    * @return copie du plateau (IBoard)
+    */
     @Override
     public IBoard safeCopy() {
         Tower[][] newGrid = new Tower[SIZE][SIZE];

fr/iut_fbleau/Avalam/AvalamPly.java

@@ -4,44 +4,43 @@ import fr.iut_fbleau.GameAPI.AbstractPly;
 import fr.iut_fbleau.GameAPI.Player;
 
 /**
- * Représente un coup (ply) dans le jeu Avalam.
+* La classe <code>AvalamPly</code>
- *
+*
- * Un coup est défini par :
+* Représente un coup (ply) dans le jeu Avalam.
- * <ul>
+* Un coup est défini par :
- *     <li>un joueur (PLAYER1 ou PLAYER2)</li>
+* - un joueur (PLAYER1 ou PLAYER2)
- *     <li>une position source (xFrom, yFrom)</li>
+* - une position source (xFrom, yFrom)
- *     <li>une position destination (xTo, yTo)</li>
+* - une position destination (xTo, yTo)
- * </ul>
+*
- *
+* Cette classe ne vérifie pas la légalité : tout est délégué à <code>AvalamBoard</code>.
- * Ces coordonnées seront utilisées par <code>AvalamBoard</code> pour :
+*/
- * <ul>
- *     <li>vérifier la légalité du coup</li>
- *     <li>fusionner les tours concernées</li>
- *     <li>mettre à jour la grille</li>
- * </ul>
- *
- * Cette classe ne contient aucune logique de vérification : tout est délégué
- * à <code>AvalamBoard.isLegal()</code> et <code>AvalamBoard.doPly()</code>.
- */
 public class AvalamPly extends AbstractPly {
 
-    /** Coordonnées source */
+    //Attributs
+
+    /** Coordonnée ligne de la case source. */
     private final int xFrom;
+
+    /** Coordonnée colonne de la case source. */
     private final int yFrom;
 
-    /** Coordonnées destination */
+    /** Coordonnée ligne de la case destination. */
     private final int xTo;
+
+    /** Coordonnée colonne de la case destination. */
     private final int yTo;
 
+    //Constructeur
+
     /**
-     * Constructeur principal.
+    * Construit un coup Avalam.
-     *
+    *
-     * @param player joueur qui joue le coup
+    * @param player joueur qui joue le coup
-     * @param xFrom ligne d'origine
+    * @param xFrom ligne d'origine
-     * @param yFrom colonne d'origine
+    * @param yFrom colonne d'origine
-     * @param xTo ligne de destination
+    * @param xTo ligne de destination
-     * @param yTo colonne de destination
+    * @param yTo colonne de destination
-     */
+    */
     public AvalamPly(Player player, int xFrom, int yFrom, int xTo, int yTo) {
         super(player);
         this.xFrom = xFrom;
@@ -50,26 +49,51 @@ public class AvalamPly extends AbstractPly {
         this.yTo = yTo;
     }
 
-    /** Ligne d'origine */
+    //Méthodes
+
+    /**
+    * Retourne la ligne d'origine.
+    *
+    * @return ligne source
+    */
     public int getXFrom() {
         return xFrom;
     }
 
-    /** Colonne d'origine */
+    /**
+    * Retourne la colonne d'origine.
+    *
+    * @return colonne source
+    */
     public int getYFrom() {
         return yFrom;
     }
 
-    /** Ligne de destination */
+    /**
+    * Retourne la ligne de destination.
+    *
+    * @return ligne destination
+    */
     public int getXTo() {
         return xTo;
     }
 
-    /** Colonne de destination */
+    /**
+    * Retourne la colonne de destination.
+    *
+    * @return colonne destination
+    */
     public int getYTo() {
         return yTo;
     }
 
+    //Affichage
+
+    /**
+    * Retourne une représentation textuelle du coup.
+    *
+    * @return chaîne décrivant le coup
+    */
     @Override
     public String toString() {
         return "AvalamPly{" +

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -1,9 +1,7 @@
 package fr.iut_fbleau.Avalam;
 
-import fr.iut_fbleau.Avalam.logic.BoardLoader;
+import fr.iut_fbleau.Bot.IdiotBot;
-import fr.iut_fbleau.Avalam.ui.BoardView;
+import fr.iut_fbleau.GameAPI.AbstractPly;
-import fr.iut_fbleau.Avalam.ui.ScoreView;
-import fr.iut_fbleau.Avalam.ui.TurnView;
 import fr.iut_fbleau.GameAPI.Player;
 import fr.iut_fbleau.GameAPI.Result;
 
@@ -11,42 +9,82 @@ import javax.swing.*;
 import java.awt.*;
 
 /**
- * Fenêtre principale du jeu Avalam.
+* La classe <code>AvalamWindow</code>
- *
+*
- * Elle contient :
+* Fenêtre principale (interface graphique) du jeu Avalam.
- *  - le plateau (BoardView)
+* Elle contient :
- *  - l'affichage du score
+* - le plateau (BoardView)
- *  - l'affichage du joueur courant
+* - l’affichage du score (ScoreView)
- *
+* - l’affichage du joueur courant (TurnView)
- * Elle interagit directement avec AvalamBoard (moteur du jeu).
+*
- */
+* Elle pilote un objet <code>AvalamBoard</code> (moteur du jeu).
+* Elle peut fonctionner en mode :
+* - joueur vs joueur
+* - joueur vs bot idiot (aléatoire)
+* - joueur vs bot alpha (préparé)
+*
+* @version 1.0
+* Date :
+* Licence :
+*/
 public class AvalamWindow extends JFrame {
 
-    /** Moteur du jeu (API GameAPI) */
+    //Attributs
+
+    /** Moteur du jeu (état + règles). */
     private AvalamBoard board;
 
-    /** Vues graphiques */
+    /** Vue affichant le score. */
     private ScoreView scoreView;
+
+    /** Vue affichant le joueur courant. */
     private TurnView turnView;
+
+    /** Vue affichant le plateau. */
     private BoardView boardView;
 
+    /** Mode de jeu sélectionné. */
+    private final GameMode mode;
+
+    /** Joueur contrôlé par le bot (si actif). */
+    private final Player botPlayer = Player.PLAYER2;
+
+    /** Bot idiot (utilisé si mode PVBOT). */
+    private final IdiotBot idiotBot;
+
+    /** Indique si une animation de tour de bot est en cours. */
+    private boolean botAnimating = false;
+
+    //Constructeur
+
+    /**
+    * Construit la fenêtre en mode joueur vs joueur.
+    */
     public AvalamWindow() {
+        this(GameMode.PVP);
+    }
+
+    /**
+    * Construit la fenêtre en fonction du mode choisi.
+    *
+    * @param mode mode de jeu
+    */
+    public AvalamWindow(GameMode mode) {
         super("Avalam");
 
+        this.mode = mode;
+        this.idiotBot = (mode == GameMode.PVBOT) ? new IdiotBot(botPlayer) : null;
+
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLayout(new BorderLayout());
 
-        // ----------------------------------------------------------
+        // Chargement du plateau initial
-        // Chargement du plateau initial depuis Plateau.txt
-        // ----------------------------------------------------------
         Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
-        // debug TEMP !!!!!!!!!
-        System.out.println("DEBUG Plateau: Grid[0][0] = " + initialGrid[0][0]);
-        board = new AvalamBoard(initialGrid); // PLAYER1 commence
 
-        // ----------------------------------------------------------
+        // Initialisation du moteur (PLAYER1 commence)
-        // PANNEAU SCORE + TOUR
+        board = new AvalamBoard(initialGrid);
-        // ----------------------------------------------------------
+
+        // Panneau supérieur (score + tour)
         JPanel topPanel = new JPanel(new GridLayout(2, 1));
         topPanel.setBackground(new java.awt.Color(200, 200, 200));
 
@@ -62,29 +100,27 @@ public class AvalamWindow extends JFrame {
 
         add(topPanel, BorderLayout.NORTH);
 
-        // ----------------------------------------------------------
+        // Plateau
-        // PLATEAU (BoardView)
-        // ----------------------------------------------------------
         boardView = new BoardView(board, this::onBoardUpdated);
-
         add(boardView, BorderLayout.CENTER);
 
         pack();
         setResizable(false);
         setLocationRelativeTo(null);
         setVisible(true);
+
+        // Si un jour le bot doit commencer, on peut déclencher ici.
+        maybePlayBotTurn();
     }
 
-    /* ================================================================
+    //Méthodes
-     *                     MISES À JOUR D’APRÈS LE MOTEUR
-     * ================================================================ */
 
     /**
-     * Appelé automatiquement après chaque coup via BoardView → controller → board.
+    * Appelée après chaque coup (humain ou bot).
-     */
+    * Met à jour score, tour, et affiche la fin de partie.
+    */
     public void onBoardUpdated() {
 
-        // Mise à jour du score et du joueur courant
         scoreView.updateScores(
                 computeScore(Color.YELLOW),
                 computeScore(Color.RED)
@@ -92,32 +128,109 @@ public class AvalamWindow extends JFrame {
 
         turnView.setTurn(turnMessage());
 
-        //  Détection de fin de partie
         if (board.isGameOver()) {
             Result res = board.getResult();
 
             String msg;
-
             switch (res) {
-                case WIN : msg = "Le joueur jaune a gagné !";
+                case WIN:
-                case LOSS : msg = "Le joueur rouge a gagné !";
+                    msg = "Le joueur jaune a gagné !";
-                case DRAW : msg = "Égalité !";
+                    break;
-                default : msg = "Fin de partie.";
+                case LOSS:
+                    msg = "Le joueur rouge a gagné !";
+                    break;
+                case DRAW:
+                    msg = "Égalité !";
+                    break;
+                default:
+                    msg = "Fin de partie.";
+                    break;
             }
 
-            JOptionPane.showMessageDialog(this, msg, "Partie terminée",
+            JOptionPane.showMessageDialog(
-                    JOptionPane.INFORMATION_MESSAGE);
+                    this,
+                    msg,
+                    "Partie terminée",
+                    JOptionPane.INFORMATION_MESSAGE
+            );
+            return;
         }
+
+        // Si on est contre un bot et que c’est son tour, on déclenche son animation.
+        maybePlayBotTurn();
     }
 
+    /**
+    * Fait jouer le bot en deux étapes visibles :
+    * 1) sélection de la tour (affiche les coups légaux)
+    * 2) attente 1 seconde
+    * 3) déplacement vers la destination
+    *
+    * Le tout sans bloquer l'interface (Timer Swing).
+    */
+    private void maybePlayBotTurn() {
 
-    /* ================================================================
+        if (mode != GameMode.PVBOT) return;
-     *                             OUTILS
+        if (board.isGameOver()) return;
-     * ================================================================ */
+        if (board.getCurrentPlayer() != botPlayer) return;
+        if (botAnimating) return;
+
+        botAnimating = true;
+
+        // Désactiver les interactions du joueur pendant le tour du bot.
+        boardView.setInteractionEnabled(false);
+
+        // Choix d’un coup sur une copie sûre
+        AbstractPly botMove = idiotBot.giveYourMove(board.safeCopy());
+        if (botMove == null) {
+            botAnimating = false;
+            boardView.setInteractionEnabled(true);
+            return;
+        }
+
+        if (!(botMove instanceof AvalamPly)) {
+            botAnimating = false;
+            boardView.setInteractionEnabled(true);
+            return;
+        }
+
+        AvalamPly ap = (AvalamPly) botMove;
+
+        // Étape 1 : sélection (comme un clic humain)
+        InteractionController ctrl = boardView.getController();
+        ctrl.onPieceClicked(ap.getXFrom(), ap.getYFrom());
+        boardView.refresh();
+
+        // Étape 2 : attendre puis cliquer la destination
+        javax.swing.Timer t = new javax.swing.Timer(1000, e -> {
+
+            // Sécurité : si la partie a changé entre temps
+            if (board.isGameOver() || board.getCurrentPlayer() != botPlayer) {
+                botAnimating = false;
+                boardView.setInteractionEnabled(true);
+                ((javax.swing.Timer) e.getSource()).stop();
+                return;
+            }
+
+            ctrl.onPieceClicked(ap.getXTo(), ap.getYTo());
+            boardView.refresh();
+
+            botAnimating = false;
+            boardView.setInteractionEnabled(true);
+
+            ((javax.swing.Timer) e.getSource()).stop();
+        });
+
+        t.setRepeats(false);
+        t.start();
+    }
 
     /**
-     * Calcule le score d'une couleur : nombre de tours contrôlées.
+    * Calcule le score d'une couleur : nombre de tours contrôlées.
-     */
+    *
+    * @param c couleur à compter
+    * @return nombre de tours appartenant à la couleur c
+    */
     private int computeScore(Color c) {
         int score = 0;
         for (int r = 0; r < AvalamBoard.SIZE; r++) {
@@ -132,10 +245,14 @@ public class AvalamWindow extends JFrame {
     }
 
     /**
-     * Message du joueur dont c'est le tour.
+    * Retourne le message affiché pour le joueur courant.
-     */
+    *
+    * @return message du tour
+    */
     private String turnMessage() {
-        return "Tour du joueur : " + 
+        return "Tour du joueur : " +
                 (board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge");
     }
+
+    //Affichage
 }

fr/iut_fbleau/Avalam/BoardLoader.java

@@ -1,4 +1,4 @@
-package fr.iut_fbleau.Avalam.logic;
+package fr.iut_fbleau.Avalam;
 
 import fr.iut_fbleau.Avalam.Color;
 import fr.iut_fbleau.Avalam.Tower;
@@ -8,8 +8,32 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 
+/**
+* La classe <code>BoardLoader</code>
+*
+* Permet de charger un plateau Avalam à partir d’un fichier texte.
+* Le fichier contient une grille 9x9 de valeurs numériques :
+* - 0 : case vide
+* - 1 : tour jaune
+* - 2 : tour rouge
+*
+* Cette classe fournit une méthode statique pour construire
+* une grille de tours (<code>Tower[][]</code>) à partir d’une ressource.
+*/
 public class BoardLoader {
 
+    //Attributs
+
+    //Constructeur
+
+    //Méthodes
+
+    /**
+    * Charge un plateau Avalam depuis un fichier de ressources.
+    *
+    * @param resourcePath chemin du fichier de plateau (dans les ressources)
+    * @return une grille 9x9 de tours (Tower) ou null pour les cases vides
+    */
     public static Tower[][] loadFromFile(String resourcePath) {
 
         Tower[][] grid = new Tower[9][9];
@@ -17,7 +41,7 @@ public class BoardLoader {
         InputStream in = BoardLoader.class.getResourceAsStream("/" + resourcePath);
 
         if (in == null) {
-            System.err.println("❌ Ressource introuvable : /" + resourcePath);
+            System.err.println("Ressource introuvable : /" + resourcePath);
             return grid;
         }
 
@@ -28,7 +52,7 @@ public class BoardLoader {
 
             while ((line = reader.readLine()) != null && row < 9) {
 
-                // 🔥 Accepte SOIT les espaces, SOIT les virgules
+                // Accepte SOIT les espaces, SOIT les virgules
                 line = line.replace(",", " ");
                 String[] parts = line.trim().split("\\s+");
 

fr/iut_fbleau/Avalam/BoardView.java

@@ -0,0 +1,192 @@
+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);
+            }
+        }
+    }
+}

fr/iut_fbleau/Avalam/Color.java

@@ -1,20 +1,57 @@
 package fr.iut_fbleau.Avalam;
 
+/**
+* L'énumération <code>Color</code>
+*
+* Représente les deux couleurs utilisées dans Avalam :
+* - YELLOW (jaune)
+* - RED (rouge)
+*
+* Chaque valeur est associée à une couleur Swing (<code>java.awt.Color</code>)
+* pour l’affichage graphique et peut être convertie en <code>Player</code> (GameAPI).
+*/
 public enum Color {
 
+    //Attributs
+
+    /** Couleur jaune (associée à PLAYER1). */
     YELLOW(255, 220, 0),
+
+    /** Couleur rouge (associée à PLAYER2). */
     RED(200, 40, 40);
 
+    /** Couleur Swing utilisée pour l'affichage dans l'interface graphique. */
     private final java.awt.Color swingColor;
 
+    //Constructeur
+
+    /**
+    * Construit une couleur Avalam en initialisant sa couleur Swing associée.
+    *
+    * @param r composante rouge [0..255]
+    * @param g composante verte [0..255]
+    * @param b composante bleue [0..255]
+    */
     Color(int r, int g, int b) {
         this.swingColor = new java.awt.Color(r, g, b);
     }
 
+    //Méthodes
+
+    /**
+    * Retourne la couleur Swing associée (pour l'affichage).
+    *
+    * @return java.awt.Color
+    */
     public java.awt.Color getSwingColor() {
         return swingColor;
     }
 
+    /**
+    * Convertit la couleur Avalam en joueur GameAPI.
+    *
+    * @return PLAYER1 si YELLOW, sinon PLAYER2
+    */
     public fr.iut_fbleau.GameAPI.Player toPlayer() {
         return (this == YELLOW ?
                 fr.iut_fbleau.GameAPI.Player.PLAYER1 :

fr/iut_fbleau/Avalam/GameMode.java

@@ -0,0 +1,10 @@
+package fr.iut_fbleau.Avalam;
+
+/**
+ * Mode de jeu au lancement.
+ */
+public enum GameMode {
+    PVP,        // joueur vs joueur
+    PVBOT,      // joueur vs bot idiot
+    PVALPHA     // joueur vs bot alpha (préparé)
+}

fr/iut_fbleau/Avalam/HighlightLayer.java

@@ -0,0 +1,94 @@
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.List;
+
+/**
+* La classe <code>HighlightLayer</code>
+*
+* Gère l'affichage graphique des cases jouables sur le plateau Avalam.
+* Les cases autorisées sont représentées par des cercles verts semi-transparents.
+*
+* Cette classe ne contient aucune logique de jeu.
+*/
+public class HighlightLayer extends JPanel {
+
+    //Attributs
+
+    /** Position X de base du plateau. */
+    private int xBase;
+
+    /** Position Y de base du plateau. */
+    private int yBase;
+
+    /** Espacement entre les cases du plateau. */
+    private int spacing;
+
+    /** Taille d’un pion en pixels. */
+    private int size;
+
+    /** Liste des positions jouables (cases en vert). */
+    private List<Point> legalMoves;
+
+    //Constructeur
+
+    /**
+    * Construit la couche d'affichage des coups légaux.
+    *
+    * @param xBase position X de base du plateau
+    * @param yBase position Y de base du plateau
+    * @param spacing espacement entre cases
+    * @param size taille des pions
+    */
+    public HighlightLayer(int xBase, int yBase, int spacing, int size) {
+        this.xBase = xBase;
+        this.yBase = yBase;
+        this.spacing = spacing;
+        this.size = size;
+
+        setOpaque(false);
+        setBounds(0, 0, 800, 800);
+    }
+
+    //Méthodes
+
+    /**
+    * Définit la liste des cases légales à afficher.
+    *
+    * @param moves liste des positions jouables
+    */
+    public void setLegalMoves(List<Point> moves) {
+        this.legalMoves = moves;
+        repaint();
+    }
+
+    //Affichage
+
+    /**
+    * Dessine les cercles verts autour des cases autorisées.
+    *
+    * @param g contexte graphique
+    */
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+
+        if (legalMoves == null) return;
+
+        Graphics2D g2 = (Graphics2D) g;
+        g2.setColor(new java.awt.Color(0, 255, 0, 120));
+
+        for (Point p : legalMoves) {
+
+            int r = p.x;
+            int c = p.y;
+
+            int x = xBase + c * spacing;
+            int y = yBase + r * spacing;
+
+            int highlight = size + 20; // Cercle plus grand que le pion
+            g2.fillOval(x - 10, y - 10, highlight, highlight);
+        }
+    }
+}

fr/iut_fbleau/Avalam/InteractionController.java

@@ -1,8 +1,4 @@
-package fr.iut_fbleau.Avalam.ui;
+package fr.iut_fbleau.Avalam;
-
-import fr.iut_fbleau.Avalam.AvalamBoard;
-import fr.iut_fbleau.Avalam.AvalamPly;
-import fr.iut_fbleau.Avalam.Tower;
 
 import fr.iut_fbleau.GameAPI.AbstractPly;
 import fr.iut_fbleau.GameAPI.Player;
@@ -13,48 +9,71 @@ import java.util.Iterator;
 import java.util.List;
 
 /**
- * Le contrôleur gère toute l'interaction entre l'utilisateur et le moteur Avalam.
+* La classe <code>InteractionController</code>
- *
+*
- * Son rôle :
+* Gère l'interaction entre l'utilisateur et le moteur du jeu Avalam.
- *  - gérer la sélection d’une tour
+* Elle permet :
- *  - générer les coups légaux via l’API (iterator)
+* - la sélection d'une tour
- *  - valider un déplacement (isLegal)
+* - le calcul des coups légaux
- *  - appliquer un coup (doPly)
+* - la validation d'un déplacement
- *  - mettre à jour le plateau (via refresh demandé au BoardView)
+* - l'application d'un coup
- *
+* - la mise à jour de l'affichage via BoardView
- * IMPORTANT : ce contrôleur n’affiche rien. Il envoie les infos à BoardView.
+*
- */
+* Cette classe ne réalise aucun affichage direct.
+*/
 public class InteractionController {
 
+    //Attributs
+
+    /** Référence au moteur du jeu Avalam. */
     private AvalamBoard board;
 
-    /** Position sélectionnée (-1 si aucune) */
+    /** Ligne de la tour sélectionnée (-1 si aucune). */
     private int selectedRow = -1;
+
+    /** Colonne de la tour sélectionnée (-1 si aucune). */
     private int selectedCol = -1;
 
-    /** Liste des coups légaux (en Point) autour de la sélection */
+    /** Liste des coups légaux (sous forme de points). */
     private List<Point> legalMoves = new ArrayList<>();
 
-    /** Référence à la vue pour la rafraîchir après déplacements */
+    /** Référence à la vue du plateau pour rafraîchir l'affichage. */
     private BoardView view;
 
+    //Constructeur
+
+    /**
+    * Construit le contrôleur d'interactions.
+    *
+    * @param board moteur du jeu Avalam
+    * @param view vue du plateau
+    */
     public InteractionController(AvalamBoard board, BoardView view) {
         this.board = board;
         this.view = view;
     }
 
-    /** Retourne les cases jouables (pour HighlightLayer). */
+    //Méthodes
+
+    /**
+    * Retourne la liste des cases jouables.
+    *
+    * @return liste des coups légaux
+    */
     public List<Point> getLegalMoves() {
         return legalMoves;
     }
 
     /**
-     * Appelé lorsqu’un pion est cliqué dans BoardView.
+    * Appelé lorsqu’un pion est cliqué dans BoardView.
-     * Gère :
+    * Gère :
-     *  - sélection d’une tour
+    * - la sélection d’une tour
-     *  - désélection
+    * - la désélection
-     *  - tentative de déplacement (si clique sur un highlight)
+    * - la tentative de déplacement
-     */
+    *
+    * @param r ligne cliquée
+    * @param c colonne cliquée
+    */
     public void onPieceClicked(int r, int c) {
 
         // Si on clique la même case ⇒ désélection
@@ -79,16 +98,21 @@ public class InteractionController {
         }
     }
 
-    /* -------------------------------------------------------------------------
+    /**
-     *                        SÉLECTION D’UNE TOUR
+    * Sélectionne une tour à la position (r,c).
-     * ---------------------------------------------------------------------- */
+    *
-
+    * @param r ligne
+    * @param c colonne
+    */
     private void selectTower(int r, int c) {
         selectedRow = r;
         selectedCol = c;
         computeLegalMoves();
     }
 
+    /**
+    * Annule la sélection actuelle.
+    */
     private void clearSelection() {
         selectedRow = -1;
         selectedCol = -1;
@@ -96,9 +120,9 @@ public class InteractionController {
     }
 
     /**
-     * Identifie les destinations possibles depuis la tour sélectionnée.
+    * Calcule les coups légaux à partir de la tour sélectionnée.
-     * Utilise l’API officielle : board.iterator()
+    * Utilise l'itérateur fourni par AvalamBoard.
-     */
+    */
     private void computeLegalMoves() {
         legalMoves.clear();
 
@@ -117,13 +141,12 @@ public class InteractionController {
         }
     }
 
-    /* -------------------------------------------------------------------------
-     *                        TENTATIVE DE DÉPLACEMENT
-     * ---------------------------------------------------------------------- */
-
     /**
-     * Tente d’exécuter un déplacement vers (r,c) si c’est un coup légal.
+    * Tente d’exécuter un déplacement vers la case (r,c).
-     */
+    *
+    * @param r ligne de destination
+    * @param c colonne de destination
+    */
     private void tryMove(int r, int c) {
         // Vérifier si (r,c) est une destination légale
         boolean isLegalDest = false;
@@ -152,11 +175,11 @@ public class InteractionController {
             // Réinitialiser la sélection
             clearSelection();
 
-            // Recalcul du score + joueur courant + fin de partie (handled in window)
+            // Mise à jour de l'interface
             view.onBoardUpdated();
 
         } else {
-            // Coup impossible (rare, mais pour sécurité)
+            // Coup impossible
             clearSelection();
         }
 

fr/iut_fbleau/Avalam/Main.java

@@ -1,7 +1,50 @@
 package fr.iut_fbleau.Avalam;
 
+import javax.swing.*;
+
+/**
+ * Point d’entrée : propose un menu de sélection de mode, puis lance la fenêtre Avalam.
+ */
 public class Main {
+
     public static void main(String[] args) {
-        new AvalamWindow();
+
+        SwingUtilities.invokeLater(() -> {
+
+            String[] options = {
+                    "joueur vs joueur",
+                    "joueur vs botidiot",
+                    "joueur vs bot alpha"
+            };
+
+            int choice = JOptionPane.showOptionDialog(
+                    null,
+                    "Choisissez un mode de jeu :",
+                    "Avalam - Mode de jeu",
+                    JOptionPane.DEFAULT_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    null,
+                    options,
+                    options[0]
+            );
+
+            GameMode mode;
+            if (choice == 1) mode = GameMode.PVBOT;
+            else if (choice == 2) mode = GameMode.PVALPHA;
+            else mode = GameMode.PVP;
+
+            // Si alpha choisi : non implémenté, on prévient et on lance en PVP (préparation).
+            if (mode == GameMode.PVALPHA) {
+                JOptionPane.showMessageDialog(
+                        null,
+                        "Bot Alpha-Beta non implémenté pour l'instant.\nLancement en joueur vs joueur.",
+                        "Information",
+                        JOptionPane.INFORMATION_MESSAGE
+                );
+                mode = GameMode.PVP;
+            }
+
+            new AvalamWindow(mode);
+        });
     }
 }

fr/iut_fbleau/Avalam/PieceButton.java

@@ -1,40 +1,47 @@
-package fr.iut_fbleau.Avalam.ui;
+package fr.iut_fbleau.Avalam;
-
 import javax.swing.*;
 import java.awt.*;
 
 /**
- * La classe <code>PieceButton</code> représente graphiquement une tour Avalam.
+* La classe <code>PieceButton</code>
- * Il s'agit d'un bouton rond :
+*
- *
+* Représente graphiquement une tour Avalam sous forme d’un bouton rond.
- * <ul>
+* Chaque bouton :
- *     <li>coloré selon le joueur</li>
+* - possède une couleur correspondant au joueur,
- *     <li>affichant sa hauteur</li>
+* - affiche la hauteur de la tour,
- *     <li>avec un effet de survol visuel</li>
+* - réagit au survol de la souris.
- * </ul>
+*
- *
+* Ce composant permet l’interaction avec les pièces du plateau.
- * Ce composant sert d'interaction principale pour cliquer les pions.
+*/
- *
- * @author
- * @version 1.0
- */
 public class PieceButton extends JButton {
 
-    private Color color;
+    //Attributs
+
+    /** Couleur graphique du pion. */
+    private java.awt.Color color;
+
+    /** Hauteur de la tour affichée. */
     private int height;
+
+    /** Indique si la souris survole le bouton. */
     private boolean hover = false;
 
-    /** Position de la tour sur la grille. */
+    /** Position de la tour sur la grille (ligne). */
-    public final int row, col;
+    public final int row;
+
+    /** Position de la tour sur la grille (colonne). */
+    public final int col;
+
+    //Constructeur
 
     /**
-     * Constructeur.
+    * Construit un bouton représentant une tour Avalam.
-     *
+    *
-     * @param c couleur graphique du pion
+    * @param c couleur graphique du pion
-     * @param height hauteur de la tour
+    * @param height hauteur de la tour
-     * @param row ligne du pion
+    * @param row ligne du pion
-     * @param col colonne du pion
+    * @param col colonne du pion
-     */
+    */
     public PieceButton(java.awt.Color c, int height, int row, int col) {
         this.color = c;
         this.height = height;
@@ -52,9 +59,13 @@ public class PieceButton extends JButton {
         });
     }
 
+    //Méthodes
+
     /**
-     * Dessine le pion rond ainsi que son chiffre au centre.
+    * Dessine le pion rond ainsi que sa hauteur au centre.
-     */
+    *
+    * @param g contexte graphique
+    */
     @Override
     protected void paintComponent(Graphics g) {
         Graphics2D g2 = (Graphics2D) g.create();
@@ -78,9 +89,15 @@ public class PieceButton extends JButton {
         g2.dispose();
     }
 
+    //Affichage
+
     /**
-     * Rend le bouton réellement rond (zone cliquable circulaire).
+    * Rend le bouton réellement rond (zone cliquable circulaire).
-     */
+    *
+    * @param x coordonnée X
+    * @param y coordonnée Y
+    * @return true si le point est dans le cercle
+    */
     @Override
     public boolean contains(int x, int y) {
         double dx = x - getWidth()/2.0;

fr/iut_fbleau/Avalam/PieceLayer.java

@@ -1,48 +1,44 @@
-package fr.iut_fbleau.Avalam.ui;
+package fr.iut_fbleau.Avalam;
-
-import fr.iut_fbleau.Avalam.Tower;
 
 import javax.swing.*;
 import java.awt.*;
 
 /**
- * La classe <code>PieceLayer</code> gère l'affichage des pions
+* La classe <code>PieceLayer</code>
- * (sous forme de <code>PieceButton</code>) sur la grille.
+*
- *
+* Gère l'affichage des tours du plateau Avalam sous forme de boutons.
- * Elle s'occupe uniquement :
+* Elle :
- * <ul>
+* - affiche les pièces,
- *     <li>d'afficher les pièces</li>
+* - positionne les boutons sur la grille,
- *     <li>de positionner correctement les boutons</li>
+* - associe une action de clic à chaque pièce.
- *     <li>d'attacher un callback à chaque clic</li>
+*
- * </ul>
+* Aucune logique de jeu n'est implémentée ici.
- *
+*/
- * Aucune logique de jeu n'est réalisée ici.
- *
- * @author
- * @version 1.0
- */
 public class PieceLayer extends JPanel {
 
+    //Constructeur
+
     /**
-     * Constructeur.
+    * Construit la couche graphique des pièces.
-     * Initialise un panneau transparent prêt à recevoir des pions.
+    */
-     */
     public PieceLayer() {
         setLayout(null);
         setOpaque(false);
         setBounds(0, 0, 800, 800);
     }
 
+    //Méthodes
+
     /**
-     * Affiche la grille de tours sous forme de boutons.
+    * Affiche la grille de tours sous forme de boutons interactifs.
-     *
+    *
-     * @param grid grille 9×9 des tours
+    * @param grid grille 9×9 des tours
-     * @param xBase offset X du plateau
+    * @param xBase décalage horizontal du plateau
-     * @param yBase offset Y du plateau
+    * @param yBase décalage vertical du plateau
-     * @param spacing espacement entre cases
+    * @param spacing espacement entre cases
-     * @param size taille d'un pion
+    * @param size taille d'un pion
-     * @param clickCallback fonction appelée lors d’un clic sur un pion
+    * @param clickCallback fonction appelée lors d’un clic sur un pion
-     */
+    */
     public void displayGrid(Tower[][] grid, int xBase, int yBase,
                             int spacing, int size,
                             java.util.function.BiConsumer<Integer, Integer> clickCallback) {

fr/iut_fbleau/Avalam/ScoreView.java

@@ -0,0 +1,57 @@
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+* La classe <code>ScoreView</code>
+*
+* Affiche les scores des deux joueurs du jeu Avalam.
+* Cette classe est purement graphique : elle ne calcule pas les scores.
+*/
+public class ScoreView extends JPanel {
+
+    //Attributs
+
+    /** Label affichant le score du joueur jaune. */
+    private JLabel scoreY;
+
+    /** Label affichant le score du joueur rouge. */
+    private JLabel scoreR;
+
+    //Constructeur
+
+    /**
+    * Construit la vue des scores.
+    *
+    * @param y score initial du joueur jaune
+    * @param r score initial du joueur rouge
+    */
+    public ScoreView(int y, int r) {
+        setBackground(new java.awt.Color(200,200,200));
+        setLayout(new FlowLayout());
+
+        scoreY = new JLabel("Score Jaune : " + y);
+        scoreR = new JLabel("Score Rouge : " + r);
+
+        scoreY.setFont(new Font("Arial", Font.BOLD, 18));
+        scoreR.setFont(new Font("Arial", Font.BOLD, 18));
+
+        add(scoreY);
+        add(new JLabel("   |   "));
+        add(scoreR);
+    }
+
+    //Méthodes
+
+    /**
+    * Met à jour l'affichage des scores.
+    *
+    * @param y nouveau score du joueur jaune
+    * @param r nouveau score du joueur rouge
+    */
+    public void updateScores(int y, int r) {
+        scoreY.setText("Score Jaune : " + y);
+        scoreR.setText("Score Rouge : " + r);
+    }
+}

fr/iut_fbleau/Avalam/Tower.java

@@ -1,48 +1,99 @@
 package fr.iut_fbleau.Avalam;
 
 /**
- * Représente une tour dans le jeu Avalam.
+* La classe <code>Tower</code>
- *
+*
- * Une tour possède :
+* Représente une tour dans le jeu Avalam.
- *  - la couleur de son sommet
+* Une tour est caractérisée par :
- *  - sa hauteur (nombre de pions)
+* - une couleur (couleur du sommet)
- */
+* - 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
+* - méthode mergeTower(Tower) utilisée par AvalamBoard
+* - méthode merge(Tower) conservée (si elle est utilisée ailleurs)
+*/
 public class Tower {
 
-    private Color color;
+    //Attributs
+
+    /** Hauteur de la tour (nombre de pions empilés). */
     private int height;
 
-    /** Nouvelle tour de hauteur 1 */
+    /** 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.color = color;
+        this(1, color);
-        this.height = 1;
     }
 
-    /** Tour avec couleur et hauteur existantes */
+    /**
-    public Tower(Color color, int height) {
+    * Construit une tour avec une hauteur et une couleur données.
-        this.color = color;
+    *
+    * @param height hauteur initiale
+    * @param color couleur du sommet
+    */
+    public Tower(int height, Color color) {
         this.height = height;
+        this.color = color;
     }
 
-    public Color getColor() {
+    //Méthodes
-        return color;
-    }
 
+    /**
+    * Retourne la hauteur de la tour.
+    *
+    * @return hauteur
+    */
     public int getHeight() {
         return height;
     }
 
     /**
-     * Fusionne this (destination) avec src (source).
+    * Retourne la couleur du sommet.
-     * La source monte sur la destination →
+    *
-     *  - la couleur du sommet devient celle de src
+    * @return couleur
-     *  - la hauteur s’additionne
+    */
-     */
+    public Color getColor() {
-    public void mergeTower(Tower src) {
+        return color;
-        this.color = src.color;
-        this.height = this.height + src.height;
     }
 
+    /**
+    * Fusionne la tour <code>src</code> sur la tour courante (destination).
+    * La couleur du sommet devient celle de <code>src</code>.
+    *
+    * @param src tour source empilée sur la destination
+    */
+    public void merge(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
+
+    /**
+    * Représentation textuelle de la tour.
+    *
+    * @return chaîne représentant la tour
+    */
     @Override
     public String toString() {
         return color + "(" + height + ")";

fr/iut_fbleau/Avalam/TurnView.java

@@ -0,0 +1,45 @@
+package fr.iut_fbleau.Avalam;
+
+import javax.swing.*;
+import java.awt.*;
+
+/**
+* La classe <code>TurnView</code>
+*
+* Affiche le joueur dont c'est le tour dans le jeu Avalam.
+* Cette classe est uniquement graphique.
+*/
+public class TurnView extends JPanel {
+
+    //Attributs
+
+    /** Label affichant le joueur courant. */
+    private JLabel text;
+
+    //Constructeur
+
+    /**
+    * Construit la vue du tour de jeu.
+    *
+    * @param initial message initial à afficher
+    */
+    public TurnView(String initial) {
+        setBackground(new java.awt.Color(220,220,220));
+
+        text = new JLabel(initial);
+        text.setFont(new Font("Arial", Font.BOLD, 20));
+
+        add(text);
+    }
+
+    //Méthodes
+
+    /**
+    * Met à jour le texte affichant le joueur courant.
+    *
+    * @param s message à afficher
+    */
+    public void setTurn(String s) {
+        text.setText(s);
+    }
+}

fr/iut_fbleau/Avalam/ui/BoardView.java

@@ -1,118 +0,0 @@
-package fr.iut_fbleau.Avalam.ui;
-
-import fr.iut_fbleau.Avalam.AvalamBoard;
-import fr.iut_fbleau.Avalam.Tower;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
- * BoardView est la vue principale du plateau Avalam.
- *
- * Elle gère :
- *  - l’affichage des tours (PieceLayer)
- *  - l’affichage des coups possibles (HighlightLayer)
- *  - les clics via InteractionController
- *
- * Toute la logique de jeu est déléguée au moteur AvalamBoard
- * et au contrôleur InteractionController.
- */
-public class BoardView extends JLayeredPane {
-
-    /** Référence au moteur Avalam */
-    private AvalamBoard board;
-
-    /** Couche d’affichage des rond verts */
-    private HighlightLayer highlightLayer;
-
-    /** Couche d’affichage des tours */
-    private PieceLayer pieceLayer;
-
-    /** 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 board moteur Avalam utilisé pour afficher la grille
-     * @param boardUpdateCallback callback appelé après chaque coup
-     */
-    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
-        this.board = board;
-        this.boardUpdateCallback = boardUpdateCallback;
-
-        setLayout(null);
-
-        // Contrôleur
-        this.controller = new InteractionController(board, this);
-
-        // Couche Highlight
-        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
-        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
-
-        // Couche des pièces
-        pieceLayer = new PieceLayer();
-        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
-
-        setPreferredSize(new Dimension(800, 800));
-
-        refresh();
-    }
-
-    /**
-     * 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(
-                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;
-    }
-}

fr/iut_fbleau/Avalam/ui/HighlightLayer.java

@@ -1,74 +0,0 @@
-package fr.iut_fbleau.Avalam.ui;
-
-import javax.swing.*;
-import java.awt.*;
-import java.util.List;
-
-/**
- * La classe <code>HighlightLayer</code> est responsable de l'affichage des
- * cases de déplacement autorisées sous forme de cercles verts.
- *
- * Elle n'interagit pas directement avec les pièces, mais se contente
- * de dessiner en arrière-plan selon une liste de positions légales.
- *
- * @author
- * @version 1.0
- */
-public class HighlightLayer extends JPanel {
-
-    private int xBase, yBase, spacing, size;
-
-    /** Liste des positions jouables (cases en vert). */
-    private List<Point> legalMoves;
-
-    /**
-     * Constructeur.
-     *
-     * @param xBase position X de base du plateau
-     * @param yBase position Y de base du plateau
-     * @param spacing espacement entre cases
-     * @param size taille des pions
-     */
-    public HighlightLayer(int xBase, int yBase, int spacing, int size) {
-        this.xBase = xBase;
-        this.yBase = yBase;
-        this.spacing = spacing;
-        this.size = size;
-
-        setOpaque(false);
-        setBounds(0, 0, 800, 800);
-    }
-
-    /**
-     * Définit la liste des cases légales à afficher.
-     */
-    public void setLegalMoves(List<Point> moves) {
-        this.legalMoves = moves;
-        repaint();
-    }
-
-    /**
-     * Dessine les cercles verts autour des cases autorisées.
-     */
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-
-        if (legalMoves == null) return;
-
-        Graphics2D g2 = (Graphics2D) g;
-        g2.setColor(new Color(0, 255, 0, 120));
-
-        for (Point p : legalMoves) {
-
-            int r = p.x;
-            int c = p.y;
-
-            int x = xBase + c * spacing;
-            int y = yBase + r * spacing;
-
-            int highlight = size + 20; // Cercle plus grand que le pion
-            g2.fillOval(x - 10, y - 10, highlight, highlight);
-        }
-    }
-}

fr/iut_fbleau/Avalam/ui/ScoreView.java

@@ -1,46 +0,0 @@
-package fr.iut_fbleau.Avalam.ui;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
- * La classe <code>ScoreView</code> affiche les scores actuels des deux joueurs.
- * 
- * Elle est purement graphique : aucune logique de calcul n'est présente.
- *
- * @author
- * @version 1.0
- */
-public class ScoreView extends JPanel {
-
-    private JLabel scoreY, scoreR;
-
-    /**
-     * Constructeur.
-     *
-     * @param y score initial du joueur jaune
-     * @param r score initial du joueur rouge
-     */
-    public ScoreView(int y, int r) {
-        setBackground(new Color(200,200,200));
-        setLayout(new FlowLayout());
-
-        scoreY = new JLabel("Score Jaune : " + y);
-        scoreR = new JLabel("Score Rouge : " + r);
-
-        scoreY.setFont(new Font("Arial", Font.BOLD, 18));
-        scoreR.setFont(new Font("Arial", Font.BOLD, 18));
-
-        add(scoreY);
-        add(new JLabel("   |   "));
-        add(scoreR);
-    }
-
-    /**
-     * Met à jour l'affichage des scores.
-     */
-    public void updateScores(int y, int r) {
-        scoreY.setText("Score Jaune : " + y);
-        scoreR.setText("Score Rouge : " + r);
-    }
-}

fr/iut_fbleau/Avalam/ui/TurnView.java

@@ -1,41 +0,0 @@
-package fr.iut_fbleau.Avalam.ui;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
- * La classe <code>TurnView</code> affiche le joueur à qui c'est le tour.
- *
- * Elle agit comme une simple bannière d’information,
- * mise à jour par la logique du jeu.
- *
- * @author
- * @version 1.0
- */
-public class TurnView extends JPanel {
-
-    private JLabel text;
-
-    /**
-     * Constructeur.
-     *
-     * @param initial message initial à afficher
-     */
-    public TurnView(String initial) {
-        setBackground(new Color(220,220,220));
-
-        text = new JLabel(initial);
-        text.setFont(new Font("Arial", Font.BOLD, 20));
-
-        add(text);
-    }
-
-    /**
-     * Met à jour le texte affichant le joueur courant.
-     *
-     * @param s message à afficher
-     */
-    public void setTurn(String s) {
-        text.setText(s);
-    }
-}

fr/iut_fbleau/Bot/AlphaBetaBot.java

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.Bot;
+
+import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.IBoard;
+import fr.iut_fbleau.GameAPI.Player;
+
+/**
+ * Bot Alpha-Beta (préparé).
+ * Pour l'instant non implémenté.
+ */
+public class AlphaBetaBot extends AbstractGamePlayer {
+
+    public AlphaBetaBot(Player p) {
+        super(p);
+    }
+
+    @Override
+    public AbstractPly giveYourMove(IBoard board) {
+        throw new UnsupportedOperationException("AlphaBetaBot non implémenté pour l'instant.");
+    }
+}

fr/iut_fbleau/Bot/IdiotBot.java

@@ -0,0 +1,43 @@
+package fr.iut_fbleau.Bot;
+
+import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.IBoard;
+import fr.iut_fbleau.GameAPI.Player;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Bot idiot : choisit un coup légal au hasard parmi ceux retournés par IBoard.iterator().
+ * Compatible avec n'importe quel jeu respectant GameAPI (dont AvalamBoard).
+ */
+public class IdiotBot extends AbstractGamePlayer {
+
+    private final Random rng;
+
+    public IdiotBot(Player p) {
+        super(p);
+        this.rng = new Random();
+    }
+
+    @Override
+    public AbstractPly giveYourMove(IBoard board) {
+
+        // Si la partie est terminée ou qu'il n'y a pas de coups, on ne joue rien.
+        if (board == null || board.isGameOver()) return null;
+
+        Iterator<AbstractPly> it = board.iterator();
+        List<AbstractPly> moves = new ArrayList<>();
+
+        while (it.hasNext()) {
+            moves.add(it.next());
+        }
+
+        if (moves.isEmpty()) return null;
+
+        return moves.get(rng.nextInt(moves.size()));
+    }
+}