diff --git a/fr/iut_fbleau/Bot/DivineBot.java b/fr/iut_fbleau/Bot/DivineBot.java index 93760ff..8d49450 100644 --- a/fr/iut_fbleau/Bot/DivineBot.java +++ b/fr/iut_fbleau/Bot/DivineBot.java @@ -4,46 +4,18 @@ import fr.iut_fbleau.Avalam.*; import fr.iut_fbleau.GameAPI.*; import java.util.*; -/** - * Bot expert utilisant l'algorithme Alpha-Beta pour le jeu Avalam. - * * Idée : - * - Explore l'arbre des coups possibles jusqu'à une profondeur donnée. - * - Utilise l'élagage Alpha-Beta pour optimiser la recherche. - * - Évalue les positions selon le contrôle des tours et leur hauteur. - */ public class DivineBot extends AbstractGamePlayer { - // 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 les coups de même valeur. */ private final Random rng = new Random(); - // Constructeur - - /** - * Construit un bot DivineBot. - * * @param p joueur contrôlé par ce bot - * @param maxDepth profondeur maximale de recherche - */ public DivineBot(Player p, int maxDepth) { super(p); this.me = p; this.maxDepth = maxDepth; } - // Méthodes - - /** - * Méthode appelée par GameAPI : le bot doit choisir le meilleur coup possible. - * * @param board copie sûre de l'état de jeu (IBoard) - * @return le coup choisi (AbstractPly) ou null si aucun coup n'est possible - */ @Override public AbstractPly giveYourMove(IBoard board) { if (board == null || board.isGameOver()) return null; @@ -55,7 +27,7 @@ public class DivineBot extends AbstractGamePlayer { for (AbstractPly m : moves) { IBoard next = board.safeCopy(); next.doPly(m); - // On calcule la valeur du plateau après ce coup + // On regarde l'avenir int value = alphaBeta(next, maxDepth - 1, Integer.MIN_VALUE, Integer.MAX_VALUE); if (value > bestValue) { @@ -69,27 +41,18 @@ public class DivineBot extends AbstractGamePlayer { return bestMoves.get(rng.nextInt(bestMoves.size())); } - /** - * Fonction récursive Alpha-Beta pour évaluer l'arbre de décision. - * * @param board état actuel du plateau - * @param depth profondeur restante à explorer - * @param alpha borne inférieure - * @param beta borne supérieure - * @return la valeur de l'évaluation - */ private int alphaBeta(IBoard board, int depth, int alpha, int beta) { if (board.isGameOver()) { Result r = board.getResult(); if (r == Result.DRAW) return 0; - - boolean p1Wins = (r == Result.WIN); + // On vérifie strictement si MON joueur a gagné + boolean winP1 = (r == Result.WIN); boolean amIP1 = (me == Player.PLAYER1); - return (p1Wins == amIP1) ? 10000 : -10000; + return (winP1 == amIP1) ? 1000000 : -1000000; } if (depth == 0) return evaluate(board); - // Si c'est à moi de jouer, je maximise. Sinon, je minimise. boolean isMax = (board.getCurrentPlayer() == me); int best = isMax ? Integer.MIN_VALUE : Integer.MAX_VALUE; @@ -110,18 +73,13 @@ public class DivineBot extends AbstractGamePlayer { return best; } - /** - * Heuristique spécifique à Avalam. - * Valorise le contrôle des tours, avec un bonus pour les tours de hauteur 5 (verrouillées). - * * @param board plateau à évaluer - * @return score numérique de la position (positif si avantageux) - */ private int evaluate(IBoard board) { if (!(board instanceof AvalamBoard)) return 0; AvalamBoard b = (AvalamBoard) board; - - // Configuration des couleurs + + // On définit clairement les couleurs Color myColor = (me == Player.PLAYER1) ? Color.YELLOW : Color.RED; + Color oppColor = (myColor == Color.YELLOW) ? Color.RED : Color.YELLOW; int score = 0; for (int r = 0; r < AvalamBoard.SIZE; r++) { @@ -129,30 +87,66 @@ public class DivineBot extends AbstractGamePlayer { Tower t = b.getTowerAt(r, c); if (t == null || t.getHeight() == 0) continue; - // Une tour de 5 vaut beaucoup plus car elle est "verrouillée". - int val = (t.getHeight() == 5) ? 10 : 1; - - if (t.getColor() == myColor) { - score += val; + int h = t.getHeight(); + int weight = 0; + + // Étape 1 : Est-ce que cette tour est "finie" ou isolée ? + if (h == 5 || isIsolated(b, r, c)) { + weight = 1000; // Point sécurisé } else { - score -= val; + // Étape 2 : Si la tour est prenable par l'ennemi + if (isVulnerable(b, r, c, oppColor)) { + // Si c'est ma tour, c'est un danger (-200) + // Si c'est la sienne, c'est une opportunité (+50) + weight = -200; + } else { + // Étape 3 : Barème de progression sécurisée + switch (h) { + case 4: weight = 400; break; + case 3: weight = 150; break; + case 2: weight = 60; break; + default: weight = 10; break; + } + } } + + if (t.getColor() == myColor) score += weight; + else score -= weight; } } return score; } - /** - * Récupère la liste de tous les coups légaux disponibles sur le plateau. - * * @param board plateau actuel - * @return liste des coups possibles - */ + private boolean isIsolated(AvalamBoard b, int r, int c) { + for (int dr = -1; dr <= 1; dr++) { + for (int dc = -1; dc <= 1; dc++) { + if (dr == 0 && dc == 0) continue; + Tower n = b.getTowerAt(r + dr, c + dc); + if (n != null && n.getHeight() > 0) return false; + } + } + return true; + } + + private boolean isVulnerable(AvalamBoard b, int r, int c, Color enemyColor) { + int myHeight = b.getTowerAt(r, c).getHeight(); + for (int dr = -1; dr <= 1; dr++) { + for (int dc = -1; dc <= 1; dc++) { + if (dr == 0 && dc == 0) continue; + Tower n = b.getTowerAt(r + dr, c + dc); + // Si un ennemi peut sauter dessus pour faire une tour <= 5 + if (n != null && n.getColor() == enemyColor && (n.getHeight() + myHeight <= 5)) { + return true; + } + } + } + return false; + } + private List listMoves(IBoard board) { List moves = new ArrayList<>(); Iterator it = board.iterator(); - while (it.hasNext()) { - moves.add(it.next()); - } + while (it.hasNext()) moves.add(it.next()); return moves; } } \ No newline at end of file