Bot divin en cours de création

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..."

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

@@ -18,5 +18,175 @@ import java.util.*;
  *
  * Objectif : trop fort. */
 public class DivineBot{
+    private final Player me;
+    private final int maxDepth;
+    private final Random rng = new Random();
 
+    public DivineBot(Player p, int maxDepth) {
+        super(p);
+        this.me = p;
+        this.maxDepth = Math.max(1, maxDepth);
+    }
+
+    // ===================== COUP À JOUER =====================
+
+    @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()));
+    }
+
+    // ===================== 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);
+        }
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) {
+            return evaluate(board);
+        }
+
+        boolean isMax = board.getCurrentPlayer() == me;
+
+        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;
+        }
+    }
+
+    // ===================== TERMINAL =====================
+
+    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;
+        }
+    }
+
+    // ===================== ÉVALUATEUR =====================
+
+    /**
+     * Évaluateur heuristique Avalam :
+     * - tours finales > quasi finales > stables > faibles
+     * - approximation du score final
+     */
+    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 = (me == Player.PLAYER1) ? 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();
+                int value;
+
+                if (h == 5) value = 1000;      // tour gagnée
+                else if (h == 4) value = 300;  // quasi gagnée
+                else if (h == 3) value = 120;  // stable
+                else if (h == 2) value = 40;
+                else value = 10;
+
+                if (t.getColor() == myColor) score += value;
+                else if (t.getColor() == oppColor) score -= value;
+            }
+        }
+
+        return score;
+    }
+
+    // ===================== OUTILS =====================
+
+    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;
+    }
 }

fr/iut_fbleau/Tests/AvalamBoardTest.java

@@ -1,122 +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;  //À retirer si 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];
-        // Par défaut, current player sera PLAYER1 via constructeur sans joueur
-        board = new AvalamBoard(grid);
-    }
-
-    /*
-    @Test  //À retirer si Mockito absent
-    public void nonAvalamPly_returnsFalse() {
-        AbstractPly fake = Mockito.mock(AbstractPly.class); // instance non-AvalamPly
-        assertFalse(board.isLegal(fake));
-    }*/
-
-    @Test
-    public void outOfBounds_returnsFalse() {
-        grid[2][2] = new Tower(1, Color.YELLOW);
-        grid[2][3] = new Tower(1, Color.RED);
-        AvalamPly p = new AvalamPly(Player.PLAYER1, -1, 2, 2, 3);
-        assertFalse(board.isLegal(p));
-
-        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 2, 2, 9, 3);
-        assertFalse(board.isLegal(p2));
-    }
-
-    @Test
-    public void sameCell_returnsFalse() {
-        grid[4][4] = new Tower(1, Color.YELLOW);
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 4, 4, 4);
-        assertFalse(board.isLegal(p));
-    }
-
-    @Test
-    public void emptySourceOrDest_returnsFalse() {
-        // source null
-        grid[3][3] = null;
-        grid[3][4] = new Tower(1, Color.RED);
-        AvalamPly p1 = new AvalamPly(Player.PLAYER1, 3, 3, 3, 4);
-        assertFalse(board.isLegal(p1));
-
-        // dest null
-        grid[5][5] = new Tower(1, Color.YELLOW);
-        grid[5][6] = null;
-        AvalamPly p2 = new AvalamPly(Player.PLAYER1, 5, 5, 5, 6);
-        assertFalse(board.isLegal(p2));
-    }
-
-    @Test
-    public void sourceNotOwned_returnsFalse() {
-        // current player = PLAYER1 -> color must be YELLOW
-        grid[2][2] = new Tower(1, Color.RED); // not owned
-        grid[2][3] = new Tower(1, Color.YELLOW);
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 2, 2, 2, 3);
-        assertFalse(board.isLegal(p));
-    }
-
-    @Test
-    public void notAdjacent_returnsFalse() {
-        grid[0][0] = new Tower(1, Color.YELLOW);
-        grid[0][2] = new Tower(1, Color.RED);
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 0, 0, 0, 2);
-        assertFalse(board.isLegal(p));
-    }
-
-    @Test
-    public void sameColor_returnsFalse() {
-        grid[6][6] = new Tower(1, Color.YELLOW);
-        grid[6][7] = new Tower(1, Color.YELLOW); // same color as source
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 6, 6, 6, 7);
-        assertFalse(board.isLegal(p));
-    }
-
-    @Test
-    public void tooTallAfterMerge_returnsFalse() {
-        grid[1][1] = new Tower(3, Color.YELLOW);
-        grid[1][2] = new Tower(3, Color.RED); // 3+3 = 6 > MAX_HEIGHT (5)
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 1, 1, 1, 2);
-        assertFalse(board.isLegal(p));
-    }
-
-    @Test
-    public void validMove_returnsTrue() {
-        grid[4][4] = new Tower(2, Color.YELLOW); // owned by PLAYER1
-        grid[4][5] = new Tower(2, Color.RED);    // opposite color
-        AvalamPly p = new AvalamPly(Player.PLAYER1, 4, 4, 4, 5);
-        assertTrue(board.isLegal(p));
-    }
-
-    @Test
-    public void currentPlayerMismatchInPlyDoesNotAffectOwnershipCheck() {
-        // Even if AvalamPly is constructed with a player value, isLegal uses board.getCurrentPlayer()
-        grid[7][7] = new Tower(1, Color.YELLOW); // owned by PLAYER1 (board default)
-        grid[7][8] = new Tower(1, Color.RED);
-        // Construct ply with PLAYER2 explicitly — ownership check should still compare to board.getCurrentPlayer()
-        AvalamPly p = new AvalamPly(Player.PLAYER2, 7, 7, 7, 8);
-        assertFalse(board.isLegal(p));
-    }
-}