commit 5361d843fa6c3fdcbdba112b62b97d6fc692f580 · singingpigs.online/connect-four

CMakeLists.txt

···

       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
       +
       target_compile_options(ConnectFour PRIVATE -Wunused-variable)

     

       10
       11
        
       

     

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

     

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

+100 -50

core.cpp

···

       273
       273
        
       uint64_t time_of_last_print;

     

       274
       274
        
       uint64_t get_move_score_start_time;

     

       275
       275
        
       

     

       276
       276
       -
       int32_t get_move_score(uint8_t player, uint8_t player_this_turn, uint8_t col, BoardState state, bool *move_possible, uint8_t depth)

     

       276
       276
       +
       struct MoveEvalNode

     

       277
       277
        
       {

     

       278
       278
       -
           uint64_t time_current = SDL_GetTicks();

     

       279
       279
       -
           if (time_current - time_of_last_print >= 1000)

     

       278
       278
       +
           uint8_t curr_move_column = 0;

     

       279
       279
       +
           BoardState state;

     

       280
       280
       +
           int64_t score = 0;

     

       281
       281
       +
       };

     

       282
       282
       +
       

     

       283
       283
       +
       void get_move_scores(int64_t final_scores[7])

     

       284
       284
       +
       {

     

       285
       285
       +
           MoveEvalNode nodes[44];

     

       286
       286
       +
           init_board(nodes[0].state);

     

       287
       287
       +
       

     

       288
       288
       +
           get_move_score_start_time = SDL_GetTicks();

     

       289
       289
       +
           time_of_last_print = get_move_score_start_time;

     

       290
       290
       +
           total_moves_evaluated = 0;

     

       291
       291
       +
           wins_found = 0;

     

       292
       292
       +
           dead_ends_found = 0;

     

       293
       293
       +
           min_depth = 50;

     

       294
       294
       +
       

     

       295
       295
       +
           int8_t depth = 0;

     

       296
       296
       +
           uint8_t player = 0;

     

       297
       297
       +
           uint8_t player_this_turn = 0;

     

       298
       298
       +
           while (depth >= 0)

     

       280
       299
        
           {

     

       281
       281
       -
               time_of_last_print = time_current;

     

       300
       300
       +
               // Print status update every 100 ms.

     

       301
       301
       +
               uint64_t time_current = SDL_GetTicks();

     

       302
       302
       +
               if (time_current - time_of_last_print >= 1000)

     

       303
       303
       +
               {

     

       304
       304
       +
                   print_board(nodes[depth].state);

     

       282
       305
        
       

     

       283
       283
       -
               double_t percent_completed = 100.0 * total_moves_evaluated / 4531985219092;

     

       284
       284
       -
               uint64_t time_elapsed = time_current - get_move_score_start_time;

     

       285
       285
       -
               double_t time_to_complete = (time_elapsed / 1000.0) * (100.0 / percent_completed);

     

       306
       306
       +
                   time_of_last_print = time_current;

     

       286
       307
        
       

     

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

     

       308
       308
       +
                   double_t percent_completed = 100.0 * total_moves_evaluated / 4531985219092;

     

       309
       309
       +
                   uint64_t time_elapsed = time_current - get_move_score_start_time;

     

       310
       310
       +
                   double_t time_to_complete = (time_elapsed / 1000.0) * (100.0 / percent_completed);

     

       288
       311
        
       

     

       289
       289
       -
               char friendly_time_string[256];

     

       290
       290
       -
               sprint_friendly_time(time_to_complete, friendly_time_string);

     

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

     

       292
       292
       -
           }

     

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

     

       293
       313
        
       

     

       294
       294
       -
           BoardState state_new;

     

       295
       295
       -
           memcpy(state_new, state, sizeof(BoardState));

     

       296
       296
       -
           int8_t row = make_move_lookup_full(player_this_turn, col, state_new);

     

       297
       297
       -
           *move_possible = row >= 0;

     

       298
       298
       -
           if (*move_possible == false)

     

       299
       299
       -
           {

     

       300
       300
       -
               ++dead_ends_found;

     

       314
       314
       +
                   char friendly_time_string[256];

     

       315
       315
       +
                   sprint_friendly_time(time_to_complete, friendly_time_string);

     

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

     

       317
       317
       +
               }

     

       301
       318
        
       

     

       302
       302
       -
               return 0;

     

       303
       303
       -
           }

     

       319
       319
       +
               // Make move from current node to next node, based on curr_move_column.

     

       320
       320
       +
               memcpy(nodes[depth + 1].state, nodes[depth].state, sizeof(BoardState));

     

       321
       321
       +
               int8_t row = make_move_lookup_full(player_this_turn, nodes[depth].curr_move_column, nodes[depth + 1].state);

     

       304
       322
        
       

     

       305
       305
       -
           ++total_moves_evaluated;

     

       323
       323
       +
               bool move_to_next_column = false;

     

       306
       324
        
       

     

       307
       307
       -
           bool result = check_for_win(state_new, player_this_turn, row, col);

     

       308
       308
       -
           if (result)

     

       309
       309
       -
           {

     

       310
       310
       -
               ++wins_found;

     

       325
       325
       +
               if (row < 0)

     

       326
       326
       +
               {

     

       327
       327
       +
                   // Move not possible.

     

       328
       328
       +
                   ++dead_ends_found;

     

       311
       329
        
       

     

       312
       312
       -
               return 0;

     

       313
       313
       -
           }

     

       330
       330
       +
                   move_to_next_column = true;

     

       331
       331
       +
               }

     

       332
       332
       +
               else

     

       333
       333
       +
               {

     

       334
       334
       +
                   ++total_moves_evaluated;

     

       335
       335
       +
                   if (check_for_win(nodes[depth + 1].state, player_this_turn, row, nodes[depth].curr_move_column))

     

       336
       336
       +
                   {

     

       337
       337
       +
                       ++wins_found;

     

       338
       338
       +
                   

     

       339
       339
       +
                       // Dumb little score function just to get the functionality right.

     

       340
       340
       +
                       nodes[depth].score += player_this_turn == player ? 1 : -1;

     

       314
       341
        
       

     

       315
       315
       -
           int32_t total_score = 0;

     

       316
       316
       -
           player_this_turn = 1 - player_this_turn;

     

       317
       317
       -
           for (uint8_t col = 0; col < 7; ++col)

     

       318
       318
       -
           {

     

       319
       319
       -
               bool temp_move_possible;

     

       320
       320
       -
               total_score += get_move_score(player, player_this_turn, col, state_new, &temp_move_possible, depth + 1);

     

       321
       321
       -
           }

     

       342
       342
       +
                       move_to_next_column = true;

     

       343
       343
       +
                   }

     

       344
       344
       +
                   else

     

       345
       345
       +
                   {

     

       346
       346
       +
                       // If this is not a win or dead end, we'll move down to the next node.

     

       347
       347
       +
                       ++depth;

     

       348
       348
       +
                       nodes[depth].curr_move_column = 0;

     

       349
       349
       +
                       nodes[depth].score = 0;

     

       350
       350
       +
                       player_this_turn = 1 - player_this_turn;

     

       351
       351
       +
                   }

     

       352
       352
       +
               }

     

       322
       353
        
       

     

       323
       323
       -
           min_depth = depth < min_depth ? depth : min_depth;

     

       354
       354
       +
               // Move to next column, and backtrack if needed.

     

       355
       355
       +
               if (move_to_next_column)

     

       356
       356
       +
               {

     

       357
       357
       +
                   // Next column.

     

       358
       358
       +
                   ++nodes[depth].curr_move_column;

     

       359
       359
       +
       

     

       360
       360
       +
                   // If we've checked every column...

     

       361
       361
       +
                   while (nodes[depth].curr_move_column >= 7)

     

       362
       362
       +
                   {

     

       363
       363
       +
                       min_depth = depth < min_depth ? depth : min_depth;

     

       324
       364
        
       

     

       325
       325
       -
           return total_score;

     

       326
       326
       -
       }

     

       365
       365
       +
                       // Go back up a node (and exit out if we're going past the top).

     

       366
       366
       +
                       --depth;

     

       367
       367
       +
                       if (depth < 0)

     

       368
       368
       +
                           break;

     

       327
       369
        
       

     

       328
       328
       -
       // @TODO: lol this function still only gets the move score for one move, gotta get back to that

     

       329
       329
       -
       int32_t get_move_score_full()

     

       330
       330
       -
       {

     

       331
       331
       -
           BoardState state = { 1, 1, 1, 1, 1, 1, 1 };

     

       332
       332
       -
           bool move_possible;

     

       333
       333
       -
           get_move_score_start_time = SDL_GetTicks();

     

       334
       334
       -
           time_of_last_print = get_move_score_start_time;

     

       335
       335
       -
           total_moves_evaluated = 0;

     

       336
       336
       -
           wins_found = 0;

     

       337
       337
       -
           dead_ends_found = 0;

     

       338
       338
       -
           min_depth = 50;

     

       370
       370
       +
                       // If we're at the top...

     

       371
       371
       +
                       if (depth == 0)

     

       372
       372
       +
                       {

     

       373
       373
       +
                           // Record this move's score.

     

       374
       374
       +
                           final_scores[nodes[depth].curr_move_column] = nodes[depth + 1].score;

     

       375
       375
       +
                       }

     

       376
       376
       +
                       // Otherwise...

     

       377
       377
       +
                       else

     

       378
       378
       +
                       {

     

       379
       379
       +
                           // Add score from child node.

     

       380
       380
       +
                           nodes[depth].score += nodes[depth + 1].score;

     

       381
       381
       +
                       }

     

       339
       382
        
       

     

       340
       340
       -
           return get_move_score(0, 0, 0, state, &move_possible, 1);

     

       383
       383
       +
                       // Reset and go to next column.

     

       384
       384
       +
                       nodes[depth + 1].curr_move_column = 0;

     

       385
       385
       +
                       nodes[depth + 1].score = 0;

     

       386
       386
       +
                       ++nodes[depth].curr_move_column;

     

       387
       387
       +
                       player_this_turn = 1 - player_this_turn;

     

       388
       388
       +
                   }

     

       389
       389
       +
               }

     

       390
       390
       +
           }

     

       341
       391
        
       }

     

       342
       392
        
       

     

       343
       393
        
       void sprint_board(BoardState state, char* buffer)

