ajout de la log pour le bot

TomBaran501 · TomBaran501 · commit 9ec1231c21bf · 2026-05-25T16:47:05.000+02:00
diff --git a/bots/bot_v0 b/bots/bot_v0
diff --git a/documentations/bot_api.md b/documentations/bot_api.md
@@ -61,11 +61,14 @@ Sets the board state (FEN position) in the bot’s internal memory.
 ---
 
 ### `int bot_get_best_move(BotConnector *bot, char *move_str)`
-Requests the bot’s best move for the current position.
+### `int bot_get_best_move(BotConnector *bot, char *move_str, char *log_msg, int timeout_sec)`
+Requests the bot’s best move for the current position and optionally retrieves a log message.
 
 **Parameters:**
 - `bot`: Active bot connection.
 - `move_str`: Output buffer to store the move (e.g., `"e2e4"`).
+- `log_msg`: Output buffer to store an optional log message from the bot (can be empty).
+- `timeout_sec`: Timeout (in seconds) waiting for the main move response.
 
 **Returns:**
 - `0` if a valid move was received.
diff --git a/lib/ai/ai.h b/lib/ai/ai.h
@@ -16,6 +16,7 @@
 #define MAT 900000
 #define INFINI 100000000
 #define MAX_DEPTH 50
+#define SEARCH_LOG_SIZE 256
 
 #pragma once
 typedef struct
@@ -28,12 +29,12 @@ typedef struct
 {
     int depth;
     int nb_positions_evaluated;
-} SearchInfo;
-
+    char log[SEARCH_LOG_SIZE];
+    ScoredMove move;
 
+} SearchInfo;
 
 /// @brief Run the search for the best move in the position
 /// @param board
 /// @return
-Move get_best_move(Chessboard board);
-
+SearchInfo get_best_move(Chessboard board);
diff --git a/lib/api/api_connector.h b/lib/api/api_connector.h
@@ -14,6 +14,8 @@
 
 #define MOVE_SIZE 10
 #define FEN_SIZE 256
