commit 655dfb3826b50c4d151424a098d5c236c1706bd3 · singingpigs.online/connect-four

+52 -41

core.cpp

···

       9
       9
        
       struct WinningBoardCollection

     

       10
       10
        
       {

     

       11
       11
        
           uint8_t num_boards;

     

       12
       12
       -
           uint64_t* boards;

     

       12
       12
       +
           binary_board* boards;

     

       13
       13
        
       };

     

       14
       14
        
       

     

       15
       15
        
       MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       16
       16
        
       MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       17
       17
        
       

     

       18
       18
       -
       const uint8_t CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE = 0b01111111;

     

       18
       18
       +
       const uint8_t CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE = MAX_FULL_COLUMN + 1;

     

       19
       19
        
       uint8_t check_for_win_processed_column_table[2][CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE];

     

       20
       20
       -
       WinningBoardCollection check_for_win_processed_winning_boards_table[6][7];

     

       20
       20
       +
       WinningBoardCollection check_for_win_processed_winning_boards_table[NUM_ROWS][NUM_COLUMNS];

     

       21
       21
        
       

     

       22
       22
        
       void init_board(BoardState state)

     

       23
       23
        
       {

     

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

     

       24
       24
       +
           for (uint8_t col = 0; col < NUM_COLUMNS; ++col)

     

       25
       25
        
           {

     

       26
       26
        
               state[col] = 1;

     

       27
       27
        
           }

     
···

       29
       29
        
       

     

       30
       30
        
       inline int8_t get_board_value(BoardState state, uint8_t row, uint8_t col)

     

       31
       31
        
       {

     

       32
       32
       -
           assert(row < 6 && col < 7);

     

       32
       32
       +
           assert(row < NUM_ROWS && col < NUM_COLUMNS);

     

       33
       33
        
       

     

       34
       34
        
           return state[col] < (1 << (row + 1)) ? -1 : ((state[col] & (1 << row)) >> row);

     

       35
       35
        
       }

     

       36
       36
        
       

     

       37
       37
        
       int8_t make_move_column(uint8_t player, uint8_t* column_state)

     

       38
       38
        
       {

     

       39
       39
       -
           if (*column_state >= 0b01000000)

     

       39
       39
       +
           if (*column_state >= MIN_FULL_COLUMN)

     

       40
       40
        
               return -1;

     

       41
       41
        
       

     

       42
       42
        
           uint8_t mask = *column_state;      // 0011 0000 (example)

     
···

       73
       73
        
           }

     

       74
       74
        
       }

     

       75
       75
        
       

     

       76
       76
       -
       inline uint64_t bit_set(uint64_t num, uint8_t row, uint8_t col)

     

       76
       76
       +
       inline binary_board bit_set(binary_board num, uint8_t row, uint8_t col)

     

       77
       77
        
       {

     

       78
       78
       -
           return num | ((uint64_t)1 << (col * 8 + (row)));

     

       78
       78
       +
           return num | ((binary_board)1 << (col * 8 + (row)));

     

       79
       79
        
       }

     

       80
       80
        
       

     

       81
       81
        
       void init_core()

     
