début du bot v_0

Author: TomBaran501

bots/bot_v0

@@ -24,18 +24,10 @@ typedef struct
     int score; // score obtenu à la profondeur précédente
 } ScoredMove;
 
-#pragma once
-typedef struct
-{
-    Chessboard board;
-    Move move;
-    int score;
-    unsigned long long nbmoves;
-    int true_depth;
-    unsigned long long nb_cuts_tt;
-} ThreadTask;
 
 /// @brief Run the search for the best move in the position
 /// @param board
 /// @return
 Move get_best_move(Chessboard board);
+
+int alpha_beta(Chessboard *board, int depth, int alpha, int beta, int is_maximizing);

lib/ai/ai.h

@@ -1,114 +1,136 @@
 #include "ai.h"
+#include <limits.h>
 
-struct timespec t_start;
-int max_time_ms = 100;
-
-typedef struct
-{
-    Move best_move;
-    int evaluation;
-} SearchResult;
-
-/**
- * Recherche Alpha-Beta récursive
- * Retourne une évaluation numérique pour la position courante.
- */
-static int alpha_beta(Chessboard *board, int depth, int alpha, int beta, bool maximizingPlayer)
+// Fonction pour trier les coups dans l'ordre décroissant
+static void sort_moves(ScoredMove *scored_moves, int nbmoves)
 {
-    if (depth == 0) // Rajouter une condition sur mat et pat
+    for (int i = 0; i < nbmoves - 1; i++)
     {
-        return evaluate_position(board);
+        for (int j = 0; j < nbmoves - i - 1; j++)
+        {
+            if (scored_moves[j].score < scored_moves[j + 1].score)
+            {
+                ScoredMove temp = scored_moves[j];
+                scored_moves[j] = scored_moves[j + 1];
+                scored_moves[j + 1] = temp;
+            }
+        }
     }
+}
 
-    Move moves[250];
-    int nb_moves = get_all_legal_moves(board, moves);
-
-    if (nb_moves == 0)
-        return evaluate_position(board);
+static int get_ending_score(Chessboard *board, int is_maximizing)
+{
+    if (is_check(board))
+        return is_maximizing ? INT_MIN + 1 : INT_MAX - 1; // Checkmate
+    return 0;                                             // Stalemate
+}
 
-    if (maximizingPlayer)
+/* Helper: simple in-place partition to put capture moves first (heuristic d'ordre) */
+static void order_moves_by_capture(Move moves[], int nbmoves)
+{
+    if (nbmoves <= 1)
+        return;
+    int i = 0, j = nbmoves - 1;
+    while (i < j)
     {
-        int maxEval = -INFINI;
-        for (int i = 0; i < nb_moves; i++)
+        while (i < nbmoves && moves[i].piece_taken)
+            i++;
+        while (j >= 0 && !moves[j].piece_taken)
+            j--;
+        if (i < j)
         {
-            Chessboard next_board = *board;
-            play_move(&next_board, moves[i]);
-
-            int eval = alpha_beta(&next_board, depth - 1, alpha, beta, false);
-            if (eval > maxEval)
-                maxEval = eval;
-
-            if (maxEval > alpha)
-                alpha = maxEval;
+            Move tmp = moves[i];
+            moves[i] = moves[j];
+            moves[j] = tmp;
+            i++;
+            j--;
+        }
+    }
+}
 