+1 -2

core.h

···

       44
       44
        
       

     

       45
       45
        
       bool check_for_win(BoardState state, uint8_t last_move_player, uint8_t last_move_row, uint8_t last_move_col);

     

       46
       46
        
       bool check_for_win(BoardState state);

     

       47
       47
       -
       int32_t get_move_score(uint8_t player, uint8_t player_this_turn, uint8_t col, BoardState state, bool *move_possible, uint8_t depth);

     

       48
       48
       -
       int32_t get_move_score_full();

     

       47
       47
       +
       void get_move_scores(int64_t final_scores[7]);

     

       49
       48
        
       void sprint_board(BoardState state, char* buffer);

     

       50
       49
        
       void print_board(BoardState state);

+3 -5

main.cpp

···

       11
       11
        
       {

     

       12
       12
        
           init_core();

     

       13
       13
        
       

     

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

     

       15
       15
       -
           uint8_t player = 0;

     

       16
       16
       -
       

     

       17
       14
        
           // for (uint8_t row = 0; row < 6; ++row)

     

       18
       15
        
           // {

     

       19
       16
        
           //     for (uint8_t col = 0; col < 7; ++col)

     
···

       60
       57
        
               //     break;

     

       61
       58
        
               // }

     

       62
       59
        
       

     

       63
       63
       -
               int32_t move_score = get_move_score_full();

     

       60
       60
       +
               int64_t final_scores[7];

     

       61
       61
       +
               get_move_scores(final_scores);

     

       64
       62
        
       

     

       65
       63
        
               // uint64_t eval_end_time = SDL_GetPerformanceCounter();

     

       66
       64
        
               // printf("Time to finish evaluation: %ld\n", (eval_end_time - eval_start_time) / 1000);

     

       67
       67
       -
               printf("Column 0 move score: %d\n", move_score);

     

       65
       65
       +
               // printf("Column 0 move score: %d\n", move_score);

     

       68
       66
        
       

     

       69
       67
        
               // // Wait for move

     

       70
       68
        
               // printf("Player %d, what's your move?\n", player);