···

       86
       86
        
           for (uint8_t player = 0; player < 2; ++player)

     

       87
       87
        
           {

     

       88
       88
        
               make_move_table_partial[player][0] = MakeMoveResult { -1, 0 };

     

       89
       89
       -
               for (uint8_t column_state = 1; column_state < 0b01000000; ++column_state)

     

       89
       89
       +
               for (uint8_t column_state = 1; column_state < MAKE_MOVE_TABLE_PARTIAL_SIZE; ++column_state)

     

       90
       90
        
               {

     

       91
       91
        
                   MakeMoveResult result;

     

       92
       92
        
                   result.column_state = column_state;

     
···

       137
       137
        
           }

     

       138
       138
        
       

     

       139
       139
        
           // Building check_for_win winning board lookup table

     

       140
       140
       -
           for (uint8_t table_row = 0; table_row < 6; ++table_row)

     

       140
       140
       +
           for (uint8_t table_row = 0; table_row < NUM_ROWS; ++table_row)

     

       141
       141
        
           {

     

       142
       142
       -
               for (uint8_t table_col = 0; table_col < 7; ++table_col)

     

       142
       142
       +
               for (uint8_t table_col = 0; table_col < NUM_COLUMNS; ++table_col)

     

       143
       143
        
               {

     

       144
       144
       -
                   uint64_t boards[32];

     

       144
       144
       +
                   binary_board boards[32];

     

       145
       145
        
                   uint8_t num_boards = 0;

     

       146
       146
        
       

     

       147
       147
        
                   // Vertical

     

       148
       148
       -
                   for (uint8_t row_start = 0; row_start < 3; ++row_start)

     

       148
       148
       +
                   for (uint8_t row_start = 0; row_start <= (NUM_ROWS - NUM_TO_WIN); ++row_start)

     

       149
       149
        
                   {

     

       150
       150
       -
                       uint64_t winning_board_state = 0;

     

       151
       151
       -
                       for (uint8_t row_offset = 0; row_offset < 4; ++row_offset)

     

       150
       150
       +
                       binary_board winning_board_state = 0;

     

       151
       151
       +
                       for (uint8_t row_offset = 0; row_offset < NUM_TO_WIN; ++row_offset)

     

       152
       152
        
                       {

     

       153
       153
        
                           winning_board_state = bit_set(winning_board_state, row_start + row_offset, table_col);

     

       154
       154
        
                       }

     
···

       158
       158
        
                   }

     

       159
       159
        
       

     

       160
       160
        
                   // Horizontal

     

       161
       161
       -
                   for (uint8_t col_start = 0; col_start < 4; ++col_start)

     

       161
       161
       +
                   for (uint8_t col_start = 0; col_start <= (NUM_COLUMNS - NUM_TO_WIN); ++col_start)

     

       162
       162
        
                   {

     

       163
       163
       -
                       uint64_t winning_board_state = 0;

     

       164
       164
       -
                       for (uint8_t col_offset = 0; col_offset < 4; ++col_offset)

     

       163
       163
       +
                       binary_board winning_board_state = 0;

     

       164
       164
       +
                       for (uint8_t col_offset = 0; col_offset < NUM_TO_WIN; ++col_offset)

     

       165
       165
        
                       {

     

       166
       166
        
                           winning_board_state = bit_set(winning_board_state, table_row, col_start + col_offset);

     

       167
       167
        
                       }

     
···

       180
       180
        
                           --diag_col;

     

       181
       181
        
                       }

     

       182
       182
        
       

     

       183
       183
       -
                       while (diag_row + 4 <= 6 && diag_col + 4 <= 7)

     

       183
       183
       +
                       while (diag_row + NUM_TO_WIN <= NUM_ROWS && diag_col + NUM_TO_WIN <= NUM_COLUMNS)

     

       184
       184
        
                       {

     

       185
       185
       -
                           uint64_t winning_board_state = 0;

     

       186
       186
       -
                           for (uint8_t i = 0; i < 4; ++i)

     

       185
       185
       +
                           binary_board winning_board_state = 0;

     

       186
       186
       +
                           for (uint8_t i = 0; i < NUM_TO_WIN; ++i)

     

       187
       187
        
                           {

     

       188
       188
        
                               winning_board_state = bit_set(winning_board_state, diag_row + i, diag_col + i);

     

       189
       189
        
                           }

     
···

       200
       200
        
                   {

     

       201
       201
        
                       int8_t diag_row = table_row;

     

       202
       202
        
                       uint8_t diag_col = table_col;

     

       203
       203
       -
                       while (diag_row + 1 < 6 && diag_col > 0)

     

       203
       203
       +
                       while (diag_row + 1 < NUM_ROWS && diag_col > 0)

     

       204
       204
        
                       {

     

       205
       205
        
                           ++diag_row;

     

       206
       206
        
                           --diag_col;

     

       207
       207
        
                       }

     

       208
       208
        
       

     

       209
       209
       -
                       while ((diag_row + 1) - 4 >= 0 && diag_col + 4 <= 7)

     

       209
       209
       +
                       while ((diag_row + 1) - NUM_TO_WIN >= 0 && diag_col + NUM_TO_WIN <= NUM_COLUMNS)

     

       210
       210
        
                       {

     

       211
       211
       -
                           uint64_t winning_board_state = 0;

     

       212
       212
       -
                           for (uint8_t i = 0; i < 4; ++i)

     

       211
       211
       +
                           binary_board winning_board_state = 0;

     

       212
       212
       +
                           for (uint8_t i = 0; i < NUM_TO_WIN; ++i)

     

       213
       213
        
                           {

     

       214
       214
        
                               winning_board_state = bit_set(winning_board_state, diag_row - i, diag_col + i);

     

       215
       215
        
                           }

     
···

       224
       224
        
       

     

       225
       225
        
                   WinningBoardCollection board_collection;

     

       226
       226
        
                   board_collection.num_boards = num_boards;

     

       227
       227
       -
                   board_collection.boards = (uint64_t*)malloc(num_boards * sizeof(uint64_t));

     

       228
       228
       -
                   memcpy(board_collection.boards, boards, num_boards * sizeof(uint64_t));

     

       227
       227
       +
                   board_collection.boards = (binary_board*)malloc(num_boards * sizeof(binary_board));

     

       228
       228
       +
                   memcpy(board_collection.boards, boards, num_boards * sizeof(binary_board));

     

       229
       229
        
       

     

       230
       230
        
                   check_for_win_processed_winning_boards_table[table_row][table_col] = board_collection;

     

       231
       231
        
               }

     
···

       234
       234
        
       

     

       235
       235
        
       int8_t make_move(uint8_t player, uint8_t column, BoardState state)

     

       236
       236
        
       {

     

       237
       237
       -
           assert(column >= 0 && column < 7);

     

       237
       237
       +
           assert(column >= 0 && column < NUM_COLUMNS);

     

       238
       238
        
       

     

       239
       239
        
           return make_move_column(player, &state[column]);

     

       240
       240
        
       }

     
···

       242
       242
        
       bool check_for_win(BoardState state, uint8_t last_move_player, uint8_t last_move_row, uint8_t last_move_col)

     

       243
       243
        
       {

     

       244
       244
        
           assert(last_move_player <= 1);

     

       245
       245
       -
           assert(last_move_row < 6 && last_move_col < 7);

     

       245
       245
       +
           assert(last_move_row < NUM_ROWS && last_move_col < NUM_COLUMNS);

     

       246
       246
        
       

     

       247
       247
       -
           uint8_t processed_board_state[8] = { 0 };

     

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

     

       247
       247
       +
           uint8_t processed_board_state[NUM_COLUMNS_PROCESSED] = { 0 };

     

       248
       248
       +
           for (uint8_t col = 0; col < NUM_COLUMNS; ++col)

     

       249
       249
        
           {

     

       250
       250
       -
               assert(state[col] < 0b10000000);

     

       250
       250
       +
               assert(state[col] < MAX_FULL_COLUMN + 1);

     

       251
       251
        
               processed_board_state[col] = check_for_win_processed_column_table[last_move_player][state[col]];

     

       252
       252
        
           }

     

       253
       253
        
       

     

       254
       254
       -
           uint64_t* processed_board_state_binary = (uint64_t*)processed_board_state;

     

       254
       254
       +
           binary_board* processed_board_state_binary = (binary_board*)processed_board_state;

     

       255
       255
        
       

     

       256
       256
        
           WinningBoardCollection winning_boards = check_for_win_processed_winning_boards_table[last_move_row][last_move_col];

     

       257
       257
        
           for (uint8_t i = 0; i < winning_boards.num_boards; ++i)

     

       258
       258
        
           {

     

       259
       259
       -
               uint64_t winning_board_state = winning_boards.boards[i];

     

       259
       259
       +
               binary_board winning_board_state = winning_boards.boards[i];

     

       260
       260
        
               if ((winning_board_state & *processed_board_state_binary) == winning_board_state)

     

       261
       261
        
               {

     

       262
       262
        
                   return true;

     
···

       280
       280
        
           int64_t score = 0;

     

       281
       281
        
       };

     

       282
       282
        
       

     

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

     

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

     

       284
       284
        
       {

     

       285
       285
        
           MoveEvalNode nodes[44];

     

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

     
···

       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)

     

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

     

       362
       362
        
                   {

     

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

     

       364
       364
        
       

     
···

       392
       392
        
       

     

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

     

       394
       394
        
       {

     

       395
       395
       -
           snprintf(buffer, 256, "_1_2_3_4_5_6_7_\n");

     

       396
       396
       -
           buffer += 16;

     

       397
       397
       -
           for (int8_t row = 6 - 1; row >= 0; --row)

     

       395
       395
       +
           for (uint8_t i = 0; i < NUM_COLUMNS; ++i)

     

       396
       396
       +
           {

     

       397
       397
       +
               snprintf(buffer, 256, "_%d", i + 1);

     

       398
       398
       +
               buffer += 2;

     

       399
       399
       +
           }

     

       400
       400
       +
       

     

       401
       401
       +
           snprintf(buffer, 256, "_\n");

     

       402
       402
       +
           buffer += 2;

     

       403
       403
       +
           for (int8_t row = NUM_ROWS - 1; row >= 0; --row)

     

       398
       404
        
           {

     

       399
       405
        
               snprintf(buffer, 256, "|");

     

       400
       406
        
               buffer += 1;

     

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

     

       407
       407
       +
               for (uint8_t col = 0; col < NUM_COLUMNS; ++col)

     

       402
       408
        
               {

     

       403
       409
        
                   switch (get_board_value(state, row, col))

     

       404
       410
        
                   {

     
···

       422
       428
        
               snprintf(buffer, 256, "\n");

     

       423
       429
        
               buffer += 1;

     

       424
       430
        
           }

     

       425
       425
       -
           snprintf(buffer, 256, "‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n");

     

       431
       431
       +
           for (uint8_t i = 0; i < NUM_COLUMNS; ++i)

     

       432
       432
       +
           {

     

       433
       433
       +
               snprintf(buffer, 256, "--");

     

       434
       434
       +
               buffer += 2;

     

       435
       435
       +
           }

     

       436
       436
       +
           snprintf(buffer, 256, "‾\n");

     

       426
       437
        
       }

     

       427
       438
        
       

     

       428
       439
        
       void print_board(BoardState state)

+16 -7

core.h

···

       3
       3
        
       #include <cassert>

     

       4
       4
        
       #include <stdint.h>

     

       5
       5
        
       

     

       6
       6
       -
       typedef uint8_t BoardState[7];

     

       6
       6
       +
       const uint8_t NUM_ROWS = 6;

     

       7
       7
       +
       const uint8_t NUM_COLUMNS = 7;

     

       8
       8
       +
       const uint8_t NUM_TO_WIN = 4;

     

       9
       9
       +
       const uint8_t MIN_FULL_COLUMN = 0b01000000;

     

       10
       10
       +
       const uint8_t MAX_FULL_COLUMN = 0b01111111;

     

       11
       11
       +
       typedef uint64_t binary_board;

     

       12
       12
       +
       

     

       13
       13
       +
       const uint8_t NUM_COLUMNS_PROCESSED = (uint8_t)sizeof(binary_board);

     

       14
       14
       +
       

     

       15
       15
       +
       typedef uint8_t BoardState[NUM_COLUMNS];

     

       7
       16
        
       

     

       8
       17
        
       void init_board(BoardState state);

     

       9
       18
        
       void init_core();

     
···

       15
       24
        
           uint8_t column_state;

     

       16
       25
        
       };

     

       17
       26
        
       

     

       18
       18
       -
       const uint8_t MAKE_MOVE_TABLE_PARTIAL_SIZE = 0b01000000;

     

       19
       19
       -
       const uint8_t MAKE_MOVE_TABLE_FULL_SIZE = 0b01111111;

     

       27
       27
       +
       const uint8_t MAKE_MOVE_TABLE_PARTIAL_SIZE = MIN_FULL_COLUMN;

     

       28
       28
       +
       const uint8_t MAKE_MOVE_TABLE_FULL_SIZE = MAX_FULL_COLUMN + 1;

     

       20
       29
        
       

     

       21
       30
        
       extern MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       22
       31
        
       extern MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       23
       32
        
       

     

       24
       33
        
       inline int8_t make_move_lookup_partial(uint8_t player, uint8_t column, BoardState state)

     

       25
       34
        
       {

     

       26
       26
       -
           assert(column >= 0 && column < 7);

     

       35
       35
       +
           assert(column >= 0 && column < NUM_COLUMNS);

     

       27
       36
        
       

     

       28
       28
       -
           if (state[column] >= 0b01000000)

     

       37
       37
       +
           if (state[column] >= MAKE_MOVE_TABLE_PARTIAL_SIZE)

     

       29
       38
        
               return -1;

     

       30
       39
        
       

     

       31
       40
        
           MakeMoveResult result = make_move_table_partial[player][state[column]];

     
···

       35
       44
        
       

     

       36
       45
        
       inline int8_t make_move_lookup_full(uint8_t player, uint8_t column, BoardState state)

     

       37
       46
        
       {

     

       38
       38
       -
           assert(column >= 0 && column < 7);

     

       47
       47
       +
           assert(column >= 0 && column < NUM_COLUMNS);

     

       39
       48
        
       

     

       40
       49
        
           MakeMoveResult result = make_move_table_full[player][state[column]];

     

       41
       50
        
           state[column] = result.column_state;

     
···

       44
       53
        
       

     

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

     

       46
       55
        
       bool check_for_win(BoardState state);

     

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

     

       56
       56
       +
       void get_move_scores(int64_t final_scores[NUM_COLUMNS]);

     

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

     

       49
       58
        
       void print_board(BoardState state);

+17 -4

main.cpp

···

       19
       19
        
           //     }

     

       20
       20
        
           // }

     

       21
       21
        
       

     

       22
       22
       -
           while (true)

     

       23
       23
       -
           {

     

       22
       22
       +
           // while (true)

     

       23
       23
       +
           // {

     

       24
       24
        
               // // Print board

     

       25
       25
        
               // printf("_1_2_3_4_5_6_7_\n");

     

       26
       26
        
               // for (int8_t row = 6 - 1; row >= 0; --row)

     
···

       57
       57
        
               //     break;

     

       58
       58
        
               // }

     

       59
       59
        
       

     

       60
       60
       -
               int64_t final_scores[7];

     

       60
       60
       +
               int64_t final_scores[NUM_COLUMNS];

     

       61
       61
        
               get_move_scores(final_scores);

     

       62
       62
       +
               printf("final scores: ");

     

       63
       63
       +
               for (uint8_t i = 0; i < NUM_COLUMNS; ++i)

     

       64
       64
       +
               {

     

       65
       65
       +
                   printf("%d", final_scores[i]);

     

       66
       66
       +
                   if (i + 1 < NUM_COLUMNS)

     

       67
       67
       +
                   {

     

       68
       68
       +
                       printf(" | ");

     

       69
       69
       +
                   }

     

       70
       70
       +
                   else

     

       71
       71
       +
                   {

     

       72
       72
       +
                       printf("\n");

     

       73
       73
       +
                   }

     

       74
       74
       +
               }

     

       62
       75
        
       

     

       63
       76
        
               // uint64_t eval_end_time = SDL_GetPerformanceCounter();

     

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

     
···

       77
       90
        
               // }

     

       78
       91
        
       

     

       79
       92
        
               // printf("\033[2J");

     

       80
       80
       -
           }

     

       93
       93
       +
           // }

     

       81
       94
        
       

     

       82
       95
        
           return 0;

     

       83
       96
        
       }