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

@@ -1,44 +0,0 @@
-package fr.iut_fbleau.Avalam;
-
-import fr.iut_fbleau.GameAPI.AbstractGame;
-import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
-import fr.iut_fbleau.GameAPI.IBoard;
-import fr.iut_fbleau.GameAPI.Player;
-
-import java.util.EnumMap;
-
-/**
- * Classe pour jouer une partie entre deux bots sans interface graphique.
- * Utilisée dans le mode Arène.
- * 
- * @version 1.0
- */
-public class ArenaGame extends AbstractGame {
-
-    /**
-     * Construit une partie Arène entre deux bots.
-     *
-     * @param board plateau initial
-     * @param bot1 bot pour PLAYER1
-     * @param bot2 bot pour PLAYER2
-     */
-    public ArenaGame(IBoard board, AbstractGamePlayer bot1, AbstractGamePlayer bot2) {
-        super(board, createPlayerMap(bot1, bot2));
-    }
-
-    /**
-     * Crée la map des joueurs pour AbstractGame.
-     *
-     * @param bot1 bot pour PLAYER1
-     * @param bot2 bot pour PLAYER2
-     * @return une EnumMap associant chaque Player à son bot
-     */
-    private static EnumMap<Player, AbstractGamePlayer> createPlayerMap(
-            AbstractGamePlayer bot1, AbstractGamePlayer bot2) {
-        EnumMap<Player, AbstractGamePlayer> map = new EnumMap<>(Player.class);
-        map.put(Player.PLAYER1, bot1);
-        map.put(Player.PLAYER2, bot2);
-        return map;
-    }
-}
-

fr/iut_fbleau/Avalam/ArenaWindow.java

