Ajout de la commande de test au ReadMe + légères corrections de langue

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
+    }

Makefile

@@ -1,3 +1,6 @@
+# === Environnements ===
+TEST_ENV = "bin:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
+
 # === Répertoires ===
 SRC_DIR = fr
 BIN_DIR = bin
@@ -12,12 +15,16 @@ SOURCES := $(shell find $(SRC_DIR) -name "*.java")
 # === Classe principale ===
 MAIN_CLASS = fr.iut_fbleau.Avalam.Main
 
+# === Classe de test ===
+TEST_CLASS = fr.iut_fbleau.Tests.AvalamBoardTest
+
 # === Commandes Java ===
 JC = javac
-JCFLAGS = -d $(BIN_DIR)
+JCFLAGS = -d $(BIN_DIR) -cp $(TEST_ENV)
 
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
+JAVAFLAGS_TESTS = -cp $(TEST_ENV)
 
 # === Règle par défaut ===
 all: build
@@ -43,6 +50,12 @@ run:
 	@echo "===> Lancement du jeu Avalam..."
 	@$(JAVA) $(JAVAFLAGS) $(MAIN_CLASS)
 
+# === Tests ===
+test:
+	@echo "===> Lancement des tests..."
+	@$(JAVA) $(JAVAFLAGS_TESTS) org.junit.runner.JUnitCore $(TEST_CLASS)
+	@echo "... Fin des tests."
+
 # === Nettoyage ===
 clean:
 	@echo "===> Suppression des fichiers compilés..."

README.md

@@ -4,9 +4,11 @@
 
 Date de création : 16/10/25
 
-Le but est de mettre en oeuvre des jeux plus intéressants que le jeu de Nim, toujours en suivant l'API.
+Date de rendu : 06/02/26
 
-Dans un second temps, on fera des bots le plus efficace possible (probablement un alpha beta avec cut-off plus fonction d'évaluation qui peut être faite à la main ou par MonteCarlo).
+Le but est de mettre en oeuvre un jeu plus intéressants que le jeu de Nim, en suivant l'API de Florent Madelaine.
+
+Dans un second temps, nous développerons des bots les plus efficaces possible, probablement en utilisant un algorithme alpha-bêta avec cut-off et une fonction d'évaluation réalisé à la main ou par MonteCarlo.
 
 Le jeu de notre groupe est **Avalam**.
 
@@ -17,6 +19,11 @@ Le jeu de notre groupe est **Avalam**.
 make build
 ```
 
+### Tests
+```bash
+make test
+```
+
 ### Exécution
 ```bash
 make run
@@ -78,13 +85,13 @@ Le plateau est représenté par une grille 9x9 où chaque case contient :
 
 Sur un plateau de jeu, les joueurs disposent de 24 pions chacun. Le but est de créer de petites tours avec son pion de couleur au-dessus. Pour ce faire, chaque joueur déplace son pion sur une tour ou déplace une tour sur un autre pion. La personne ayant le plus de pions sur le dessus des tours gagne.
 
-### Régles officiel :
+### Règles officielles :
 **Régle de base** \
 Chaque joueur choisit sa couleur.
 Le but du jeu est de constituer un maximum de tours de 1 à 5 pions, jamais plus, surmontées par un pion de sa couleur.
 Un joueur est le propriétaire d'une tour lorsqu'un pion de sa couleur en occupe le sommet. Un pion isolé constitue également une tour. 
 
-**Deplacements** \
+**Déplacements** \
 Chaque joueur en effectue un seul mouvement, dans n'importe quel sens (horizontal, vertical, diagonal) avec n'importe quel pion (ou pile de pions), quelle qu'en soit la couleur. Ce mouvement consiste à empiler le ou les pions déplacés sur un trou directement voisin déjà occupé par un ou plusieurs pions.
 
 **Mouvement interdit (1)** \

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,14 +272,31 @@ 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];
 
