ajout des fin de parties dans le rendering

Author: TomBaran501

lib/chessboard/chessboard.h

@@ -10,9 +10,10 @@
 #include "bitboard.h"
 #include "masks.h"
 
+typedef struct RepetitionTable RepetitionTable;
 
 // Définition de la structure Chessboard
-typedef struct
+typedef struct Chessboard
 {
     uint64_t pawns;
     uint64_t knights;
@@ -29,8 +30,17 @@ typedef struct
 
     int white_to_play;
 
+    RepetitionTable *hashtable;
+
 } Chessboard;
 
+enum
+{
+    PLAYING = 0,
+    DRAW = 1,
+    WIN = 2,
+}; // Game state
+
 // Initialisation d'un échiquier avec la position de départ
 void init_chessboard(Chessboard *board);
 

lib/chessboard/chessboardcontroller.h

@@ -4,17 +4,18 @@
 #include "bitboards/bitboard.h"
 #include "chessrules.h"
 #include "move/move.h"
+#include "hashtables/hash_table.h"
 
 /// @brief renvoie la liste des coups possibles pour une piece
 /// @param piecePos la position de la piece
 /// @param chessboard l'echequier
 /// @return la liste des coups possibles
-int getlegalmoves(int piecePos, Chessboard *chessboard, Move piece_moves[250]);
+int get_legal_moves(int piecePos, Chessboard *chessboard, Move piece_moves[250]);
 
 /// @brief Récupère tous les coups légaux possibles pour toutes les pièces du joueur
 /// @param chessboard l'échiquier
 /// @return Tout les coups légaux possibles
-int getalllegalmoves(Chessboard *chessboard, Move all_moves[250]);
+int get_all_legal_moves(Chessboard *chessboard, Move all_moves[250]);
 
 /// @brief Joue un coup sur l'échiquier. Cette fonction met à jour l'echequier
 /// @param board l'echequier qui va être mis à jour
@@ -36,13 +37,21 @@ bool try_play_move(Chessboard *board, Move *move);
 void unplay_move(Chessboard *board, Move move);
 
 /// @brief Renvoie true si il y a echec
-/// @param board 
-/// @return 
+/// @param board
+/// @return
 bool is_check(Chessboard *board);
 
 /// @brief Renvoie toute les captures possibles de la position
-/// @param chessboard 
-/// @param all_moves 
-/// @return 
+/// @param chessboard
+/// @param all_moves
+/// @return
 int get_all_captures(Chessboard *chessboard, Move captures[250]);
 
+/// @brief Joue le coup et renvoie le "Game State"
+/// Playing = 0;
+/// Draw = 1;
+/// Checkmate = 2
+/// @param board
+/// @param move
+/// @return
+int play_move_check_gameover(Chessboard *board, Move move);

lib/chessboard/hashtables/hash_table.h

@@ -4,30 +4,34 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <time.h>
-#include "../chessboard.h"
+#include <stdbool.h>
 
 typedef uint64_t ZobristKey;
 
 #define HASH_TABLE_SIZE 16384
 
+typedef struct Chessboard Chessboard;
+
 // Structure pour une entrée de la table de répétition
