dick/BUT3ProjetJeuGroupe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Bot Divin (plus performant)

Browse Source
This commit is contained in:
Hugo RABAN
2026-02-05 23:12:03 +01:00
parent ebfc9d7d78
commit f40f3daa1d
1 changed files with 57 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
fr/iut_fbleau/Bot/DivineBot.java
View File

@@ -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<AbstractPly> listMoves(IBoard board) {
List<AbstractPly> moves = new ArrayList<>();
Iterator<AbstractPly> it = board.iterator();
while (it.hasNext()) {
moves.add(it.next());
}
while (it.hasNext()) moves.add(it.next());
return moves;
}
}