Ajout vérification correspondance du Joueur (Test Ok)

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/ArenaWindow.java

@@ -1,7 +1,6 @@
 package fr.iut_fbleau.Avalam;
 
 import fr.iut_fbleau.Bot.AlphaBetaBot;
-import fr.iut_fbleau.Bot.DivineBot;
 import fr.iut_fbleau.Bot.IdiotBot;
 import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
 import fr.iut_fbleau.GameAPI.Player;
@@ -14,14 +13,10 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Fenêtre pour le mode Arène (bots vs bots).
- *
- * Elle permet :
- * - de sélectionner deux bots parmi Idiot, Alpha-Beta et Divin ;
- * - de configurer la profondeur de recherche pour les bots intelligents ;
- * - de choisir le nombre de parties à jouer ;
- * - d’afficher, dans un tableau, le résultat de chaque partie (gagnant ou erreur) ;
- * - de revenir au menu principal ou de quitter entièrement le jeu.
+ * Fenêtre pour le mode Arène.
+ * Permet de sélectionner deux bots, le nombre de parties, et affiche les résultats.
+ * 
+ * @version 1.0
  */
 public class ArenaWindow extends JFrame {
 
@@ -58,19 +53,14 @@ public class ArenaWindow extends JFrame {
         JButton startButton = new JButton("Lancer les parties");
         startButton.addActionListener(e -> showConfigDialog());
         buttonPanel.add(startButton);
-
+        
         JButton backButton = new JButton("Retour au menu");
         backButton.addActionListener(e -> {
             dispose(); // Ferme la fenêtre Arène
             Main.showModeSelection(); // Affiche le menu principal
         });
         buttonPanel.add(backButton);
-
-        // Nouveau bouton pour quitter entièrement le jeu
-        JButton quitButton = new JButton("Quitter");
-        quitButton.addActionListener(e -> System.exit(0));
-        buttonPanel.add(quitButton);
-
+        
         add(buttonPanel, BorderLayout.SOUTH);
 
         pack();
@@ -234,22 +224,13 @@ public class ArenaWindow extends JFrame {
             }
         }
 
-        // Afficher un message de fin avec possibilité de quitter directement
-        Object[] options = {"OK", "Quitter le jeu"};
-        int choice = JOptionPane.showOptionDialog(
+        // Afficher un message de fin
+        JOptionPane.showMessageDialog(
                 this,
                 "Toutes les parties sont terminées !",
                 "Arène terminée",
-                JOptionPane.DEFAULT_OPTION,
-                JOptionPane.INFORMATION_MESSAGE,
-                null,
-                options,
-                options[0]
+                JOptionPane.INFORMATION_MESSAGE
         );
-
-        if (choice == 1) {
-            System.exit(0);
-        }
     }
 
     /**
@@ -266,7 +247,14 @@ public class ArenaWindow extends JFrame {
         } else if (botType.equals("Bot Alpha-Beta")) {
             return new AlphaBetaBot(player, depth);
         } else if (botType.equals("Bot Divin")) {
-            return new DivineBot(player, depth);
+            // Pour l'instant, le Bot Divin n'est pas implémenté, on utilise IdiotBot
+            JOptionPane.showMessageDialog(
+                    this,
+                    "Le Bot Divin n'est pas encore implémenté. Utilisation du Bot Idiot à la place.",
+                    "Avertissement",
+                    JOptionPane.WARNING_MESSAGE
+            );
+            return new IdiotBot(player);
         }
         return null;
     }

fr/iut_fbleau/Avalam/AvalamBoard.java

@@ -205,6 +205,7 @@ public class AvalamBoard extends AbstractBoard {
         Tower dst = grid[xT][yT];
         if (src == null || dst == null) return false;
 
+        if (p.getPlayer() != getCurrentPlayer()) return false;
         if (src.getColor() != colorForPlayer(getCurrentPlayer())) return false;
         if (!areAdjacent(xF, yF, xT, yT)) return false;
         if (src.getColor() == dst.getColor()) return false;

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -1,6 +1,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.IdiotBot;
 import fr.iut_fbleau.GameAPI.AbstractPly;
@@ -13,25 +14,22 @@ import java.awt.*;
 /**
  * La classe <code>AvalamWindow</code>
  *
- * Fenêtre principale (interface graphique) du jeu Avalam pour tous les modes
- * hors Arène :
- * - joueur vs joueur (PVP)
- * - joueur vs bot idiot (PVBOT)
- * - joueur vs bot alpha (PVALPHA)
+ * Fenêtre principale (interface graphique) du jeu Avalam.
+ * Elle contient :
+ * - le plateau (BoardView)
+ * - l’affichage du score (ScoreView)
+ * - l’affichage du joueur courant (TurnView)
+ *
+ * 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)
  *
- * Elle contient :
- * - le plateau (<code>BoardView</code>)
- * - l’affichage du score (<code>ScoreView</code>)
- * - l’affichage du joueur courant (<code>TurnView</code>)
- *
- * Elle pilote un objet <code>AvalamBoard</code> (moteur du jeu) et,
- * en fonction du {@link GameMode}, instancie le bot approprié
- * (idiot, alpha-bêta ou divin).
- *
- * En fin de partie, elle ouvre une fenêtre de fin (<code>EndGameDialog</code>)
- * affichant le gagnant, les scores et proposant les actions :
- * « Rejouer », « Menu principal » ou « Quitter le jeu ».
+ * @version 1.0
+ * Date :
+ * Licence :
  */
 public class AvalamWindow extends JFrame {
 
@@ -52,9 +50,6 @@ public class AvalamWindow extends JFrame {
     /** Mode de jeu sélectionné. */
     private final GameMode mode;
 
-    /** Profondeur de recherche utilisée (utile pour les modes avec bot intelligent et pour rejouer). */
-    private final int searchDepth;
-
     /** Joueur contrôlé par le bot (si actif). */
     private final Player botPlayer = Player.PLAYER2;
 
@@ -64,9 +59,18 @@ public class AvalamWindow extends JFrame {
     /** Bot Alpha-Beta (utilisé si mode PVALPHA). */
     private final AlphaBetaBot alphaBot;
 
-    /** Bot Divin (utilisé si mode PVGOD). */
     private final DivineBot divineBot;
 
+    // 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.
+     */
+
     /** Indique si une animation de tour de bot est en cours. */
     private boolean botAnimating = false;
 
@@ -83,7 +87,7 @@ public class AvalamWindow extends JFrame {
      * Construit la fenêtre en fonction du mode choisi.
      * Pour PVALPHA/PVGOD, la profondeur par défaut est 4.
      *
-     * @param mode mode de jeu (PVP, PVBOT, PVALPHA ou PVGOD)
+     * @param mode mode de jeu
      */
     public AvalamWindow(GameMode mode) {
         this(mode, 4);
@@ -91,23 +95,22 @@ public class AvalamWindow extends JFrame {
 
     /**
      * Construit la fenêtre en fonction du mode choisi.
-     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off
-     * pour les bots Alpha-Beta et Divin.
+     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off.
      *
-     * @param mode       mode de jeu
+     * @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.searchDepth = Math.max(1, alphaDepth);
 
         this.idiotBot = (mode == GameMode.PVBOT) ? new IdiotBot(botPlayer) : null;
 
-        int depth = this.searchDepth;
+        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);
@@ -166,30 +169,28 @@ public class AvalamWindow extends JFrame {
         if (board.isGameOver()) {
             Result res = board.getResult();
 
-            int scoreJaune = computeScore(Color.YELLOW);
-            int scoreRouge = computeScore(Color.RED);
+            String msg;
+            switch (res) {
+                case WIN:
+                    msg = "Le joueur jaune a gagné !";
+                    break;
+                case LOSS:
+                    msg = "Le joueur rouge a gagné !";
+                    break;
+                case DRAW:
+                    msg = "Égalité !";
+                    break;
+                default:
+                    msg = "Fin de partie.";
+                    break;
+            }
 
-            EndGameDialog dialog = new EndGameDialog(
+            JOptionPane.showMessageDialog(
                     this,
-                    res,
-                    scoreJaune,
-                    scoreRouge,
-                    mode,
-                    searchDepth,
-                    // Rejouer : on ferme la fenêtre actuelle et on relance une nouvelle partie avec le même mode/profondeur
-                    () -> SwingUtilities.invokeLater(() -> {
-                        dispose();
-                        new AvalamWindow(mode, searchDepth);
-                    }),
-                    // Menu principal : on ferme la fenêtre actuelle et on réaffiche le menu de mode de jeu
-                    () -> SwingUtilities.invokeLater(() -> {
-                        dispose();
-                        Main.showModeSelection();
-                    }),
-                    // Quitter complètement l'application
-                    () -> System.exit(0)
+                    msg,
+                    "Partie terminée",
+                    JOptionPane.INFORMATION_MESSAGE
             );
-            dialog.setVisible(true);
             return;
         }
 
@@ -219,8 +220,12 @@ public class AvalamWindow extends JFrame {
         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.
+
         botAnimating = true;
 
         // Désactiver les interactions du joueur pendant le tour du bot.

fr/iut_fbleau/Avalam/EndGameDialog.java

@@ -1,160 +0,0 @@
-package fr.iut_fbleau.Avalam;
-
-import fr.iut_fbleau.GameAPI.Result;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
- * Fenêtre de fin de partie.
- *
- * Elle est ouverte par {@link AvalamWindow} lorsque le moteur signale
- * que la partie est terminée. Elle affiche :
- * - le résultat (gagnant ou égalité) à partir du {@link Result} ;
- * - le score détaillé (tours contrôlées par Jaune et Rouge) ;
- * - le mode de jeu courant (PVP, PVBOT, PVALPHA, PVGOD, avec profondeur pour les bots intelligents).
- *
- * Elle propose également trois actions sous forme de boutons :
- * - « Rejouer » : relancer une partie avec la même configuration ;
- * - « Menu principal » : retourner au menu de sélection de mode ;
- * - « Quitter » : fermer complètement l’application.
- */
-public class EndGameDialog extends JDialog {
-
-    /**
-     * Construit la fenêtre de fin de partie.
-     *
-     * @param parent     fenêtre principale (généralement une {@link AvalamWindow})
-     * @param result     résultat de la partie (WIN / LOSS / DRAW du point de vue de PLAYER1 / Jaune)
-     * @param scoreJaune score du joueur jaune (nombre de tours contrôlées)
-     * @param scoreRouge score du joueur rouge (nombre de tours contrôlées)
-     * @param mode       mode de jeu courant (pour l’information et le « Rejouer »)
-     * @param depth      profondeur utilisée (pour les modes avec bot intelligent)
-     * @param onReplay   action à exécuter lorsque l’utilisateur clique sur « Rejouer »
-     * @param onMenu     action à exécuter lorsque l’utilisateur clique sur « Menu principal »
-     * @param onQuit     action à exécuter lorsque l’utilisateur clique sur « Quitter »
-     */
-    public EndGameDialog(
-            JFrame parent,
-            Result result,
-            int scoreJaune,
-            int scoreRouge,
-            GameMode mode,
-            int depth,
-            Runnable onReplay,
-            Runnable onMenu,
-            Runnable onQuit
-    ) {
-        super(parent, "Fin de partie", true);
-
-        setLayout(new BorderLayout(10, 10));
-
-        // Panel principal d'information
-        JPanel infoPanel = new JPanel();
-        infoPanel.setLayout(new BoxLayout(infoPanel, BoxLayout.Y_AXIS));
-        infoPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
-
-        JLabel titre = new JLabel("Partie terminée");
-        titre.setFont(titre.getFont().deriveFont(Font.BOLD, 18f));
-        titre.setAlignmentX(Component.CENTER_ALIGNMENT);
-
-        String gagnant;
-        switch (result) {
-            case WIN:
-                gagnant = "Le joueur JAUNE a gagné !";
-                break;
-            case LOSS:
-                gagnant = "Le joueur ROUGE a gagné !";
-                break;
-            case DRAW:
-                gagnant = "Égalité parfaite !";
-                break;
-            default:
-                gagnant = "Fin de partie.";
-        }
-
-        JLabel gagnantLabel = new JLabel(gagnant);
-        gagnantLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
-
-        JLabel scoreLabel = new JLabel(
-                "Score - Jaune : " + scoreJaune + " | Rouge : " + scoreRouge
-        );
-        scoreLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
-
-        JLabel modeLabel = new JLabel("Mode : " + modeToString(mode, depth));
-        modeLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
-
-        infoPanel.add(titre);
-        infoPanel.add(Box.createVerticalStrut(10));
-        infoPanel.add(gagnantLabel);
-        infoPanel.add(Box.createVerticalStrut(5));
-        infoPanel.add(scoreLabel);
-        infoPanel.add(Box.createVerticalStrut(5));
-        infoPanel.add(modeLabel);
-
-        add(infoPanel, BorderLayout.CENTER);
-
-        // Panel des boutons d'action
-        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 15, 10));
-
-        JButton replayButton = new JButton("Rejouer");
-        replayButton.addActionListener(e -> {
-            if (onReplay != null) {
-                onReplay.run();
-            }
-            dispose();
-        });
-
-        JButton menuButton = new JButton("Menu principal");
-        menuButton.addActionListener(e -> {
-            if (onMenu != null) {
-                onMenu.run();
-            }
-            dispose();
-        });
-
-        JButton quitButton = new JButton("Quitter");
-        quitButton.addActionListener(e -> {
-            if (onQuit != null) {
-                onQuit.run();
-            }
-            dispose();
-        });
-
-        buttonPanel.add(replayButton);
-        buttonPanel.add(menuButton);
-        buttonPanel.add(quitButton);
-
-        add(buttonPanel, BorderLayout.SOUTH);
-
-        pack();
-        setResizable(false);
-        setLocationRelativeTo(parent);
-    }
-
-    /**
-     * Retourne une description lisible du mode de jeu courant.
-     *
-     * @param mode  mode de jeu
-     * @param depth profondeur (pour les bots intelligents)
-     * @return chaîne décrivant le mode
-     */
-    private String modeToString(GameMode mode, int depth) {
-        switch (mode) {
-            case PVP:
-                return "Joueur vs Joueur";
-            case PVBOT:
-                return "Joueur vs Bot idiot";
-            case PVALPHA:
-                return "Joueur vs Bot Alpha (profondeur " + depth + ")";
-            case PVGOD:
-                return "Joueur vs Bot Divin (profondeur " + depth + ")";
-            case ARENA:
-                return "Arène (bots)"; // normalement non utilisé ici
-            default:
-                return mode.name();
-        }
-    }
-}
-
-

fr/iut_fbleau/Avalam/Main.java

@@ -22,7 +22,7 @@ public class Main {
                 "joueur vs joueur",
                 "joueur vs botidiot",
                 "joueur vs bot alpha",
-                "joueur vs bot divin",
+                "joueur vs bot divin (NON IMPLEMENTE)",
                 "Arène"
         };
 

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