Bot Divin et AvalamWindow connecté

Makefile

@@ -1,6 +1,3 @@
-# === Environnements ===
-TEST_ENV = "bin:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
-
 # === Répertoires ===
 SRC_DIR = fr
 BIN_DIR = bin
@@ -15,16 +12,12 @@ 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) -cp $(TEST_ENV)
+JCFLAGS = -d $(BIN_DIR)
 
 JAVA = java
 JAVAFLAGS = -cp $(BIN_DIR)
-JAVAFLAGS_TESTS = -cp $(TEST_ENV)
 
 # === Règle par défaut ===
 all: build
@@ -50,12 +43,6 @@ 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,11 +4,9 @@
 
 Date de création : 16/10/25
 
-Date de rendu : 06/02/26
+Le but est de mettre en oeuvre des jeux plus intéressants que le jeu de Nim, toujours en suivant l'API.
 
-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, 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).
-
-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**.
 
@@ -19,11 +17,6 @@ Le jeu de notre groupe est **Avalam**.
 make build
 ```
 
-### Tests
-```bash
-make test
-```
-
 ### Exécution
 ```bash
 make run
@@ -85,13 +78,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 officielles :
+### Régles officiel :
 **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. 
 
-**Déplacements** \
+**Deplacements** \
 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/AvalamWindow.java

@@ -2,7 +2,7 @@ package fr.iut_fbleau.Avalam;
 
 import fr.iut_fbleau.Bot.AlphaBetaBot;
 // A FAIRE PLUS TARD (PVGOD)
-// import fr.iut_fbleau.Bot.DivineBot;
+import fr.iut_fbleau.Bot.DivineBot;
 import fr.iut_fbleau.Bot.IdiotBot;
 import fr.iut_fbleau.GameAPI.AbstractPly;
 import fr.iut_fbleau.GameAPI.Player;
