commit 6b58378a7073381a0a84086652327ab5d72ec747 · singingpigs.online/connect-four

+3 -3

CMakeLists.txt

···

       4
       4
        
       

     

       5
       5
        
       add_subdirectory(SDL EXCLUDE_FROM_ALL)

     

       6
       6
        
       

     

       7
       7
       -
       add_executable(ConnectFour main.cpp core.cpp)

     

       7
       7
       +
       add_executable(ConnectFour main.cpp core.cpp helpers.cpp)

     

       8
       8
        
       target_link_libraries(ConnectFour PRIVATE SDL3::SDL3)

     

       9
       9
        
       target_include_directories(ConnectFour PRIVATE SDL/include/SDL3)

     

       10
       10
        
       

     

       11
       11
       -
       add_executable(ConnectFour-Profile profile.cpp core.cpp)

     

       11
       11
       +
       add_executable(ConnectFour-Profile profile.cpp core.cpp helpers.cpp)

     

       12
       12
        
       target_link_libraries(ConnectFour-Profile PRIVATE SDL3::SDL3)

     

       13
       13
        
       target_include_directories(ConnectFour-Profile PRIVATE SDL/include/SDL3)

     

       14
       14
        
       

     
···

       24
       24
        
       )

     

       25
       25
        
       

     

       26
       26
        
       foreach(TEST_NAME ${TEST_LIST})

     

       27
       27
       -
           add_executable(${TEST_NAME} tests/${TEST_NAME}.cpp core.cpp)

     

       27
       27
       +
           add_executable(${TEST_NAME} tests/${TEST_NAME}.cpp core.cpp helpers.cpp)

     

       28
       28
        
           target_link_libraries(${TEST_NAME} PRIVATE SDL3::SDL3)

     

       29
       29
        
           target_include_directories(${TEST_NAME} PRIVATE SDL/include/SDL3)

     

       30
       30
        
           add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})

+11 -45

core.cpp

···

       1
       1
        
       #include "core.h"

     

       2
       2
       +
       #include "helpers.h"

     

       2
       3
        
       

     

       3
       4
        
       #include <cassert>

     

       4
       5
        
       #include <math.h>

     
