Bot Divin et AvalamWindow connecté

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,292 +0,0 @@
-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;
-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 (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.
- */
-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);
-
-        // 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();
-        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 avec possibilité de quitter directement
-        Object[] options = {"OK", "Quitter le jeu"};
-        int choice = JOptionPane.showOptionDialog(
-                this,
-                "Toutes les parties sont terminées !",
-                "Arène terminée",
-                JOptionPane.DEFAULT_OPTION,
-                JOptionPane.INFORMATION_MESSAGE,
-                null,
-                options,
-                options[0]
-        );
-
-        if (choice == 1) {
-            System.exit(0);
-        }
-    }
-
-    /**
-     * 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")) {
-            return new DivineBot(player, depth);
-        }
-        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/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
+ * Fenêtre principale (interface graphique) du jeu Avalam.
- * hors Arène :
+ * Elle contient :
- * - joueur vs joueur (PVP)
+ * - le plateau (BoardView)
- * - joueur vs bot idiot (PVBOT)
+ * - l’affichage du score (ScoreView)
- * - joueur vs bot alpha (PVALPHA)
+ * - 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 :
+ * @version 1.0
- * - le plateau (<code>BoardView</code>)
+ * Date :
- * - l’affichage du score (<code>ScoreView</code>)
+ * Licence :
- * - 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 ».
  */
 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
+     * Si le mode est PVALPHA ou PVGOD, la profondeur est utilisée comme cut-off.
-     * pour les bots Alpha-Beta et Divin.
      *
-     * @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);
+            String msg;
-            int scoreRouge = computeScore(Color.RED);
+            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,
+                    msg,
-                    scoreJaune,
+                    "Partie terminée",
-                    scoreRouge,
+                    JOptionPane.INFORMATION_MESSAGE
-                    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)
             );
-            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/BackgroundLayer.java

@@ -1,37 +0,0 @@
-package fr.iut_fbleau.Avalam;
-
-import javax.swing.*;
-import java.awt.*;
-
-/**
-* La classe <code>BackgroundLayer</code>
-* 
-* Sous composant de BoardView affichant l’image de fond.
-*/
-public class BackgroundLayer extends JComponent {
-    private Image img;
-
-    /**
-    * Construit une couche de fond.
-    *
-    * @param resourcePath chemin de l'image de fond
-    */
-    public BackgroundLayer(String resourcePath) {
-        img = Toolkit.getDefaultToolkit().getImage(
-                getClass().getClassLoader().getResource(resourcePath)
-        );
-    }
-
-    /**
-    * Dessine l'image de fond.
-    *
-    * @param g contexte graphique
-    */
-    @Override
-    protected void paintComponent(Graphics g) {
-        super.paintComponent(g);
-        if (img != null) {
-            g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
-        }
-    }
-}

fr/iut_fbleau/Avalam/BoardView.java

@@ -10,7 +10,7 @@ import java.awt.*;
 * Elle gère :
 * - l’affichage des tours (PieceLayer)
 * - l’affichage des coups possibles (HighlightLayer)
-* - l’affichage du fond graphique (BackgroundLayer)
+* - l’affichage du fond graphique
 * - les clics via InteractionController
 *
 * Cette classe ne contient aucune logique de règles du jeu.
@@ -156,4 +156,37 @@ public class BoardView extends JLayeredPane {
         }
         return grid;
     }
+
+    //Affichage
+
+    /**
+    * Composant affichant l’image de fond.
+    */
+    private static class BackgroundLayer extends JComponent {
+        private Image img;
+
+        /**
+        * Construit une couche de fond.
+        *
+        * @param resourcePath chemin de l'image de fond
+        */
+        public BackgroundLayer(String resourcePath) {
+            img = Toolkit.getDefaultToolkit().getImage(
+                    getClass().getClassLoader().getResource(resourcePath)
+            );
+        }
+
+        /**
+        * Dessine l'image de fond.
+        *
+        * @param g contexte graphique
+        */
+        @Override
+        protected void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            if (img != null) {
+                g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
+            }
+        }
+    }
 }

fr/iut_fbleau/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/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,75 +8,62 @@ import javax.swing.*;
 public class Main {
 
     public static void main(String[] args) {
+
         SwingUtilities.invokeLater(() -> {
-            showModeSelection();
-        });
-    }
 
-    /**
+            String[] options = {
-     * Affiche le menu de sélection du mode de jeu.
+                    "joueur vs joueur",
-     * Peut être appelé depuis d'autres fenêtres pour revenir au menu.
+                    "joueur vs botidiot",
-     */
+                    "joueur vs bot alpha",
-    public static void showModeSelection() {
+                    "joueur vs bot divin (NON IMPLEMENTE)"
-        String[] options = {
+            };
-                "joueur vs joueur",
-                "joueur vs botidiot",
-                "joueur vs bot alpha",
-                "joueur vs bot divin",
-                "Arène"
-        };
 
-        int choice = JOptionPane.showOptionDialog(
+            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)",
+                    "Choisissez un mode de jeu :",
-                    (mode == GameMode.PVGOD ? "Bot Divin (PVGOD)" : "Bot Alpha-Beta"),
+                    "Avalam - Mode de jeu",
-                    JOptionPane.QUESTION_MESSAGE
+                    JOptionPane.DEFAULT_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    null,
+                    options,
+                    options[0]
             );
 
-            int depth = 4; // défaut
+            if (choice == -1) System.exit(0);
-            if (s != null) {
+
-                try { depth = Integer.parseInt(s.trim()); }
+            GameMode mode;
-                catch (Exception ignored) { depth = 4; }
+            if (choice == 1) mode = GameMode.PVBOT;
-            } else {
+            else if (choice == 2) mode = GameMode.PVALPHA;
-                // Annulation : on revient en PVP
+            else if (choice == 3) mode = GameMode.PVGOD;
-                new AvalamWindow(GameMode.PVP);
+            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;
             }
 
-            if (depth < 1) depth = 1;
+            new AvalamWindow(mode);
-
+        });
-            new AvalamWindow(mode, depth);
-            return;
-        }
-
-        new AvalamWindow(mode);
     }
 }