@@ -1,280 +0,0 @@
-package fr.iut_fbleau.Avalam;
-
-import fr.iut_fbleau.Bot.AlphaBetaBot;
-import fr.iut_fbleau.Bot.IdiotBot;
-import fr.iut_fbleau.GameAPI.AbstractGamePlayer;
-import fr.iut_fbleau.GameAPI.Player;
-import fr.iut_fbleau.GameAPI.Result;
-
-import javax.swing.*;
-import javax.swing.table.DefaultTableModel;
-import java.awt.*;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * 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 {
-
-    /** Tableau affichant les résultats des parties. */
-    private JTable resultsTable;
-    
-    /** Modèle de données pour le tableau des résultats. */
-    private DefaultTableModel tableModel;
-    
-    /** Liste des résultats des parties (non utilisée actuellement). */
-    private List<String> results;
-
-    /**
-     * Construit la fenêtre Arène.
-     */
-    public ArenaWindow() {
-        super("Arène - Bot vs Bot");
-        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-        setLayout(new BorderLayout());
-
-        results = new ArrayList<>();
-
-        // Panneau de configuration
-        JPanel configPanel = createConfigPanel();
-        add(configPanel, BorderLayout.NORTH);
-
-        // Tableau des résultats
-        createResultsTable();
-        JScrollPane scrollPane = new JScrollPane(resultsTable);
-        add(scrollPane, BorderLayout.CENTER);
-
-        // Panneau des boutons
-        JPanel buttonPanel = new JPanel(new FlowLayout());
-        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);
-        
-        add(buttonPanel, BorderLayout.SOUTH);
-
-        pack();
-        setSize(600, 400);
-        setLocationRelativeTo(null);
-        setVisible(true);
-    }
-
-    /**
-     * Crée le panneau de configuration (pour l'instant vide, sera rempli par le dialogue).
-     *
-     * @return un JPanel contenant les informations de configuration
-     */
-    private JPanel createConfigPanel() {
-        JPanel panel = new JPanel();
-        panel.setBorder(BorderFactory.createTitledBorder("Configuration"));
-        panel.add(new JLabel("Utilisez le bouton 'Lancer les parties' pour configurer et démarrer."));
-        return panel;
-    }
-
-    /**
-     * Crée le tableau des résultats avec les colonnes : Partie, Bot 1, Bot 2, Gagnant.
-     */
-    private void createResultsTable() {
-        String[] columnNames = {"Partie", "Bot 1", "Bot 2", "Gagnant"};
-        tableModel = new DefaultTableModel(columnNames, 0) {
-            @Override
-            public boolean isCellEditable(int row, int column) {
-                return false;
-            }
-        };
-        resultsTable = new JTable(tableModel);
-        resultsTable.setFillsViewportHeight(true);
-    }
-
-    /**
-     * Affiche le dialogue de configuration et lance les parties.
-     */
-    private void showConfigDialog() {
-        // Choix du bot 1
-        String[] botTypes = {"Bot Idiot", "Bot Alpha-Beta", "Bot Divin"};
-        String bot1Choice = (String) JOptionPane.showInputDialog(
-                this,
-                "Choisissez le Bot 1 (Joueur 1) :",
-                "Configuration Arène - Bot 1",
-                JOptionPane.QUESTION_MESSAGE,
-                null,
-                botTypes,
-                botTypes[0]
-        );
-
-        if (bot1Choice == null) return;
-
-        // Choix du bot 2
-        String bot2Choice = (String) JOptionPane.showInputDialog(
-                this,
-                "Choisissez le Bot 2 (Joueur 2) :",
-                "Configuration Arène - Bot 2",
-                JOptionPane.QUESTION_MESSAGE,
-                null,
-                botTypes,
-                botTypes[0]
-        );
-
-        if (bot2Choice == null) return;
-
-        // Profondeur pour Alpha-Beta et Divin
-        int depth = 4;
-        if (bot1Choice.contains("Alpha") || bot1Choice.contains("Divin") ||
-            bot2Choice.contains("Alpha") || bot2Choice.contains("Divin")) {
-            String depthStr = JOptionPane.showInputDialog(
-                    this,
-                    "Profondeur de recherche pour les bots Alpha-Beta/Divin ?\n(Conseil: 4)",
-                    "Profondeur",
-                    JOptionPane.QUESTION_MESSAGE
-            );
-            if (depthStr != null) {
-                try {
-                    depth = Integer.parseInt(depthStr.trim());
-                    if (depth < 1) depth = 1;
-                } catch (Exception e) {
-                    depth = 4;
-                }
-            }
-        }
-
-        // Nombre de parties
-        String nbPartiesStr = JOptionPane.showInputDialog(
-                this,
-                "Combien de parties voulez-vous jouer ?",
-                "Nombre de parties",
-                JOptionPane.QUESTION_MESSAGE
-        );
-
-        if (nbPartiesStr == null) return;
-
-        int nbParties;
-        try {
-            nbParties = Integer.parseInt(nbPartiesStr.trim());
-            if (nbParties < 1) {
-                JOptionPane.showMessageDialog(this, "Le nombre de parties doit être au moins 1.");
-                return;
-            }
-        } catch (Exception e) {
-            JOptionPane.showMessageDialog(this, "Nombre invalide.");
-            return;
-        }
-
-        // Lancer les parties
-        runArena(bot1Choice, bot2Choice, depth, nbParties);
-    }
-
-    /**
-     * Lance les parties entre les deux bots.
-     * 
-     * @param bot1Type type du bot 1 (Joueur 1)
-     * @param bot2Type type du bot 2 (Joueur 2)
-     * @param depth profondeur de recherche pour les bots Alpha-Beta/Divin
-     * @param nbParties nombre de parties à jouer
-     */
-    private void runArena(String bot1Type, String bot2Type, int depth, int nbParties) {
-        // Créer les bots
-        AbstractGamePlayer bot1 = createBot(bot1Type, Player.PLAYER1, depth);
-        AbstractGamePlayer bot2 = createBot(bot2Type, Player.PLAYER2, depth);
-
-        if (bot1 == null || bot2 == null) {
-            JOptionPane.showMessageDialog(this, "Erreur lors de la création des bots.");
-            return;
-        }
-
-        // Vider le tableau
-        tableModel.setRowCount(0);
-        results.clear();
-
-        // Charger le plateau initial
-        Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
-
-        // Lancer les parties
-        for (int i = 1; i <= nbParties; i++) {
-            AvalamBoard board = new AvalamBoard(initialGrid, Player.PLAYER1);
-            ArenaGame game = new ArenaGame(board, bot1, bot2);
-
-            try {
-                Result result = game.run();
-                String winner = getWinnerName(result, bot1Type, bot2Type);
-                
-                // Ajouter au tableau
-                tableModel.addRow(new Object[]{
-                        "Partie " + i,
-                        bot1Type,
-                        bot2Type,
-                        winner
-                });
-            } catch (Exception e) {
-                tableModel.addRow(new Object[]{
-                        "Partie " + i,
-                        bot1Type,
-                        bot2Type,
-                        "Erreur: " + e.getMessage()
-                });
-            }
-        }
-
-        // Afficher un message de fin
-        JOptionPane.showMessageDialog(
-                this,
-                "Toutes les parties sont terminées !",
-                "Arène terminée",
-                JOptionPane.INFORMATION_MESSAGE
-        );
-    }
-
-    /**
-     * Crée un bot selon son type.
-     *
-     * @param botType type de bot ("Bot Idiot", "Bot Alpha-Beta", "Bot Divin")
-     * @param player joueur contrôlé par ce bot (PLAYER1 ou PLAYER2)
-     * @param depth profondeur de recherche pour Alpha-Beta/Divin
-     * @return une instance de AbstractGamePlayer correspondant au type, ou null si le type est invalide
-     */
-    private AbstractGamePlayer createBot(String botType, Player player, int depth) {
-        if (botType.equals("Bot Idiot")) {
-            return new IdiotBot(player);
-        } else if (botType.equals("Bot Alpha-Beta")) {
-            return new AlphaBetaBot(player, depth);
-        } else if (botType.equals("Bot Divin")) {
-            // 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;
-    }
-
-    /**
-     * Détermine le nom du gagnant selon le résultat.
-     * 
-     * @param result résultat de la partie (WIN, LOSS, ou DRAW du point de vue de PLAYER1)
-     * @param bot1Type nom du bot 1
-     * @param bot2Type nom du bot 2
-     * @return une chaîne indiquant le gagnant ou "Match nul"
-     */
-    private String getWinnerName(Result result, String bot1Type, String bot2Type) {
-        if (result == Result.WIN) {
-            return bot1Type + " (Joueur 1)";
-        } else if (result == Result.LOSS) {
-            return bot2Type + " (Joueur 2)";
-        } else {
-            return "Match nul";
-        }
-    }
-}
-