···

       221
       222
        
           return false;

     

       222
       223
        
       }

     

       223
       224
        
       

     

       224
       224
       -
       uint64_t total_moves_evaluated = 0;

     

       225
       225
       -
       uint64_t wins_found = 0;

     

       226
       226
       -
       uint64_t dead_ends_found = 0;

     

       227
       227
       -
       uint8_t min_depth = 50;

     

       225
       225
       +
       uint64_t total_moves_evaluated;

     

       226
       226
       +
       uint64_t wins_found;

     

       227
       227
       +
       uint64_t dead_ends_found;

     

       228
       228
       +
       uint8_t min_depth;

     

       228
       229
        
       uint64_t time_of_last_print;

     

       229
       230
        
       uint64_t get_move_score_start_time;

     

       230
       231
        
       

     

       231
       231
       -
       void sprint_friendly_time(double_t total_seconds, char* buffer)

     

       232
       232
       -
       {

     

       233
       233
       -
           uint32_t days = (uint32_t)(total_seconds / (60 * 60 * 24));

     

       234
       234
       -
           total_seconds -= days * 60.0 * 60.0 * 24.0;

     

       235
       235
       -
           uint32_t hours = (uint32_t)(total_seconds / (60 * 60));

     

       236
       236
       -
           total_seconds -= hours * 60.0 * 60.0;

     

       237
       237
       -
           uint32_t minutes = (uint32_t)(total_seconds / 60);

     

       238
       238
       -
           total_seconds -= minutes * 60.0;

     

       239
       239
       -
           uint32_t seconds = (uint32_t)total_seconds;

     

       240
       240
       -
       

     

       241
       241
       -
           if (days > 0)

     

       242
       242
       -
           {

     

       243
       243
       -
               snprintf(buffer, 256, "%d day%s, %d hour%s, %d minute%s, %d second%s",

     

       244
       244
       -
                   days, days > 1 ? "s" : "",

     

       245
       245
       -
                   hours, hours > 1 ? "s" : "",

     

       246
       246
       -
                   minutes, minutes > 1 ? "s" : "",

     

       247
       247
       -
                   seconds, seconds > 1 ? "s": "");

     

       248
       248
       -
           }

     

       249
       249
       -
           else if (hours > 0)

     

       250
       250
       -
           {

     

       251
       251
       -
               snprintf(buffer, 256, "%d hour%s, %d minute%s, %d second%s",

     

       252
       252
       -
                   hours, hours > 1 ? "s" : "",

     

       253
       253
       -
                   minutes, minutes > 1 ? "s" : "",

     

       254
       254
       -
                   seconds, seconds > 1 ? "s": "");

     

       255
       255
       -
           }

     

       256
       256
       -
           else if (minutes > 0)

     

       257
       257
       -
           {

     

       258
       258
       -
               snprintf(buffer, 256, "%d minute%s, %d second%s",

     

       259
       259
       -
                   minutes, minutes > 1 ? "s" : "",

     

       260
       260
       -
                   seconds, seconds > 1 ? "s": "");

     

       261
       261
       -
           }

     

       262
       262
       -
           else

     

       263
       263
       -
           {

     

       264
       264
       -
               snprintf(buffer, 256, "%d second%s",

     

       265
       265
       -
                   seconds, seconds > 1 ? "s": "");

     

       266
       266
       -
           }

     

       267
       267
       -
       }

     

       268
       268
       -
       

     

       269
       232
        
       int32_t get_move_score(uint8_t player, uint8_t player_this_turn, uint8_t col, BoardState state, bool *move_possible, uint8_t depth)

     

       270
       233
        
       {

     

       271
       234
        
           uint64_t time_current = SDL_GetTicks();

     
···

       279
       242
        
       

     

       280
       243
        
               printf("Total moves: %llu (%f%%), wins found: %llu, dead-ends found: %llu, depth: %d\n", total_moves_evaluated, percent_completed, wins_found, dead_ends_found, min_depth);

     

       281
       244
        
       

     

       282
       282
       -
               char* friendly_time_string = (char*)malloc(sizeof(char) * 512);

     

       245
       245
       +
               char friendly_time_string[256];

     

       283
       246
        
               sprint_friendly_time(time_to_complete, friendly_time_string);

     

       284
       247
        
               printf("- Time to complete: %s\n", friendly_time_string);

     

       285
       285
       -
               free(friendly_time_string);

     

       286
       248
        
           }

     

       287
       249
        
       

     

       288
       250
        
           BoardState state_new;

     

       289
       251
        
           memcpy(state_new, state, sizeof(BoardState));

     

       290
       290
       -
           int8_t row = make_move(player_this_turn, col, state_new);

     

       252
       252
       +
           int8_t row = make_move_lookup_full(player_this_turn, col, state_new);

     

       291
       253
        
           *move_possible = row >= 0;

     

       292
       254
        
           if (*move_possible == false)

     

       293
       255
        
           {

     
···

       326
       288
        
           bool move_possible;

     

       327
       289
        
           get_move_score_start_time = SDL_GetTicks();

     

       328
       290
        
           time_of_last_print = get_move_score_start_time;

     

       291
       291
       +
           total_moves_evaluated = 0;

     

       292
       292
       +
           wins_found = 0;

     

       293
       293
       +
           dead_ends_found = 0;

     

       294
       294
       +
           min_depth = 50;

     

       329
       295
        
       

     

       330
       296
        
           return get_move_score(0, 0, 0, state, &move_possible, 1);

     

       331
       297
        
       }

+41

helpers.cpp

···

       1
       1
       +
       #include "helpers.h"

     

       2
       2
       +
       

     

       3
       3
       +
       #include <stdio.h>

     

       4
       4
       +
       

     

       5
       5
       +
       void sprint_friendly_time(double_t total_seconds, char buffer[256])

     

       6
       6
       +
       {

     

       7
       7
       +
           uint32_t days = (uint32_t)(total_seconds / (60 * 60 * 24));

     

       8
       8
       +
           total_seconds -= days * 60.0 * 60.0 * 24.0;

     

       9
       9
       +
           uint32_t hours = (uint32_t)(total_seconds / (60 * 60));

     

       10
       10
       +
           total_seconds -= hours * 60.0 * 60.0;

     

       11
       11
       +
           uint32_t minutes = (uint32_t)(total_seconds / 60);

     

       12
       12
       +
           total_seconds -= minutes * 60.0;

     

       13
       13
       +
           uint32_t seconds = (uint32_t)total_seconds;

     

       14
       14
       +
       

     

       15
       15
       +
           if (days > 0)

     

       16
       16
       +
           {

     

       17
       17
       +
               snprintf(buffer, 256, "%d day%s, %d hour%s, %d minute%s, %d second%s",

     

       18
       18
       +
                   days, days > 1 ? "s" : "",

     

       19
       19
       +
                   hours, hours > 1 ? "s" : "",

     

       20
       20
       +
                   minutes, minutes > 1 ? "s" : "",

     

       21
       21
       +
                   seconds, seconds > 1 ? "s": "");

     

       22
       22
       +
           }

     

       23
       23
       +
           else if (hours > 0)

     

       24
       24
       +
           {

     

       25
       25
       +
               snprintf(buffer, 256, "%d hour%s, %d minute%s, %d second%s",

     

       26
       26
       +
                   hours, hours > 1 ? "s" : "",

     

       27
       27
       +
                   minutes, minutes > 1 ? "s" : "",

     

       28
       28
       +
                   seconds, seconds > 1 ? "s": "");

     

       29
       29
       +
           }

     

       30
       30
       +
           else if (minutes > 0)

     

       31
       31
       +
           {

     

       32
       32
       +
               snprintf(buffer, 256, "%d minute%s, %d second%s",

     

       33
       33
       +
                   minutes, minutes > 1 ? "s" : "",

     

       34
       34
       +
                   seconds, seconds > 1 ? "s": "");

     

       35
       35
       +
           }

     

       36
       36
       +
           else

     

       37
       37
       +
           {

     

       38
       38
       +
               snprintf(buffer, 256, "%d second%s",

     

       39
       39
       +
                   seconds, seconds > 1 ? "s": "");

     

       40
       40
       +
           }

     

       41
       41
       +
       }