-        for (int r = 0; r < SIZE; r++)
+        for (int r = 0; r < SIZE; r++) {
-            for (int c = 0; c < SIZE; c++)
+            for (int c = 0; c < SIZE; c++) {
-                newGrid[r][c] = grid[r][c];
 
-        return new AvalamBoard(newGrid, getCurrentPlayer(), gameOver, result);
+                Tower t = grid[r][c];
+                if (t == null) {
+                    newGrid[r][c] = null;
+                } else {
+                    // Copie profonde : on recrée une nouvelle Tower indépendante
+                    newGrid[r][c] = new Tower(t.getHeight(), t.getColor());
+                }
+            }
+        }
+
+        // On conserve le joueur courant
+        return new AvalamBoard(newGrid, getCurrentPlayer());
     }
 }

fr/iut_fbleau/Avalam/AvalamPly.java

@@ -4,37 +4,36 @@ 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 xFrom ligne d'origine
@@ -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,10 @@
 package fr.iut_fbleau.Avalam;
 
-import fr.iut_fbleau.Avalam.logic.BoardLoader;
+import fr.iut_fbleau.Bot.AlphaBetaBot;
-import fr.iut_fbleau.Avalam.ui.BoardView;
+// A FAIRE PLUS TARD (PVGOD)
-import fr.iut_fbleau.Avalam.ui.ScoreView;
+// import fr.iut_fbleau.Bot.DivineBot;
-import fr.iut_fbleau.Avalam.ui.TurnView;
+import fr.iut_fbleau.Bot.IdiotBot;
+import fr.iut_fbleau.GameAPI.AbstractPly;
 import fr.iut_fbleau.GameAPI.Player;
 import fr.iut_fbleau.GameAPI.Result;
 
@@ -11,42 +12,116 @@ import javax.swing.*;
 import java.awt.*;
 
 /**
- * Fenêtre principale du jeu Avalam.
+ * La classe <code>AvalamWindow</code>
  *
+ * Fenêtre principale (interface graphique) du jeu Avalam.
  * Elle contient :
  * - le plateau (BoardView)
- *  - l'affichage du score
+ * - l’affichage du score (ScoreView)
- *  - l'affichage du joueur courant
+ * - 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 (cut-off)
+ * - joueur vs bot divin (PVGOD)
+ *
+ * @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;
+
+    /** Bot Alpha-Beta (utilisé si mode PVALPHA). */
+    private final AlphaBetaBot alphaBot;
+
+    // A FAIRE PLUS TARD (PVGOD)
+    // /** Bot Divin (utilisé si mode PVGOD). */
+    // private final DivineBot divineBot;
+
+    /**
+     * A FAIRE PLUS TARD (PVGOD)
+     * On garde l'attribut à null pour ne pas casser la compilation,
+     * mais toute la logique PVGOD est désactivée/commentée.
+     */
+    private final Object divineBot = null;
+
+    /** 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, 4);
+    }
+
+    /**
+     * Construit la fenêtre en fonction du mode choisi.
+     * Pour PVALPHA/PVGOD, la profondeur par défaut est 4.
+     *
+     * @param mode mode de jeu
+     */
+    public AvalamWindow(GameMode mode) {
+        this(mode, 4);
+    }
+
+    /**
+     * Construit la fenêtre en fonction du mode choisi.
+     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off.
+     *
+     * @param mode mode de jeu
+     * @param alphaDepth profondeur de recherche pour Alpha-Beta / Bot Divin
+     */
+    public AvalamWindow(GameMode mode, int alphaDepth) {
         super("Avalam");
 
+        this.mode = mode;
+
+        this.idiotBot = (mode == GameMode.PVBOT) ? new IdiotBot(botPlayer) : null;
+
+        int depth = Math.max(1, alphaDepth);
+        this.alphaBot = (mode == GameMode.PVALPHA) ? new AlphaBetaBot(botPlayer, depth) : null;
+
+        // A FAIRE PLUS TARD (PVGOD)
+        // this.divineBot = (mode == GameMode.PVGOD) ? new DivineBot(botPlayer, depth) : 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 +137,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 devait commencer (pas le cas ici), on le ferait jouer 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,31 +165,132 @@ 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();
+    }
 