fr/iut_fbleau/Avalam/GameMode.java

@@ -7,6 +7,5 @@ public enum GameMode {
     PVP,        // joueur vs joueur
     PVBOT,      // joueur vs bot idiot
     PVALPHA,     // joueur vs bot alpha
-    PVGOD,       // joueur vs bot stratégique
+    PVGOD       // joueur vs bot stratégique
-    ARENA       // bot vs bot (mode arène)
 }

fr/iut_fbleau/Avalam/Main.java

@@ -8,22 +8,14 @@ import javax.swing.*;
 public class Main {
 
     public static void main(String[] args) {
-        SwingUtilities.invokeLater(() -> {
-            showModeSelection();
-        });
-    }
 
-    /**
+        SwingUtilities.invokeLater(() -> {
-     * Affiche le menu de sélection du mode de jeu.
+
-     * Peut être appelé depuis d'autres fenêtres pour revenir au menu.
-     */
-    public static void showModeSelection() {
             String[] options = {
                     "joueur vs joueur",
                     "joueur vs botidiot",
                     "joueur vs bot alpha",
-                "joueur vs bot divin (NON IMPLEMENTE)",
+                    "joueur vs bot divin (NON IMPLEMENTE)"
-                "Arène"
             };
 
             int choice = JOptionPane.showOptionDialog(
@@ -39,12 +31,6 @@ public class Main {
 
             if (choice == -1) System.exit(0);
 
-        // Mode Arène
-        if (choice == 4) {
-            new ArenaWindow();
-            return;
-        }
-
             GameMode mode;
             if (choice == 1) mode = GameMode.PVBOT;
             else if (choice == 2) mode = GameMode.PVALPHA;
@@ -78,5 +64,6 @@ public class Main {
             }
 
             new AvalamWindow(mode);
+        });
     }
 }

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