-typedef struct {
+typedef struct
+{
     ZobristKey key;
     int count;
 } HashEntry;
 
 // Table de répétition
-typedef struct {
+typedef struct RepetitionTable
+{
     HashEntry entries[HASH_TABLE_SIZE];
     ZobristKey history[512];
     int history_count;
 } RepetitionTable;
 
 // Tables Zobrist globales
-extern ZobristKey zobrist_pieces[12][64];  // 12 types de pièces × 64 cases
-extern ZobristKey zobrist_castling[16];     // 16 combinaisons de droits de roque
-extern ZobristKey zobrist_en_passant[64];   // En passant par case
-extern ZobristKey zobrist_side_to_move;     // Trait aux blancs/noirs
+extern ZobristKey zobrist_pieces[12][64]; // 12 types de pièces × 64 cases
+extern ZobristKey zobrist_castling[16];   // 16 combinaisons de droits de roque
+extern ZobristKey zobrist_en_passant[64]; // En passant par case
+extern ZobristKey zobrist_side_to_move;   // Trait aux blancs/noirs
 
 // Fonctions d'initialisation
 void init_zobrist(void);

lib/ui/rendering.h

@@ -24,6 +24,7 @@ typedef struct
     GenericList *colored_squares;
     BotConnector *bot1;
     BotConnector *bot2;
+    int *GameState;
 } GameEnvironement;
 
 #pragma once

src/ai/ai.c

@@ -21,7 +21,7 @@ static int alpha_beta(Chessboard *board, int depth, int alpha, int beta, bool ma
     }
 
     Move moves[250];
-    int nb_moves = getalllegalmoves(board, moves);
+    int nb_moves = get_all_legal_moves(board, moves);
 
     if (nb_moves == 0)
         return evaluate_position(board);
@@ -74,7 +74,7 @@ static int alpha_beta(Chessboard *board, int depth, int alpha, int beta, bool ma
 static SearchResult search_best_move_alpha_beta(Chessboard *board, int depth)
 {
     Move moves[250];
-    int nb_moves = getalllegalmoves(board, moves);
+    int nb_moves = get_all_legal_moves(board, moves);
 
     SearchResult result;
     result.best_move = moves[0];

src/chessboard/chessboard.c

@@ -1,4 +1,5 @@
 #include "chessboard.h"
+#include "hashtables/hash_table.h"
 
 #include "stdlib.h"
 
@@ -28,6 +29,12 @@ void init_chessboard(Chessboard *board)
     board->castling = create_1bit_board(casttling_squares[0]) + create_1bit_board(casttling_squares[1]) + create_1bit_board(casttling_squares[2]) + create_1bit_board(casttling_squares[3]);
 
     board->white_to_play = true;
+
+    RepetitionTable *t = malloc(sizeof(RepetitionTable));
+    init_repetition_table(t);
+    board->hashtable = t;
+
+    init_zobrist();
 }
 
 void print_chessboard(const Chessboard *board)
@@ -310,7 +317,12 @@ void init_chessboard_from_fen(Chessboard *board, const char *fen)
         ptr += 2;
     }
 
+    RepetitionTable *t = malloc(sizeof(RepetitionTable));
+    init_repetition_table(t);
+    board->hashtable = t;
+
     init_bitboards();
+    init_zobrist();
 }
 
 void copy_chessboard(const Chessboard *src, Chessboard *dst)

src/chessboard/chessboardcontroller.c

@@ -207,7 +207,7 @@ static int get_captures_piece(int piecePos, Chessboard *chessboard, Move piece_m
     return nbmoves;
 }
 
-int getlegalmoves(int piecePos, Chessboard *chessboard, Move piece_moves[250])
+int get_legal_moves(int piecePos, Chessboard *chessboard, Move piece_moves[250])
 {
     uint64_t playerPieces = chessboard->white_to_play ? chessboard->occupied_white : chessboard->occupied_black;
 
@@ -264,7 +264,7 @@ int get_all_captures(Chessboard *chessboard, Move all_moves[250])
     return icoup;
 }
 
-int getalllegalmoves(Chessboard *chessboard, Move all_moves[250])
+int get_all_legal_moves(Chessboard *chessboard, Move all_moves[250])
 {
     uint64_t playerPieces = chessboard->white_to_play ? chessboard->occupied_white : chessboard->occupied_black;
     int icoup = 0;
@@ -274,7 +274,7 @@ int getalllegalmoves(Chessboard *chessboard, Move all_moves[250])
         int piecePos = get_lsb_index(playerPieces);
         Move piece_moves[256];
 
-        int nb_coups = getlegalmoves(piecePos, chessboard, piece_moves);
+        int nb_coups = get_legal_moves(piecePos, chessboard, piece_moves);
 
         // Ajoute les mouvements de cette pièce à la liste globale
         for (int i = 0; i < nb_coups; i++)
@@ -408,7 +408,7 @@ static void update_bitboard_promotion(int promotion_flag, Chessboard *board, uin
 static bool is_legal_move(Chessboard *board, Move *move)
 {
     Move legal_moves[250];
-    int nbcoups = getalllegalmoves(board, legal_moves);
+    int nbcoups = get_all_legal_moves(board, legal_moves);
 
     for (int i = 0; i < nbcoups; i++)
     {
@@ -468,6 +468,7 @@ inline void play_move(Chessboard *board, Move move)
     }
 
     board->white_to_play = !board->white_to_play;
+    add_position(board->hashtable, compute_hash(board));
 }
 
 inline void unplay_move(Chessboard *board, Move move)
@@ -505,4 +506,22 @@ inline void unplay_move(Chessboard *board, Move move)
     }
     board->enpassant = move.en_passant;
     board->white_to_play = !board->white_to_play;
+    pop_position(board->hashtable);
+}
+
+int play_move_check_gameover(Chessboard *board, Move move)
+{
+    play_move(board, move);
+
+    if (is_threefold_repetition(board->hashtable, compute_hash(board)))
+        return DRAW;
+    
+    Move moves[250];
+    if (get_all_legal_moves(board, moves) != 0)
+        return PLAYING;
+    
+    if (is_check(board))
+        return WIN;
+    
+    return DRAW;
 }

src/chessboard/hashtables/hash_table.c

@@ -1,4 +1,5 @@
 #include "hash_table.h"