-    /* ================================================================
+    /**
-     *                             OUTILS
+     * Fait jouer le bot (idiot / alpha / divin) 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() {
+
+        // Mode joueur vs joueur : aucun bot
+        if (mode == GameMode.PVP) return;
+
+        // Sécurité
+        if (board.isGameOver()) return;
+        if (board.getCurrentPlayer() != botPlayer) return;
+        if (botAnimating) return;
+
+        // Vérifier qu'on a bien le bot correspondant
+        if (mode == GameMode.PVBOT && idiotBot == null) return;
+        if (mode == GameMode.PVALPHA && alphaBot == null) return;
+
+        // A FAIRE PLUS TARD (PVGOD)
+        // if (mode == GameMode.PVGOD && divineBot == null) return;
+
+        // A FAIRE PLUS TARD (PVGOD)
+        // Pour l'instant, si PVGOD est sélectionné, on ne joue pas de coup bot.
+        if (mode == GameMode.PVGOD) 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;
+        if (mode == GameMode.PVBOT) {
+            botMove = idiotBot.giveYourMove(board.safeCopy());
+        } else if (mode == GameMode.PVALPHA) {
+            botMove = alphaBot.giveYourMove(board.safeCopy());
+        } else {
+            // A FAIRE PLUS TARD (PVGOD)
+            // botMove = divineBot.giveYourMove(board.safeCopy());
+            botMove = null;
+        }
+
+        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.
+     *
+     * @param c couleur à compter
+     * @return nombre de tours appartenant à la couleur c
      */
     private int computeScore(Color c) {
         int score = 0;
@@ -132,10 +306,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 : " +
                 (board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge");
     }
+
+    //Affichage
 }

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

@@ -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+");
 
@@ -37,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

@@ -0,0 +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 (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/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,11 @@
+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
+    PVGOD       // joueur vs bot stratégique
+}

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,37 +9,57 @@ 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;
     }