+5

helpers.h

···

       1
       1
       +
       #pragma once

     

       2
       2
       +
       

     

       3
       3
       +
       #include <math.h>

     

       4
       4
       +
       

     

       5
       5
       +
       void sprint_friendly_time(double_t total_seconds, char buffer[256]);

+1 -1

main.cpp

···

       9
       9
        
       

     

       10
       10
        
       int main()

     

       11
       11
        
       {

     

       12
       12
       -
           SDL_Init(0);

     

       12
       12
       +
           init_core();

     

       13
       13
        
       

     

       14
       14
        
           BoardState state = { 1, 1, 1, 1, 1, 1, 1 };

     

       15
       15
        
           uint8_t player = 0;

+11

profile.cpp

···

       1
       1
        
       #include "core.h"

     

       2
       2
       +
       #include "helpers.h"

     

       2
       3
        
       

     

       3
       4
        
       #include <math.h>

     

       4
       5
        
       #include "SDL.h"

     
···

       66
       67
        
           double_t make_move_num_per_us = 1000 / make_move_avg_time_ns;

     

       67
       68
        
           printf("%s(): %f times / μs. (total time to make %llu moves: %f ms\n", label, make_move_num_per_us, total_num_moves, make_move_total_time_ns / 1000000);

     

       68
       69
        
       

     

       70
       70
       +
           double_t make_move_time_to_finish_sec = ((double_t)(make_move_end_time - make_move_start_time) / SDL_GetPerformanceFrequency()) * (4531985219092.0 / total_num_moves);

     

       71
       71
       +
           char make_move_time_to_finish_str[256];

     

       72
       72
       +
           sprint_friendly_time(make_move_time_to_finish_sec, make_move_time_to_finish_str);

     

       73
       73
       +
           printf("-- Time to complete 4531985219092 moves: %s.\n", make_move_time_to_finish_str);

     

       74
       74
       +
       

     

       69
       75
        
           bool* wins = (bool*)malloc(sizeof(bool) * NUM_GAMES); // basically just to keep the compiler from optimizing out check_for_win

     

       70
       76
        
           uint64_t check_for_win_start_time = SDL_GetPerformanceCounter();

     

       71
       77
        
           for (uint64_t i = 0; i < NUM_GAMES; ++i)

     
···

       78
       84
        
           double_t check_for_win_avg_time_ns = check_for_win_total_time_ns / NUM_GAMES;

     

       79
       85
        
           double_t check_for_win_num_per_us = 1000 / check_for_win_avg_time_ns;

     

       80
       86
        
           printf("check_for_win(): %f times / μs. (total time to check %llu games: %f ms\n", check_for_win_num_per_us, NUM_GAMES, check_for_win_total_time_ns / 1000000);

     

       87
       87
       +
       

     

       88
       88
       +
           double_t check_for_win_time_to_finish_sec = ((double_t)(check_for_win_end_time - check_for_win_start_time) / SDL_GetPerformanceFrequency()) * (4531985219092.0 / NUM_GAMES);

     

       89
       89
       +
           char check_for_win_time_to_finish_str[256];

     

       90
       90
       +
           sprint_friendly_time(check_for_win_time_to_finish_sec, check_for_win_time_to_finish_str);

     

       91
       91
       +
           printf("-- Time to check 4531985219092 states: %s.\n", check_for_win_time_to_finish_str);

     

       81
       92
        
       }

     

       82
       93
        
       

     

       83
       94
        
       int main()