+#include "../chessboard.h"
 
 ZobristKey zobrist_pieces[12][64];
 ZobristKey zobrist_castling[16];

src/main.c

@@ -33,7 +33,7 @@ static int run_test(Chessboard *board, int profondeur)
         return 1;
 
     Move liste_coups[250];
-    int nbmoves = getalllegalmoves(board, liste_coups);
+    int nbmoves = get_all_legal_moves(board, liste_coups);
 
     int total = 0;
 
@@ -64,7 +64,7 @@ static uint64_t run_test_mt(Chessboard *board, int profondeur)
         return 1;
 
     Move liste_coups[250];
-    int nbmoves = getalllegalmoves(board, liste_coups);
+    int nbmoves = get_all_legal_moves(board, liste_coups);
 
     pthread_t *threads = malloc(sizeof(pthread_t) * nbmoves);
     ThreadArgs *args = malloc(sizeof(ThreadArgs) * nbmoves);

src/ui/rendering.c

@@ -40,7 +40,7 @@ static void draw_board(SDL_Renderer *renderer)
     }
 }
 
-static inline GameEnvironement create_game_environment(SDL_Event *event, Chessboard *board, SDL_Renderer *renderer, GenericList *colored_squares, BotConnector *bot1, BotConnector *bot2)
+static inline GameEnvironement create_game_environment(SDL_Event *event, Chessboard *board, SDL_Renderer *renderer, GenericList *colored_squares, BotConnector *bot1, BotConnector *bot2, int *GameState)
 {
     GameEnvironement env;
     env.event = event;
@@ -49,6 +49,7 @@ static inline GameEnvironement create_game_environment(SDL_Event *event, Chessbo
     env.colored_squares = colored_squares;
     env.bot1 = bot1;
     env.bot2 = bot2;
+    env.GameState = GameState;
 
     return env;
 }
@@ -214,7 +215,7 @@ static void render_fen(SDL_Renderer *renderer, const char *fen)
 
 static int set_moves(Chessboard *board, Move moves[250], int pos_piece, GenericList *colored_squares)
 {
-    int nbmoves = getlegalmoves(pos_piece, board, moves);
+    int nbmoves = get_legal_moves(pos_piece, board, moves);
     if (nbmoves == 0)
         return 0;
 
@@ -229,7 +230,7 @@ static int set_moves(Chessboard *board, Move moves[250], int pos_piece, GenericL
 
 void play_move_all(GameEnvironement env, Move move)
 {
-    play_move(env.board, move);
+    *env.GameState = play_move_check_gameover(env.board, move);
 
     char movestring[MOVE_SIZE];
     move_to_string(&move, movestring);
@@ -312,7 +313,7 @@ static void handle_player_event(GameEnvironement env, int *clicked_square)
     {
         if (is_in_list(env.colored_squares, &square))
         {
-            int nbmoves = getlegalmoves(*clicked_square, env.board, list_moves);
+            int nbmoves = get_legal_moves(*clicked_square, env.board, list_moves);
             render_play_move(env, list_moves, square, nbmoves);
         }
         reset_colored_squares(env.colored_squares);
@@ -331,8 +332,10 @@ static GameEnvironement init_game_environment(char *startpos, SDL_Renderer *rend
 
     BotConnector *bot1 = malloc(sizeof(BotConnector));
     BotConnector *bot2 = malloc(sizeof(BotConnector));
+    int *GameState = malloc(sizeof(int));
+    *GameState = 0;
 
-    GameEnvironement env = create_game_environment(event, board, renderer, colored_squares, bot1, bot2);
+    GameEnvironement env = create_game_environment(event, board, renderer, colored_squares, bot1, bot2, GameState);
     return env;
 }
 
@@ -351,6 +354,9 @@ static void cleanup_ui(SDL_Renderer *renderer, SDL_Window *window, GameEnvironem
     if (env.bot2)
         free(env.bot2);
 
+    if (env.GameState)
+        free(env.GameState);
+
     for (int i = 0; i < 12; i++)
         if (piece_textures[i])
             SDL_DestroyTexture(piece_textures[i]), piece_textures[i] = NULL;
@@ -425,7 +431,7 @@ static int get_and_play_best_move(int color, GameEnvironement env)
 
     if (bot_get_best_move(bot, best_move) != 0)
         return 1;
-    
+
     Move move = get_move(best_move);
     play_move_all(env, move);
 
@@ -477,6 +483,9 @@ static void game_loop(char *startpos, SDL_Renderer *renderer, int color_ai, SDL_
 
     while (running)
     {
+        if (*env.GameState != PLAYING)
+            running = false;
+
         while (SDL_PollEvent(env.event))
         {
             if (!handle_SDL_events(color_ai, &clicked_square, env))