+// Taille maximale pour un message de log renvoyé par le bot
+#define LOG_SIZE 256
 
 typedef struct
 {
@@ -29,8 +31,11 @@ int is_bot_connected(BotConnector *bot);
 
 int bot_set_fen(BotConnector *bot, const char *fen);
 
-// Demande au bot le meilleur coup pour un FEN et une couleur
-int bot_get_best_move(BotConnector *bot, char *move_str);
+// Demande au bot le meilleur coup pour un FEN et récupère aussi un message de log éventuel
+// - `move_str` doit avoir la taille MOVE_SIZE
+// - `log_msg` doit avoir la taille LOG_SIZE (peut être vide si aucun message)
+// - `timeout_sec` délai (en secondes) pour la lecture du coup principal
+int bot_get_best_move(BotConnector *bot, char *move_str, char *log_msg, int timeout_sec);
 
 // Envoie un coup au bot pour mise à jour de son état interne
 int bot_play_move(BotConnector *bot, const char *move_str);
diff --git a/src/ai/ai.c b/src/ai/ai.c
@@ -1,8 +1,6 @@
 #include "ai.h"
 #include <limits.h>
 
-SearchInfo info = {0};
-
 // ==================== Move Ordering ====================
 
 static int get_move_score(Chessboard *board, const Move *move)
@@ -37,10 +35,10 @@ static void order_moves(Chessboard *board, Move *moves, int count)
 
 // ==================== Quiescence Search ====================
 
-static int quiescence_search(Chessboard *board, int alpha, int beta)
+static int quiescence_search(Chessboard *board, int alpha, int beta, SearchInfo *info)
 {
     int stand_pat = evaluate_position(board);
-    info.nb_positions_evaluated += 1;
+    info->nb_positions_evaluated += 1;
 
     if (stand_pat >= beta)
         return beta;
@@ -56,7 +54,7 @@ static int quiescence_search(Chessboard *board, int alpha, int beta)
             continue;
 
         play_move(board, moves[i]);
-        int score = -quiescence_search(board, -beta, -alpha);
+        int score = -quiescence_search(board, -beta, -alpha, info);
         unplay_move(board, moves[i]);
 
         if (score >= beta)
@@ -70,10 +68,10 @@ static int quiescence_search(Chessboard *board, int alpha, int beta)
 
 // ==================== Alpha-Beta ====================
 
-int alpha_beta(Chessboard *board, int depth, int alpha, int beta)
+int alpha_beta(Chessboard *board, int depth, int alpha, int beta, SearchInfo *info)
 {
     if (depth == 0)
-        return quiescence_search(board, alpha, beta);
+        return quiescence_search(board, alpha, beta, info);
 
     Move moves[250];
     int count = get_all_legal_moves(board, moves);
@@ -92,7 +90,7 @@ int alpha_beta(Chessboard *board, int depth, int alpha, int beta)
     for (int i = 0; i < count; i++)
     {
         play_move(board, moves[i]);
-        int score = -alpha_beta(board, depth - 1, -beta, -alpha);
+        int score = -alpha_beta(board, depth - 1, -beta, -alpha, info);
         unplay_move(board, moves[i]);
 
         if (score > best)
@@ -109,21 +107,21 @@ int alpha_beta(Chessboard *board, int depth, int alpha, int beta)
 
 // ==================== Root Search ====================
 
-static int get_score(Chessboard *board, Move move, int depth)
+static int get_score(Chessboard *board, Move move, int depth, SearchInfo *info)
 {
     play_move(board, move);
     int score;
     
     if (depth == 0)
         score = evaluate_position(board); // Potentiellement quiecence search au lieu de evaluate mais probablement pas d'impact
     else
-        score = -alpha_beta(board, depth - 1, -INFINI, INFINI);
+        score = -alpha_beta(board, depth - 1, -INFINI, INFINI, info);
     
     unplay_move(board, move);
     return score;
 }
 
-static ScoredMove search_best_move(Chessboard *board, int depth)
+static ScoredMove search_best_move(Chessboard *board, int depth, SearchInfo *info)
 {
     Move legal_moves[250];
     int nbmoves = get_all_legal_moves(board, legal_moves);
@@ -136,14 +134,11 @@ static ScoredMove search_best_move(Chessboard *board, int depth)
 
     ScoredMove best;
     best.move = legal_moves[0];
-    best.score = get_score(board, legal_moves[0], depth);
+    best.score = get_score(board, legal_moves[0], depth, info);
 
     for (int i = 1; i < nbmoves; i++)
     {
-        int score = get_score(board, legal_moves[i], depth);
-
-        //print_move(&legal_moves[i]);
-        //printf("score: %i\n", score);
+        int score = get_score(board, legal_moves[i], depth, info);
 
         if (score > best.score)
         {
@@ -152,14 +147,17 @@ static ScoredMove search_best_move(Chessboard *board, int depth)
         }
     }
 
-    //printf("nb_pos: %i, score: %i\n", info.nb_positions_evaluated, best.score);
-
     return best;
 }
 
-Move get_best_move(Chessboard board)
+SearchInfo get_best_move(Chessboard board)
 {
+    SearchInfo info = {0};
     info.nb_positions_evaluated = 0;
-    ScoredMove best_move = search_best_move(&board, 3);
-    return best_move.move;
+    info.depth = 3;
+    info.log[0] = '\0';
+
+    info.move = search_best_move(&board, info.depth, &info);
+    snprintf(info.log, SEARCH_LOG_SIZE, "depth=%d evaluations=%d", info.depth, info.nb_positions_evaluated);
+    return info;
 }
diff --git a/src/api/api_connector.c b/src/api/api_connector.c
@@ -1,27 +1,64 @@
 #include "api_connector.h"
+#include <sys/time.h>
 
 static int read_line_timeout(FILE *stream, char *buf, int size, int timeout_sec)
 {
     int fd = fileno(stream);
-    fd_set readfds;
-    struct timeval tv;
+    int total = 0;
+    struct timeval start, now, tv;
 
-    FD_ZERO(&readfds);
-    FD_SET(fd, &readfds);
+    if (size <= 1)
+        return -3;
 
-    tv.tv_sec = timeout_sec;
-    tv.tv_usec = 0;
+    if (gettimeofday(&start, NULL) == -1)
+        return -1;
 
-    int ret = select(fd + 1, &readfds, NULL, NULL, &tv);
-    if (ret == -1)
-        return -1; // erreur
-    if (ret == 0)
-        return -2; // timeout
+    while (total < size - 1)
+    {
+        fd_set readfds;
+        FD_ZERO(&readfds);
+        FD_SET(fd, &readfds);
+
+        if (gettimeofday(&now, NULL) == -1)
+            return -1;
+
+        long elapsed = now.tv_sec - start.tv_sec;
+        if (elapsed >= timeout_sec)
+            return -2;
+
+        tv.tv_sec = timeout_sec - elapsed;
+        tv.tv_usec = 0;
+
+        int ret = select(fd + 1, &readfds, NULL, NULL, &tv);
+        if (ret == -1)
+        {
+            if (errno == EINTR)
+                continue;
+            return -1;
+        }
+        if (ret == 0)
+            return -2;
+
+        char c;
+        ssize_t n = read(fd, &c, 1);
+        if (n == 0)
+            return -3;
+        if (n == -1)
+        {
+            if (errno == EINTR)
+                continue;
+            return -3;
+        }
+
+        buf[total++] = c;
+        if (c == '\n')
+            break;
+    }
 
-    if (fgets(buf, size, stream) == NULL)
-        return -3; // EOF ou erreur
+    buf[total] = '\0';
+    while (total > 0 && (buf[total - 1] == '\n' || buf[total - 1] == '\r'))
+        buf[--total] = '\0';
 
-    buf[strcspn(buf, "\r\n")] = '\0';
     return 0;
 }
 
@@ -86,19 +123,38 @@ int bot_set_fen(BotConnector *bot, const char *fen)
     return 0;
 }
 
-int bot_get_best_move(BotConnector *bot, char *move_str)
+int bot_get_best_move(BotConnector *bot, char *move_str, char *log_msg, int timeout_sec)
 {
     if (!is_bot_connected(bot))
         return -1;
 
     fprintf(bot->bot_in, "get move\n");
     fflush(bot->bot_in);
 
-    int res = read_line_timeout(bot->bot_out, move_str, MOVE_SIZE, 3); // timeout 3s
-
+    int res = read_line_timeout(bot->bot_out, move_str, MOVE_SIZE, timeout_sec);
     if (res != 0)
         return -1;
 
+    // Essayer de lire un message de log optionnel provenant du bot.
+    // On laisse un petit timeout pour le log afin de ne pas bloquer.
+    if (log_msg)
+    {
+            int res2 = read_line_timeout(bot->bot_out, log_msg, LOG_SIZE, 1);
+            if (res2 != 0)
+                log_msg[0] = '\0';
+            else
+            {
+                // Attendu: ligne de log préfixée par "LOG:". Si présent, on strip le préfixe.
+                if (strncmp(log_msg, "LOG:", 4) == 0)
+                {
+                    char *p = log_msg + 4;
+                    while (*p == ' ')
+                        p++;
+                    memmove(log_msg, p, strlen(p) + 1);
+                }
+            }
+    }
+
     return 0;
 }
 
diff --git a/src/api_bot.c b/src/api_bot.c
@@ -12,7 +12,7 @@
 int is_bot_killed(char *command, size_t size)
 {
     if (fgets(command, size, stdin) == NULL)
-        return 1; 
+        return 1;
 
     command[strcspn(command, "\r\n")] = '\0';
 
@@ -26,9 +26,11 @@ void handle_commands(const char *command, Chessboard *board, char *fen)
 {
     if (strncmp(command, "get move", 8) == 0)
     {
-        Move best_move = get_best_move(*board);
-        print_move(&best_move);
+        SearchInfo infos = get_best_move(*board);
+        print_move(&infos.move.move);
         printf("\n");
+        if (infos.log[0] != '\0')
+            printf("LOG:%s\n", infos.log);
         fflush(stdout);
     }
     else if (strncmp(command, "fen ", 4) == 0)
diff --git a/src/ui/rendering.c b/src/ui/rendering.c
@@ -440,11 +440,15 @@ static int load_positions(OpeningBook *book)
 static int get_and_play_best_move(int color, GameEnvironement env)
 {
     char best_move[MOVE_SIZE];
+    char bot_log[256];
     BotConnector *bot = color == WHITE ? env.bot1 : env.bot2;
 
-    if (bot_get_best_move(bot, best_move) != 0)
+    if (bot_get_best_move(bot, best_move, bot_log, 3) != 0)
         return 1;
 
+    if (bot_log[0] != '\0')
+        printf("Bot log: %s\n", bot_log);
+
     Move move = get_move(best_move);
     play_move_all(env, move);
 
diff --git a/tests/test_api_connector.c b/tests/test_api_connector.c
@@ -15,12 +15,13 @@ Test(api_connector, connect_and_get_move)
     printf("TEST BOT API (STARTPOS)... \n");
     BotConnector bot;
     char best_move[6];
+    char log_msg[LOG_SIZE];
 
     int res = bot_connect(&bot, bot_path);
     cr_assert_eq(res, 0, "Échec de la connexion au bot");
 
     // Demande du meilleur coup
-    res = bot_get_best_move(&bot, best_move);
+    res = bot_get_best_move(&bot, best_move, log_msg, 3);
     cr_assert_eq(res, 0, "bot_get_best_move a échoué");
     cr_assert_neq(best_move[0], '\0', "Le bot n’a pas renvoyé de coup");
 
@@ -37,6 +38,7 @@ Test(api_connector, reconnect_after_disconnect)
 {
     BotConnector bot;
     char best_move[MOVE_SIZE];
+    char log_msg[LOG_SIZE];
 
     int res = bot_connect(&bot, bot_path);
     cr_assert_eq(res, 0);
@@ -46,7 +48,7 @@ Test(api_connector, reconnect_after_disconnect)
     res = bot_connect(&bot, bot_path);
     cr_assert_eq(res, 0);
 
-    res = bot_get_best_move(&bot, best_move);
+    res = bot_get_best_move(&bot, best_move, log_msg, 3);
     cr_assert_eq(res, 0);
     cr_assert_neq(best_move[0], '\0', "Le bot n’a pas renvoyé de coup");
 

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`	`int is_bot_killed(char *command, size_t size)`
`13`	`13`	`{`
`14`	`14`	`if (fgets(command, size, stdin) == NULL)`
`15`		`- return 1;`
	`15`	`+ return 1;`
`16`	`16`
`17`	`17`	`command[strcspn(command, "\r\n")] = '\0';`
`18`	`18`
`@@ -26,9 +26,11 @@ void handle_commands(const char command, Chessboard board, char *fen)`
`26`	`26`	`{`
`27`	`27`	`if (strncmp(command, "get move", 8) == 0)`
`28`	`28`	`{`
`29`		`- Move best_move = get_best_move(*board);`
`30`		`- print_move(&best_move);`
	`29`	`+ SearchInfo infos = get_best_move(*board);`
	`30`	`+ print_move(&infos.move.move);`
`31`	`31`	`printf("\n");`
	`32`	`+ if (infos.log[0] != '\0')`
	`33`	`+ printf("LOG:%s\n", infos.log);`
`32`	`34`	`fflush(stdout);`
`33`	`35`	`}`
`34`	`36`	`else if (strncmp(command, "fen ", 4) == 0)`