j'avais oublié de faire la javadoc

Reviewed-on: #17

fr/iut_fbleau/Avalam/ArenaGame.java

@@ -0,0 +1,44 @@
+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

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

@@ -280,12 +280,23 @@ public class AvalamBoard extends AbstractBoard {
     */
     @Override
     public IBoard safeCopy() {
+
         Tower[][] newGrid = new Tower[SIZE][SIZE];
 
-        for (int r = 0; r < SIZE; r++)
-            for (int c = 0; c < SIZE; c++)
-                newGrid[r][c] = grid[r][c];
+        for (int r = 0; r < SIZE; r++) {
+            for (int c = 0; c < SIZE; c++) {
 
-        return new AvalamBoard(newGrid, getCurrentPlayer(), gameOver, result);
+                Tower t = grid[r][c];
+                if (t == null) {
+                    newGrid[r][c] = null;
+                } else {
+                    // Copie profonde : on recrée une nouvelle Tower indépendante
+                    newGrid[r][c] = new Tower(t.getHeight(), t.getColor());
+                }
+            }
+        }
+
+        // On conserve le joueur courant
+        return new AvalamBoard(newGrid, getCurrentPlayer());
     }
 }

fr/iut_fbleau/Avalam/AvalamWindow.java

@@ -1,5 +1,8 @@
 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;
 import fr.iut_fbleau.GameAPI.Player;