@@ -51,9 +67,12 @@ public class InteractionController {
     /**
     * Appelé lorsqu’un pion est cliqué dans BoardView.
     * 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) {
 
@@ -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,8 +120,8 @@ 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,12 +141,11 @@ 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
@@ -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,69 @@
 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",
+                    "joueur vs bot divin (NON IMPLEMENTE)"
+            };
+
+            int choice = JOptionPane.showOptionDialog(
+                    null,
+                    "Choisissez un mode de jeu :",
+                    "Avalam - Mode de jeu",
+                    JOptionPane.DEFAULT_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    null,
+                    options,
+                    options[0]
+            );
+
+            if (choice == -1) System.exit(0);
+
+            GameMode mode;
+            if (choice == 1) mode = GameMode.PVBOT;
+            else if (choice == 2) mode = GameMode.PVALPHA;
+            else if (choice == 3) mode = GameMode.PVGOD;
+            else mode = GameMode.PVP;
+
+            // Pour ALPHA et GOD : demander une profondeur
+            if (mode == GameMode.PVALPHA || mode == GameMode.PVGOD) {
+
+                String s = JOptionPane.showInputDialog(
+                        null,
+                        "Profondeur de recherche ?\n(Conseil 4)",
+                        (mode == GameMode.PVGOD ? "Bot Divin (PVGOD)" : "Bot Alpha-Beta"),
+                        JOptionPane.QUESTION_MESSAGE
+                );
+
+                int depth = 4; // défaut
+                if (s != null) {
+                    try { depth = Integer.parseInt(s.trim()); }
+                    catch (Exception ignored) { depth = 4; }
+                } else {
+                    // Annulation : on revient en PVP
+                    new AvalamWindow(GameMode.PVP);
+                    return;
+                }
+
+                if (depth < 1) depth = 1;
+
+                new AvalamWindow(mode, depth);
+                return;
+            }
+
+            new AvalamWindow(mode);
+        });
     }
 }

fr/iut_fbleau/Avalam/PieceButton.java

@@ -1,34 +1,41 @@
-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 height hauteur de la tour
@@ -52,8 +59,12 @@ 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) {
@@ -78,8 +89,14 @@ public class PieceButton extends JButton {
         g2.dispose();
     }
 
+    //Affichage
+
     /**
     * 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) {

fr/iut_fbleau/Avalam/PieceLayer.java

@@ -1,31 +1,25 @@
-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);
@@ -33,12 +27,14 @@ public class PieceLayer extends JPanel {
         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 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 size taille d'un pion
     * @param clickCallback fonction appelée lors d’un clic sur un pion

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,88 @@
 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(int, Color) utilisé dans d'autres parties possibles
+* - usine createTower(Color) utilisé par BoardLoader
+* - méthode mergeTower(Tower) utilisée par AvalamBoard
+*/
 public class Tower {
+    //Attributs
 
+    /** Hauteur de la tour (nombre de pions empilés). */
+    private byte height;
+
+    /** Couleur du sommet de la tour (propriétaire actuel). */
     private Color color;
-    private int height;
 
-    /** Nouvelle tour de hauteur 1 */
+    //Constructeur
-    public Tower(Color color) {
+
+    /**
+    * Construit une tour avec une hauteur et une couleur données.
+    *
+    * @param height hauteur initiale
+    * @param color couleur du sommet
+    */
+    public Tower(int height, Color color) {
+        this.height = (byte) height;
         this.color = color;
-        this.height = 1;
     }
 
-    /** Tour avec couleur et hauteur existantes */
+    /**
-    public Tower(Color color, int height) {
+    * Construit une tour de hauteur 1 avec la couleur donnée.
-        this.color = color;
+    * (Constructeur attendu par BoardLoader dans le projet.)
-        this.height = height;
+    *
+    * @param color couleur du sommet
+    */
+    public static Tower createTower(Color color) {
+        return new Tower(1, 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 void mergeTower(Tower src) {
+    public Color getColor() {
-        this.color = src.color;
+        return 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 mergeTower(Tower src) {
+        this.height += src.height;
+        this.color = src.color;
+    }
+
+    //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,217 @@
+package fr.iut_fbleau.Bot;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+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 fr.iut_fbleau.GameAPI.Result;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Bot Alpha-Beta avec cut-off (profondeur maximale).
+ *
+ * Idée :
+ * - si on atteint la profondeur limite, on évalue la position (heuristique).
+ * - sinon, on explore les coups avec Alpha-Beta (minimax optimisé).
+ *
+ * 
+ */
+public class AlphaBetaBot extends AbstractGamePlayer {
+
+    //Attributs
+
+    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
+    private final Player me;
+
+    /** Profondeur maximale de recherche (cut-off). */
+    private final int maxDepth;
+
+    /** Générateur aléatoire pour départager des coups de même valeur. */
+    private final Random rng = new Random();
+
+    //Constructeur
+
+    /**
+     * Construit un bot Alpha-Beta.
+     *
+     * @param p joueur contrôlé par ce bot
+     * @param maxDepth profondeur maximale de recherche
+     */
+    public AlphaBetaBot(Player p, int maxDepth) {
+        super(p);
+        this.me = p;
+        this.maxDepth = Math.max(1, maxDepth);
+    }
+
+    //Méthodes
+
+    /**
+     * Méthode appelée par GameAPI : le bot doit choisir un coup.
+     *
+     * @param board copie sûre de l'état de jeu (IBoard)
+     * @return un coup (AbstractPly) ou null si aucun coup possible
+     */
+    @Override
+    public AbstractPly giveYourMove(IBoard board) {
+
+        if (board == null || board.isGameOver()) return null;
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) return null;
+
+        boolean isMax = (board.getCurrentPlayer() == me);
+        int bestValue = isMax ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+
+        List<AbstractPly> bestMoves = new ArrayList<>();
+
+        int alpha = Integer.MIN_VALUE;
+        int beta = Integer.MAX_VALUE;
+
+        for (AbstractPly m : moves) {
+            IBoard next = board.safeCopy();
+            next.doPly(m);
+
+            int value = alphaBeta(next, maxDepth - 1, alpha, beta);
+
+            if (isMax) {
+                if (value > bestValue) {
+                    bestValue = value;
+                    bestMoves.clear();
+                    bestMoves.add(m);
+                } else if (value == bestValue) {
+                    bestMoves.add(m);
+                }
+                alpha = Math.max(alpha, bestValue);
+            } else {
+                if (value < bestValue) {
+                    bestValue = value;
+                    bestMoves.clear();
+                    bestMoves.add(m);
+                } else if (value == bestValue) {
+                    bestMoves.add(m);
+                }
+                beta = Math.min(beta, bestValue);
+            }
+        }
+
+        return bestMoves.get(rng.nextInt(bestMoves.size()));
+    }
+
+    /**
+     * Fonction récursive Alpha-Beta.
+     */
+    private int alphaBeta(IBoard board, int depth, int alpha, int beta) {
+
+        if (board.isGameOver()) {
+            return terminalValue(board);
+        }
+
+        if (depth == 0) {
+            return evaluate(board);
+        }
+
+        boolean isMax = (board.getCurrentPlayer() == me);
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) {
+            return evaluate(board);
+        }
+
+        if (isMax) {
+            int best = Integer.MIN_VALUE;
+
+            for (AbstractPly m : moves) {
+                IBoard next = board.safeCopy();
+                next.doPly(m);
+
+                int val = alphaBeta(next, depth - 1, alpha, beta);
+                best = Math.max(best, val);
+                alpha = Math.max(alpha, best);
+
+                if (alpha >= beta) break;
+            }
+            return best;
+
+        } else {
+            int best = Integer.MAX_VALUE;
+
+            for (AbstractPly m : moves) {
+                IBoard next = board.safeCopy();
+                next.doPly(m);
+
+                int val = alphaBeta(next, depth - 1, alpha, beta);
+                best = Math.min(best, val);
+                beta = Math.min(beta, best);
+
+                if (alpha >= beta) break;
+            }
+            return best;
+        }
+    }
+
+    /**
+     * Convertit le résultat final en valeur très grande (victoire/défaite).
+     * Result est du point de vue de PLAYER1.
+     */
+    private int terminalValue(IBoard board) {
+        Result r = board.getResult();
+        if (r == null) return 0;
+
+        boolean botIsP1 = (me == Player.PLAYER1);
+
+        if (r == Result.DRAW) return 0;
+
+        if (botIsP1) {
+            return (r == Result.WIN) ? 100000 : -100000;
+        } else {
+            return (r == Result.LOSS) ? 100000 : -100000;
+        }
+    }
+
+    /**
+     * Heuristique simple Avalam :
+     * score = (tours du bot) - (tours adverses)
+     */
+    private int evaluate(IBoard board) {
+
+        if (!(board instanceof AvalamBoard)) return 0;
+        AvalamBoard b = (AvalamBoard) board;
+
+        Color botColor = (me == Player.PLAYER1) ? Color.YELLOW : Color.RED;
+        Color oppColor = (me == Player.PLAYER1) ? Color.RED : Color.YELLOW;
+
+        int botTowers = 0;
+        int oppTowers = 0;
+
+        for (int r = 0; r < AvalamBoard.SIZE; r++) {
+            for (int c = 0; c < AvalamBoard.SIZE; c++) {
+                Tower t = b.getTowerAt(r, c);
+                if (t == null) continue;
+
+                if (t.getColor() == botColor) botTowers++;
+                else if (t.getColor() == oppColor) oppTowers++;
+            }
+        }
+
+        return botTowers - oppTowers;
+    }
+
+    /**
+     * Récupère tous les coups légaux via iterator().
+     */
+    private List<AbstractPly> listMoves(IBoard board) {
+        List<AbstractPly> moves = new ArrayList<>();
+        Iterator<AbstractPly> it = board.iterator();
+        while (it.hasNext()) moves.add(it.next());
+        return moves;
+    }
+
+    //Affichage
+}

fr/iut_fbleau/Bot/DivineBot.java

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.Bot;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.Avalam.Color;
+import fr.iut_fbleau.Avalam.Tower;
+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 fr.iut_fbleau.GameAPI.Result;
+
+import java.util.*;
+
+/**
+ * Bot "Divin" (fort) pour Avalam.
+ *
+ *
+ * Objectif : trop fort. */
+public class DivineBot{
+
+}

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()));
+    }
+}

fr/iut_fbleau/Tests/AvalamBoardTest.java

@@ -0,0 +1,123 @@
+package fr.iut_fbleau.Tests;
+
+import fr.iut_fbleau.GameAPI.AbstractPly;
+import fr.iut_fbleau.GameAPI.Player;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.Avalam.Tower;
+import fr.iut_fbleau.Avalam.Color;
+
+import org.junit.Before;
+import org.junit.Test;
+//import org.mockito.Mockito;  //Mockito absent
+
+import static org.junit.Assert.*;
+
+/**
+* La classe <code>AvalamBoardTest</code> test si la méthode isLegal() fonctionne comme prévu.
+*/
+public class AvalamBoardTest {
+
+    private Tower[][] grid;
+    private AvalamBoard board;
+
+    @Before
+    public void setUp() {
+        grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+
+        //Création des tours de tests
+        /* Motif
+        1,0,2 | 2,0,3
+        2,1,0 | 2,3,0
+        0,2,1 | 0,1,1
+        */
+        grid[4][2] = new Tower(2, Color.YELLOW);
+        grid[6][2] = new Tower(3, Color.RED);
+
+        grid[4][3] = new Tower(2, Color.RED);
+        grid[5][3] = new Tower(3, Color.YELLOW);
+
+        grid[5][4] = new Tower(1, Color.RED);
+        grid[6][4] = new Tower(1, Color.YELLOW);
+
+        //Joueur courant initialisé à 1, soit jaune
+        board = new AvalamBoard(grid);  //AvalamBoard copie la grille
+    }
+
+    /*
+    @Test  //Mockito absent
+    public void nonAvalamPly_returnsFalse() {
+        //Vérifie si l'instance est bien AvalamPly
+        AbstractPly fake = Mockito.mock(AbstractPly.class);  //Crée une instance non-AvalamPly
+        assertFalse(board.isLegal(fake));
+    }*/
+
+    @Test
+    public void outOfBounds_returnsFalse() {
+        //Source "out of box"
+        AvalamPly p = new AvalamPly(Player.PLAYER1, -1, 2, 4, 2);
+        assertFalse(board.isLegal(p));
+
+        //Destination "out of box"
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 6, 4, 9, 4);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sameCell_returnsFalse() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 4, 5, 4);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void emptySourceOrDest_returnsFalse() {
+        //Source null
+        AvalamPly p1 = new AvalamPly(Player.PLAYER1, 5, 5, 5, 4);
+        assertFalse(board.isLegal(p1));
+
+        //Destination null
+        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 6, 4, 6, 3);
+        assertFalse(board.isLegal(p2));
+    }
+
+    @Test
+    public void sourceNotOwned_returnsFalse() {
+        //Le joueur courant n'est pas rouge
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 4, 6, 4);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void notAdjacent_returnsFalse() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 2, 6, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void sameColor_returnsFalse() {
+        //La couleur des tours est identique
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 2, 5, 3);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void tooTallAfterMerge_returnsFalse() {
+        //Hauteur maximale dépassé : 3+3 = 6 > MAX_HEIGHT (5)
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 3, 6, 2);
+        assertFalse(board.isLegal(p));
+    }
+
+    @Test
+    public void validMove_returnsTrue() {
+        AvalamPly p = new AvalamPly(Player.PLAYER1, 5, 3, 4, 3);  //Hauteur limite à 5
+        assertTrue(board.isLegal(p));
+    }
+
+    @Test  //À vérifier
+    public void currentPlayerMismatchInPlyDoesNotAffectOwnershipCheck() {
+        //Si le coup est construit avec le mauvais joueur
+        AvalamPly p = new AvalamPly(Player.PLAYER2, 4, 2, 4, 3);
+        assertFalse(board.isLegal(p));
+    }
+}