Test de isLegal (à debug) [wip]

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

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,8 +59,6 @@ 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;
@@ -70,6 +68,7 @@ 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;
@@ -111,7 +110,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());
@@ -221,10 +220,11 @@ 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,7 +239,8 @@ 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

@@ -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/BoardView.java

@@ -1,192 +1,159 @@
-package fr.iut_fbleau.Avalam;
+package fr.iut_fbleau.Avalam;
-
+
-import javax.swing.*;
+import javax.swing.*;
-import java.awt.*;
+import java.awt.*;
-
+
-/**
+/**
-* La classe <code>BoardView</code>
+* La classe <code>BoardView</code>
-*
+*
-* Représente la vue principale du plateau Avalam.
+* Représente la vue principale du plateau Avalam.
-* Elle gère :
+* Elle gère :
-* - l’affichage des tours (PieceLayer)
+* - l’affichage des tours (PieceLayer)
-* - l’affichage des coups possibles (HighlightLayer)
+* - l’affichage des coups possibles (HighlightLayer)
-* - l’affichage du fond graphique
+* - l’affichage du fond graphique (BackgroundLayer)
-* - les clics via InteractionController
+* - les clics via InteractionController
-*
+*
-* Cette classe ne contient aucune logique de règles du jeu.
+* Cette classe ne contient aucune logique de règles du jeu.
-*
+*
-* @version 1.0
+* @version 1.0
-* Date :
+* Date :
-* Licence :
+* Licence :
-*/
+*/
-public class BoardView extends JLayeredPane {
+public class BoardView extends JLayeredPane {
-
+
-    //Attributs
+    //Attributs
-
+
-    /** Référence au moteur Avalam. */
+    /** Référence au moteur Avalam. */
-    private AvalamBoard board;
+    private AvalamBoard board;
-
+
-    /** Couche d’affichage du fond. */
+    /** Couche d’affichage du fond. */
-    private BackgroundLayer backgroundLayer;
+    private BackgroundLayer backgroundLayer;
-
+
-    /** Couche d’affichage des coups possibles. */
+    /** Couche d’affichage des coups possibles. */
-    private HighlightLayer highlightLayer;
+    private HighlightLayer highlightLayer;
-
+
-    /** Couche d’affichage des pièces. */
+    /** Couche d’affichage des pièces. */
-    private PieceLayer pieceLayer;
+    private PieceLayer pieceLayer;
-
+
-    /** Contrôleur des interactions. */
+    /** Contrôleur des interactions. */
-    private InteractionController controller;
+    private InteractionController controller;
-
+
-    /** Taille d’un pion en pixels. */
+    /** Taille d’un pion en pixels. */
-    private final int size = 50;
+    private final int size = 50;
-
+
-    /** Espacement entre les cases. */
+    /** Espacement entre les cases. */
-    private final int spacing = 70;
+    private final int spacing = 70;
-
+
-    /** Décalage horizontal du plateau. */
+    /** Décalage horizontal du plateau. */
-    private final int xBase = 60;
+    private final int xBase = 60;
-
+
-    /** Décalage vertical du plateau. */
+    /** Décalage vertical du plateau. */
-    private final int yBase = 60;
+    private final int yBase = 60;
-
+
-    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
+    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
-    private Runnable boardUpdateCallback;
+    private Runnable boardUpdateCallback;
-
+
-    //Constructeur
+    //Constructeur
-
+
-    /**
+    /**
-    * Construit la vue du plateau.
+    * Construit la vue du plateau.
-    *
+    *
-    * @param board moteur du jeu
+    * @param board moteur du jeu
-    * @param boardUpdateCallback callback à appeler après un coup
+    * @param boardUpdateCallback callback à appeler après un coup
-    */
+    */
-    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
+    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
-        this.board = board;
+        this.board = board;
-        this.boardUpdateCallback = boardUpdateCallback;
+        this.boardUpdateCallback = boardUpdateCallback;
-
+
-        setLayout(null);
+        setLayout(null);
-
+
-        // Contrôleur
+        // Contrôleur
-        this.controller = new InteractionController(board, this);
+        this.controller = new InteractionController(board, this);
-
+
-        // Couche fond
+        // Couche fond
-        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
+        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
-        backgroundLayer.setBounds(0, 0, 725, 725);
+        backgroundLayer.setBounds(0, 0, 725, 725);
-        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
+        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);
-
+
-        // Couche highlight
+        // Couche highlight
-        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
+        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
-        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
+        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
-
+
-        // Couche pièces
+        // Couche pièces
-        pieceLayer = new PieceLayer();
+        pieceLayer = new PieceLayer();
-        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
+        add(pieceLayer, JLayeredPane.PALETTE_LAYER);
-
+
-        setPreferredSize(new Dimension(725, 725));
+        setPreferredSize(new Dimension(725, 725));
-
+
-        refresh();
+        refresh();
-    }
+    }
-
+
-    //Méthodes
+    //Méthodes
-
+
-    /**
+    /**
-    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
+    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
-    *
+    *
-    * @return contrôleur
+    * @return contrôleur
-    */
+    */
-    public InteractionController getController() {
+    public InteractionController getController() {
-        return controller;
+        return controller;
-    }
+    }
-
+
-    /**
+    /**
-    * Active/désactive les interactions utilisateur sur le plateau.
+    * Active/désactive les interactions utilisateur sur le plateau.
-    * Utile pendant l'animation du bot pour éviter des clics concurrents.
+    * Utile pendant l'animation du bot pour éviter des clics concurrents.
-    *
+    *
-    * @param enabled true pour activer, false pour désactiver
+    * @param enabled true pour activer, false pour désactiver
-    */
+    */
-    public void setInteractionEnabled(boolean enabled) {
+    public void setInteractionEnabled(boolean enabled) {
-        // Désactive la couche des pièces (boutons) principalement
+        // Désactive la couche des pièces (boutons) principalement
-        pieceLayer.setEnabled(enabled);
+        pieceLayer.setEnabled(enabled);
-        for (Component c : pieceLayer.getComponents()) {
+        for (Component c : pieceLayer.getComponents()) {
-            c.setEnabled(enabled);
+            c.setEnabled(enabled);
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-    * Appelé par le contrôleur après un coup.
+    * Appelé par le contrôleur après un coup.
-    */
+    */
-    public void onBoardUpdated() {
+    public void onBoardUpdated() {
-        if (boardUpdateCallback != null) {
+        if (boardUpdateCallback != null) {
-            boardUpdateCallback.run();
+            boardUpdateCallback.run();
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-    * Rafraîchit les couches visuelles.
+    * Rafraîchit les couches visuelles.
-    */
+    */
-    public void refresh() {
+    public void refresh() {
-
+
-        pieceLayer.displayGrid(
+        pieceLayer.displayGrid(
-                boardGrid(),
+                boardGrid(),
-                xBase, yBase, spacing, size,
+                xBase, yBase, spacing, size,
-                (r, c) -> controller.onPieceClicked(r, c)
+                (r, c) -> controller.onPieceClicked(r, c)
-        );
+        );
-
+
-        highlightLayer.setLegalMoves(controller.getLegalMoves());
+        highlightLayer.setLegalMoves(controller.getLegalMoves());
-
+
-        backgroundLayer.repaint();
+        backgroundLayer.repaint();
-        highlightLayer.repaint();
+        highlightLayer.repaint();
-        pieceLayer.repaint();
+        pieceLayer.repaint();
-        repaint();
+        repaint();
-    }
+    }
-
+
-    /**
+    /**
-    * Récupère la grille depuis le moteur.
+    * Récupère la grille depuis le moteur.
-    *
+    *
-    * @return grille 9x9 de tours
+    * @return grille 9x9 de tours
-    */
+    */
-    private Tower[][] boardGrid() {
+    private Tower[][] boardGrid() {
-        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
+        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
-
+
-        for (int r = 0; r < AvalamBoard.SIZE; r++) {
+        for (int r = 0; r < AvalamBoard.SIZE; r++) {
-            for (int c = 0; c < AvalamBoard.SIZE; c++) {
+            for (int c = 0; c < AvalamBoard.SIZE; c++) {
-                grid[r][c] = board.getTowerAt(r, c);
+                grid[r][c] = board.getTowerAt(r, c);
-            }
+            }
-        }
+        }
-        return grid;
+        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,185 +1,22 @@
 package fr.iut_fbleau.Bot;
 
-import fr.iut_fbleau.Avalam.*;
+import fr.iut_fbleau.Avalam.AvalamBoard;
-import fr.iut_fbleau.GameAPI.*;
+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" (alpha-beta + évaluateur pondéré).
+ * Bot "Divin" (fort) pour Avalam.
- * * Idée :
+ *
- * - Utilise l'algorithme Alpha-Beta pour anticiper les coups.
+ *
- * - Évalue les plateaux non terminaux en accordant plus d'importance aux tours hautes.
+ * Objectif : trop fort. */
- */
+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

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