@@ -59,6 +59,8 @@ public class AvalamWindow extends JFrame {
     /** Bot Alpha-Beta (utilisé si mode PVALPHA). */
     private final AlphaBetaBot alphaBot;
 
+    private final DivineBot divineBot;
+
     // A FAIRE PLUS TARD (PVGOD)
     // /** Bot Divin (utilisé si mode PVGOD). */
     // private final DivineBot divineBot;
@@ -68,7 +70,6 @@ public class AvalamWindow extends JFrame {
      * 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;
@@ -110,7 +111,7 @@ public class AvalamWindow extends JFrame {
         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;
+        this.divineBot = (mode == GameMode.PVGOD) ? new DivineBot(botPlayer, depth) : null;
 
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLayout(new BorderLayout());
@@ -220,11 +221,10 @@ public class AvalamWindow extends JFrame {
         if (mode == GameMode.PVALPHA && alphaBot == null) return;
 
         // A FAIRE PLUS TARD (PVGOD)
-        // if (mode == GameMode.PVGOD && divineBot == null) return;
+        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;
 
@@ -239,8 +239,7 @@ public class AvalamWindow extends JFrame {
             botMove = alphaBot.giveYourMove(board.safeCopy());
         } else {
             // A FAIRE PLUS TARD (PVGOD)
-            // botMove = divineBot.giveYourMove(board.safeCopy());
+            botMove = divineBot.giveYourMove(board.safeCopy());
-            botMove = null;
         }
 
         if (botMove == null) {

fr/iut_fbleau/Avalam/BackgroundLayer.java

@@ -1,37 +0,0 @@
-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/BoardView.java

@@ -10,7 +10,7 @@ import java.awt.*;
 * Elle gère :
 * - l’affichage des tours (PieceLayer)
 * - l’affichage des coups possibles (HighlightLayer)
-* - l’affichage du fond graphique (BackgroundLayer)
+* - l’affichage du fond graphique
 * - les clics via InteractionController
 *
 * Cette classe ne contient aucune logique de règles du jeu.
@@ -156,4 +156,37 @@ public class BoardView extends JLayeredPane {
         }
         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/Bot/DivineBot.java

@@ -1,22 +1,185 @@
 package fr.iut_fbleau.Bot;
 
-import fr.iut_fbleau.Avalam.AvalamBoard;
+import fr.iut_fbleau.Avalam.*;
-import fr.iut_fbleau.Avalam.AvalamPly;
+import fr.iut_fbleau.GameAPI.*;
-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.
+ * Bot "Divin" (alpha-beta + évaluateur pondéré).
- *
+ * * Idée :
- *
+ * - Utilise l'algorithme Alpha-Beta pour anticiper les coups.
- * Objectif : trop fort. */
+ * - Évalue les plateaux non terminaux en accordant plus d'importance aux tours hautes.
-public class DivineBot{
+ */
+public class DivineBot extends AbstractGamePlayer {
 
+    // Attributs
+
+    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
+    private final Player me;
+
+    /** Profondeur maximale de recherche avant évaluation. */
+    private final int maxDepth;
+
+    /** Générateur aléatoire pour choisir parmi les meilleurs coups équivalents. */
+    private final Random rng = new Random();
+
+    // Constructeur
+
+    /**
+     * Construit le bot Divine.
+     *
+     * @param p joueur contrôlé par ce bot
+     * @param maxDepth profondeur de l'arbre de recherche
+     */
+    public DivineBot(Player p, int maxDepth) {
+        super(p);
+        this.me = p;
+        this.maxDepth = Math.max(1, maxDepth);
+    }
+
+    // Méthodes
+
+    /**
+     * Méthode principale de décision du bot.
+     * Explore le premier niveau de l'arbre et lance les appels Alpha-Beta.
+     * * @param board état actuel du jeu
+     * @return le meilleur coup calculé (AbstractPly)
+     */
+    @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);
+
+            // Appel récursif pour évaluer la suite du coup
+            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);
+            }
+        }
+
+        // Retourne un coup au hasard parmi les meilleurs ex-aequo
+        return bestMoves.get(rng.nextInt(bestMoves.size()));
+    }
+
+    /**
+     * Algorithme récursif de recherche avec élagage Alpha-Beta.
+     */
+    private int alphaBeta(IBoard board, int depth, int alpha, int beta) {
+
+        // Cas de base : fin de partie ou limite de profondeur atteinte
+        if (board.isGameOver()) return terminalValue(board);
+        if (depth == 0) return evaluate(board);
+
+        boolean isMax = board.getCurrentPlayer() == me;
+
+        for (AbstractPly m : listMoves(board)) {
+            IBoard next = board.safeCopy();
+            next.doPly(m);
+
+            int val = alphaBeta(next, depth - 1, alpha, beta);
+
+            if (isMax) {
+                alpha = Math.max(alpha, val);
+                if (alpha >= beta) break; // Coupure Beta
+            } else {
+                beta = Math.min(beta, val);
+                if (alpha >= beta) break; // Coupure Alpha
+            }
+        }
+
+        return isMax ? alpha : beta;
+    }
+
+    /**
+     * Calcule la valeur de l'état final (Victoire / Défaite).
+     */
+    private int terminalValue(IBoard board) {
+        Result r = board.getResult();
+        if (r == null) return 0;
+
+        if (r == Result.DRAW) return 0;
+
+        boolean botIsP1 = (me == Player.PLAYER1);
+        // Si le bot gagne, valeur positive élevée, sinon valeur négative
+        return ((r == Result.WIN) == botIsP1) ? 100000 : -100000;
+    }
+
+    /**
+     * Heuristique évoluée pour Avalam :
+     * Calcule un score basé sur le contrôle des tours et leur hauteur.
+     * Les tours de hauteur 5 sont prioritaires car elles sont bloquées.
+     */
+    private int evaluate(IBoard board) {
+
+        if (!(board instanceof AvalamBoard)) return 0;
+        AvalamBoard b = (AvalamBoard) board;
+
+        Color myColor = (me == Player.PLAYER1) ? Color.YELLOW : Color.RED;
+        Color oppColor = (myColor == Color.YELLOW) ? Color.RED : Color.YELLOW;
+
+        int score = 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;
+
+                int h = t.getHeight();
+                
+                // Pondération selon la hauteur (heuristique "Divine")
+                int value =
+                        (h == 5) ? 1000 :
+                        (h == 4) ? 300 :
+                        (h == 3) ? 120 :
+                        (h == 2) ? 40 : 10;
+
+                if (t.getColor() == myColor) score += value;
+                else score -= value;
+            }
+        }
+        return score;
+    }
+
+    /**
+     * Génère la liste de tous les coups possibles sur le plateau donné.
+     */
+    private List<AbstractPly> listMoves(IBoard board) {
+        List<AbstractPly> moves = new ArrayList<>();
+        board.iterator().forEachRemaining(moves::add);
+        return moves;
+    }
 }

fr/iut_fbleau/Tests/AvalamBoardTest.java

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