-            if (beta <= alpha)
-                break; // coupure Beta
+static int alpha_beta_search(Chessboard *board, int depth, int alpha, int beta, int is_maximizing, int nbmoves, Move *legal_moves)
+{
+    if (is_maximizing)
+    {
+        int best = INT_MIN;
+        for (int i = 0; i < nbmoves; ++i)
+        {
+            play_move(board, legal_moves[i]);
+            int val = alpha_beta(board, depth - 1, alpha, beta, !is_maximizing);
+            unplay_move(board, legal_moves[i]);
+
+            if (val > best)
+                best = val;
+            if (val > alpha)
+                alpha = val;
+            if (alpha >= beta)
+                break; /* beta-cutoff */
         }
-        return maxEval;
+        return best;
     }
     else
     {
-        int minEval = INFINI;
-        for (int i = 0; i < nb_moves; i++)
+        int best = INT_MAX;
+        for (int i = 0; i < nbmoves; ++i)
         {
-            Chessboard next_board = *board;
-            play_move(&next_board, moves[i]);
-
-            int eval = alpha_beta(&next_board, depth - 1, alpha, beta, true);
-            if (eval < minEval)
-                minEval = eval;
-
-            if (minEval < beta)
-                beta = minEval;
-
+            play_move(board, legal_moves[i]);
+            int val = alpha_beta(board, depth - 1, alpha, beta, !is_maximizing);
+            unplay_move(board, legal_moves[i]);
+
+            if (val < best)
+                best = val;
+            if (val < beta)
+                beta = val;
             if (beta <= alpha)
-                break; // coupure Alpha
+                break; /* alpha-cutoff */
         }
-        return minEval;
+        return best;
     }
 }
 
-/**
- * Recherche le meilleur coup à une profondeur donnée.
- */
-static SearchResult search_best_move_alpha_beta(Chessboard *board, int depth)
+int alpha_beta(Chessboard *board, int depth, int alpha, int beta, int is_maximizing)
 {
-    Move moves[250];
-    int nb_moves = get_all_legal_moves(board, moves);
+    if (depth == 0)
+        return evaluate_position(board);
 
-    SearchResult result;
-    result.best_move = moves[0];
-    result.evaluation = board->white_to_play ? -INFINI : INFINI;
+    Move legal_moves[250];
+    int nbmoves = get_all_legal_moves(board, legal_moves);
 
-    bool maximizing = board->white_to_play;
+    if (nbmoves == 0)
+        return get_ending_score(board, is_maximizing);
 
-    int alpha = -INFINI;
-    int beta = INFINI;
+    order_moves_by_capture(legal_moves, nbmoves);
 
-    for (int i = 0; i < nb_moves; i++)
-    {
-        Chessboard next_board = *board;
-        play_move(&next_board, moves[i]);
+    return alpha_beta_search(board, depth, alpha, beta, is_maximizing, nbmoves, legal_moves);
+}
+
+static int get_score(Chessboard board, Move move, int depth)
+{
+    play_move(&board, move);
+    if (depth == 0)
+        return evaluate_position(&board);
 
-        int eval = alpha_beta(&next_board, depth - 1, alpha, beta, !maximizing);
+    return alpha_beta(&board, depth - 1, INT_MIN, INT_MAX, !board.white_to_play);
+}
 
-        if (maximizing && eval > result.evaluation)
-        {
-            result.evaluation = eval;
-            result.best_move = moves[i];
-        }
-        else if (!maximizing && eval < result.evaluation)
-        {
-            result.evaluation = eval;
-            result.best_move = moves[i];
-        }
+static ScoredMove search_best_move(Chessboard board, int depth)
+{
+    Move legal_moves[250];
+    int nbmoves = get_all_legal_moves(&board, legal_moves);
+    ScoredMove scored_moves[nbmoves];
+
+    for (int i = 0; i < nbmoves; i++)
+    {
+        scored_moves[i].move = legal_moves[i];
+        scored_moves[i].score = get_score(board, legal_moves[i], depth);
     }
 
-    return result;
+    sort_moves(scored_moves, nbmoves);
+    return scored_moves[0];
 }
 
 Move get_best_move(Chessboard board)
 {
-    SearchResult best_move = search_best_move_alpha_beta(&board, 5);
-    return best_move.best_move;
+    ScoredMove best_move = search_best_move(board, 3);
+    return best_move.move;
 }

src/ai/ai.c

@@ -461,7 +461,7 @@ static void handle_ai_turn(int color_ai, GameEnvironement env)
             printf("Erreur de communication avec le bot\n");
 
         ui_refresh_board(env);
-        SDL_Delay(50);
+        SDL_Delay(10);
     }
 
     SDL_Delay(10);