Add horizontal verification

Various changes have been done for better game result verification.

main.c

@@ -13,16 +13,16 @@ int main() {
     puissance game;
 
     game_init(&game, RAND_AI, DEFAULT_ROW, DEFAULT_COL);
-    manual_play(&game, 1);
-    manual_play(&game, 0);
-    manual_play(&game, 1);
+    manual_play(&game, 4);
     print_game(game);
     manual_play(&game, 0);
-    manual_play(&game, 2);
-    manual_play(&game, 0);
     manual_play(&game, 3);
-    print_game(game);
     manual_play(&game, 0);
+    manual_play(&game, 2);
+    print_game(game);
+    manual_play(&game, 6);
+    print_game(game);
+    manual_play(&game, 1);
     print_game(game);
 
     game_destroy(&game);

puissance.c

@@ -118,52 +118,92 @@ void print_game(puissance p) {
     }
 }
 
-GameResult vertical_game_check(puissance p, int last_col_index_played) {
+GameResult get_winning_player(puissance *p) {
+    // Return the player who have won.
+    if (p->current_player == PLAYER_ONE) {
+        p->state = PLAYER_ONE_WIN;
+    } else {
+        p->state = PLAYER_TWO_WIN;
+    }
+    return p->state;
+
+}
+
+GameResult vertical_game_check(puissance *p, int last_col_index_played) {
+    if (p->state != ONGOING) {
+        return p->state;
+    }
+
     bool four_aligned = false;
     // Get the row index
-    int last_row_index_played = get_available_row_index(&p, last_col_index_played);
-    if (last_row_index_played != EMPTY_CELL_VALUE) {
-        last_row_index_played += 1; // Adjust the index
-    }
+    int last_row_index_played = get_available_row_index(p, last_col_index_played) + 1;
 
     // Verify if we have enough vertical space.
-    if (last_row_index_played + NB_SAME_VALUE_ALIGNED_FOR_WIN - 1 < p.row) {
-        int last_played_value = p.data[last_row_index_played][last_col_index_played];
+    if (last_row_index_played + NB_VERIFICATION_FOR_WIN < p->row) {
+        int last_played_value = p->data[last_row_index_played][last_col_index_played];
         four_aligned = true;
 
         // Verify if the aligned value are the same
-        for (int i = 1; i <= NB_SAME_VALUE_ALIGNED_FOR_WIN - 1; i++) {
-            if (last_played_value != p.data[last_row_index_played + i][last_col_index_played]) {
+        for (int i = 1; i <= NB_VERIFICATION_FOR_WIN; i++) {
+            if (last_played_value != p->data[last_row_index_played + i][last_col_index_played]) {
                 four_aligned = false;
                 break;
             }
         }
 
         if (four_aligned) {
-            // Return the player who have won.
-            if (p.current_player == PLAYER_ONE) {
-                return PLAYER_ONE_WIN;
-            } else {
-                return PLAYER_TWO_WIN;
+            return get_winning_player(p);
+        }
+    }
+
+    return ONGOING;
+}
+
+GameResult horizontal_game_check(puissance *p, int last_col_index_played) {
+    if (p->state != ONGOING) {
+        return p->state;
+    }
+
+    bool four_aligned = false;
+    // Get the row index
+    int last_row_index_played = get_available_row_index(p, last_col_index_played) + 1;
+    int last_played_value = p->data[last_row_index_played][last_col_index_played];
+
+    // Verify the left
+    if (last_col_index_played - NB_VERIFICATION_FOR_WIN >= 0) {
+        four_aligned = true;
+        for (int i = 1; i <= NB_VERIFICATION_FOR_WIN; i++) {
+            if (last_played_value != p->data[last_row_index_played][last_col_index_played - i]) {
+                four_aligned = false;
+                break;
+            }
+        }
+    }
+    // Verify the right
+    if (last_col_index_played + NB_VERIFICATION_FOR_WIN < p->col && four_aligned == false) {
+        four_aligned = true;
+        for (int i = 1; i <= NB_VERIFICATION_FOR_WIN; i++) {
+            if (last_played_value != p->data[last_row_index_played][last_col_index_played + i]) {
+                four_aligned = false;
+                break;
             }
         }
     }
 
+    if (four_aligned) {
+        return get_winning_player(p);
+    }
+
     return ONGOING;
 }
 
 GameResult verify_game(puissance *p, int last_col_index_played) {
-    GameResult result = ONGOING;
     // Vertical check
-    result = vertical_game_check(*p, last_col_index_played);
-
-    if (result != ONGOING) {
-        p->state = result;
-        return result;
-    }
+    vertical_game_check(p, last_col_index_played);
+    // Horizontal check
+    horizontal_game_check(p, last_col_index_played);
 
-    p->state = result;
-    return result;
+    return p->state;
 }
 
 GameResult display_game_result(GameResult gr) {

puissance.h

@@ -15,8 +15,9 @@
 #define DEFAULT_COL 7
 #define PLAYER_ONE_STRING "X"
 #define PLAYER_TWO_STRING "O"
-#define EMPTY_CELL_VALUE -1
+#define EMPTY_CELL_VALUE -2
 #define NB_SAME_VALUE_ALIGNED_FOR_WIN 4
+#define NB_VERIFICATION_FOR_WIN (NB_SAME_VALUE_ALIGNED_FOR_WIN - 1)
 
 typedef enum {
     RAND_AI,