@@ -9,24 +12,25 @@ import javax.swing.*;
 import java.awt.*;
 
 /**
-* La classe <code>AvalamWindow</code>
-*
-* 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 (préparé)
-*
-* @version 1.0
-* Date :
-* Licence :
-*/
+ * La classe <code>AvalamWindow</code>
+ *
+ * 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)
+ *
+ * @version 1.0
+ * Date :
+ * Licence :
+ */
 public class AvalamWindow extends JFrame {
 
     //Attributs
@@ -52,29 +56,62 @@ public class AvalamWindow extends JFrame {
     /** Bot idiot (utilisé si mode PVBOT). */
     private final IdiotBot idiotBot;
 
+    /** Bot Alpha-Beta (utilisé si mode PVALPHA). */
+    private final AlphaBetaBot alphaBot;
+
+    // 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.
+     */
+    private final Object divineBot = null;
+
     /** Indique si une animation de tour de bot est en cours. */
     private boolean botAnimating = false;
 
     //Constructeur
 
     /**
-    * Construit la fenêtre en mode joueur vs joueur.
-    */
+     * Construit la fenêtre en mode joueur vs joueur.
+     */
     public AvalamWindow() {
-        this(GameMode.PVP);
+        this(GameMode.PVP, 4);
     }
 
     /**
-    * Construit la fenêtre en fonction du mode choisi.
-    *
-    * @param mode mode de jeu
-    */
+     * Construit la fenêtre en fonction du mode choisi.
+     * Pour PVALPHA/PVGOD, la profondeur par défaut est 4.
+     *
+     * @param mode mode de jeu
+     */
     public AvalamWindow(GameMode mode) {
+        this(mode, 4);
+    }
+
+    /**
+     * Construit la fenêtre en fonction du mode choisi.
+     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off.
+     *
+     * @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.idiotBot = (mode == GameMode.PVBOT) ? new IdiotBot(botPlayer) : null;
 
+        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);
         setLayout(new BorderLayout());
 
@@ -109,16 +146,16 @@ public class AvalamWindow extends JFrame {
         setLocationRelativeTo(null);
         setVisible(true);
 
-        // Si un jour le bot doit commencer, on peut déclencher ici.
+        // Si un jour le bot devait commencer (pas le cas ici), on le ferait jouer ici.
         maybePlayBotTurn();
     }
 
     //Méthodes
 
     /**
-    * Appelée après chaque coup (humain ou bot).
-    * Met à jour score, tour, et affiche la fin de partie.
-    */
+     * Appelée après chaque coup (humain ou bot).
+     * Met à jour score, tour, et affiche la fin de partie.
+     */
     public void onBoardUpdated() {
 
         scoreView.updateScores(
@@ -161,27 +198,51 @@ public class AvalamWindow extends JFrame {
     }
 
     /**
-    * Fait jouer le bot en deux étapes visibles :
-    * 1) sélection de la tour (affiche les coups légaux)
-    * 2) attente 1 seconde
-    * 3) déplacement vers la destination
-    *
-    * Le tout sans bloquer l'interface (Timer Swing).
-    */
+     * Fait jouer le bot (idiot / alpha / divin) en deux étapes visibles :
+     * 1) sélection de la tour (affiche les coups légaux)
+     * 2) attente 1 seconde
+     * 3) déplacement vers la destination
+     *
+     * Le tout sans bloquer l'interface (Timer Swing).
+     */
     private void maybePlayBotTurn() {
 
-        if (mode != GameMode.PVBOT) return;
+        // Mode joueur vs joueur : aucun bot
+        if (mode == GameMode.PVP) return;
+
+        // Sécurité
         if (board.isGameOver()) return;
         if (board.getCurrentPlayer() != botPlayer) return;
         if (botAnimating) return;
 
+        // Vérifier qu'on a bien le bot correspondant
+        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.
+        if (mode == GameMode.PVGOD) return;
+
         botAnimating = true;
 
         // Désactiver les interactions du joueur pendant le tour du bot.
         boardView.setInteractionEnabled(false);
 
         // Choix d’un coup sur une copie sûre
-        AbstractPly botMove = idiotBot.giveYourMove(board.safeCopy());
+        AbstractPly botMove;
+        if (mode == GameMode.PVBOT) {
+            botMove = idiotBot.giveYourMove(board.safeCopy());
+        } else if (mode == GameMode.PVALPHA) {
+            botMove = alphaBot.giveYourMove(board.safeCopy());
+        } else {
+            // A FAIRE PLUS TARD (PVGOD)
+            // botMove = divineBot.giveYourMove(board.safeCopy());
+            botMove = null;
+        }
+
         if (botMove == null) {
             botAnimating = false;
             boardView.setInteractionEnabled(true);
@@ -226,11 +287,11 @@ public class AvalamWindow extends JFrame {
     }
 
     /**
-    * Calcule le score d'une couleur : nombre de tours contrôlées.
-    *
-    * @param c couleur à compter
-    * @return nombre de tours appartenant à la couleur c
-    */
+     * Calcule le score d'une couleur : nombre de tours contrôlées.
+     *
+     * @param c couleur à compter
+     * @return nombre de tours appartenant à la couleur c
+     */
     private int computeScore(Color c) {
         int score = 0;
         for (int r = 0; r < AvalamBoard.SIZE; r++) {
@@ -245,10 +306,10 @@ public class AvalamWindow extends JFrame {
     }
 
     /**
-    * Retourne le message affiché pour le joueur courant.
-    *
-    * @return message du tour
-    */
+     * Retourne le message affiché pour le joueur courant.
+     *
+     * @return message du tour
+     */
     private String turnMessage() {
         return "Tour du joueur : " +
                 (board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge");

fr/iut_fbleau/Avalam/GameMode.java

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

fr/iut_fbleau/Avalam/Main.java

@@ -8,43 +8,75 @@ import javax.swing.*;
 public class Main {
 
     public static void main(String[] args) {
-
         SwingUtilities.invokeLater(() -> {
-
-            String[] options = {
-                    "joueur vs joueur",
-                    "joueur vs botidiot",
-                    "joueur vs bot alpha"
-            };
-
-            int choice = JOptionPane.showOptionDialog(
-                    null,
-                    "Choisissez un mode de jeu :",
-                    "Avalam - Mode de jeu",
-                    JOptionPane.DEFAULT_OPTION,
-                    JOptionPane.QUESTION_MESSAGE,
-                    null,
-                    options,
-                    options[0]
-            );
-
-            GameMode mode;
-            if (choice == 1) mode = GameMode.PVBOT;
-            else if (choice == 2) mode = GameMode.PVALPHA;
-            else mode = GameMode.PVP;
-
-            // Si alpha choisi : non implémenté, on prévient et on lance en PVP (préparation).
-            if (mode == GameMode.PVALPHA) {
-                JOptionPane.showMessageDialog(
-                        null,
-                        "Bot Alpha-Beta non implémenté pour l'instant.\nLancement en joueur vs joueur.",
-                        "Information",
-                        JOptionPane.INFORMATION_MESSAGE
-                );
-                mode = GameMode.PVP;
-            }
-
-            new AvalamWindow(mode);
+            showModeSelection();
         });
     }
+
+    /**
+     * 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)",
+                "Arène"
+        };
+
+        int choice = JOptionPane.showOptionDialog(
+                null,
+                "Choisissez un mode de jeu :",
+                "Avalam - Mode de jeu",
+                JOptionPane.DEFAULT_OPTION,
+                JOptionPane.QUESTION_MESSAGE,
+                null,
+                options,
+                options[0]
+        );
+
+        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;
+        else if (choice == 3) mode = GameMode.PVGOD;
+        else mode = GameMode.PVP;
+
+        // Pour ALPHA et GOD : demander une profondeur
+        if (mode == GameMode.PVALPHA || mode == GameMode.PVGOD) {
+
+            String s = JOptionPane.showInputDialog(
+                    null,
+                    "Profondeur de recherche ?\n(Conseil 4)",
+                    (mode == GameMode.PVGOD ? "Bot Divin (PVGOD)" : "Bot Alpha-Beta"),
+                    JOptionPane.QUESTION_MESSAGE
+            );
+
+            int depth = 4; // défaut
+            if (s != null) {
+                try { depth = Integer.parseInt(s.trim()); }
+                catch (Exception ignored) { depth = 4; }
+            } else {
+                // Annulation : on revient en PVP
+                new AvalamWindow(GameMode.PVP);
+                return;
+            }
+
+            if (depth < 1) depth = 1;
+
+            new AvalamWindow(mode, depth);
+            return;
+        }
+
+        new AvalamWindow(mode);
+    }
 }

fr/iut_fbleau/Bot/AlphaBetaBot.java

@@ -1,22 +1,217 @@
 package fr.iut_fbleau.Bot;
 
+import fr.iut_fbleau.Avalam.AvalamBoard;
+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.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
 
 /**
- * Bot Alpha-Beta (préparé).
- * Pour l'instant non implémenté.
+ * Bot Alpha-Beta avec cut-off (profondeur maximale).
+ *
+ * Idée :
+ * - si on atteint la profondeur limite, on évalue la position (heuristique).
+ * - sinon, on explore les coups avec Alpha-Beta (minimax optimisé).
+ *
+ * 
  */
 public class AlphaBetaBot extends AbstractGamePlayer {
 
-    public AlphaBetaBot(Player p) {
+    //Attributs
+
+    /** Joueur contrôlé par ce bot (PLAYER1 ou PLAYER2). */
+    private final Player me;
+
+    /** Profondeur maximale de recherche (cut-off). */
+    private final int maxDepth;
+
+    /** Générateur aléatoire pour départager des coups de même valeur. */
+    private final Random rng = new Random();
+
+    //Constructeur
+
+    /**
+     * Construit un bot Alpha-Beta.
+     *
+     * @param p joueur contrôlé par ce bot
+     * @param maxDepth profondeur maximale de recherche
+     */
+    public AlphaBetaBot(Player p, int maxDepth) {
         super(p);
+        this.me = p;
+        this.maxDepth = Math.max(1, maxDepth);
     }
 
+    //Méthodes
+
+    /**
+     * Méthode appelée par GameAPI : le bot doit choisir un coup.
+     *
+     * @param board copie sûre de l'état de jeu (IBoard)
+     * @return un coup (AbstractPly) ou null si aucun coup possible
+     */
     @Override
     public AbstractPly giveYourMove(IBoard board) {
-        throw new UnsupportedOperationException("AlphaBetaBot non implémenté pour l'instant.");
+
+        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()));
     }
+
+    /**
+     * Fonction récursive 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);
+        }
+
+        boolean isMax = (board.getCurrentPlayer() == me);
+
+        List<AbstractPly> moves = listMoves(board);
+        if (moves.isEmpty()) {
+            return evaluate(board);
+        }
+
+        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;
+        }
+    }
+
+    /**
+     * Convertit le résultat final en valeur très grande (victoire/défaite).
+     * Result est du point de vue de PLAYER1.
+     */
+    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;
+        }
+    }
+
+    /**
+     * Heuristique simple Avalam :
+     * score = (tours du bot) - (tours adverses)
+     */
+    private int evaluate(IBoard board) {
+
+        if (!(board instanceof AvalamBoard)) return 0;
+        AvalamBoard b = (AvalamBoard) board;
+
+        Color botColor = (me == Player.PLAYER1) ? Color.YELLOW : Color.RED;
+        Color oppColor = (me == Player.PLAYER1) ? Color.RED : Color.YELLOW;
+
+        int botTowers = 0;
+        int oppTowers = 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;
+
+                if (t.getColor() == botColor) botTowers++;
+                else if (t.getColor() == oppColor) oppTowers++;
+            }
+        }
+
+        return botTowers - oppTowers;
+    }
+
+    /**
+     * Récupère tous les coups légaux via iterator().
+     */
+    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;
+    }
+
+    //Affichage
 }

fr/iut_fbleau/Bot/DivineBot.java

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.Bot;
+
+import fr.iut_fbleau.Avalam.AvalamBoard;
+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" (fort) pour Avalam.
+ *
+ *
+ * Objectif : trop fort. */
+public class DivineBot{
+
+}