···

       
9
       
 
       
struct WinningBoardCollection

     

       
10
       
 
       
{

     

       
11
       
 
       
    uint8_t num_boards;

     

       
12
       
-
       
    uint64_t* boards;

     

       
13
       
 
       
};

     

       
14
       
 
       


     

       
15
       
 
       
MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       
16
       
 
       
MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       
17
       
 
       


     

       
18
       
-
       
const uint8_t CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE = 0b01111111;

     

       
19
       
 
       
uint8_t check_for_win_processed_column_table[2][CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE];

     

       
20
       
-
       
WinningBoardCollection check_for_win_processed_winning_boards_table[6][7];

     

       
21
       
 
       


     

       
22
       
 
       
void init_board(BoardState state)

     

       
23
       
 
       
{

     

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

     

       
25
       
 
       
    {

     

       
26
       
 
       
        state[col] = 1;

     

       
27
       
 
       
    }

     
···

       
29
       
 
       


     

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

     

       
31
       
 
       
{

     

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

     

       
33
       
 
       


     

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

     

       
35
       
 
       
}

     

       
36
       
 
       


     

       
37
       
 
       
int8_t make_move_column(uint8_t player, uint8_t* column_state)

     

       
38
       
 
       
{

     

       
39
       
-
       
    if (*column_state >= 0b01000000)

     

       
40
       
 
       
        return -1;

     

       
41
       
 
       


     

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

     
···

       
73
       
 
       
    }

     

       
74
       
 
       
}

     

       
75
       
 
       


     

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

     

       
77
       
 
       
{

     

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

     

       
79
       
 
       
}

     

       
80
       
 
       


     

       
81
       
 
       
void init_core()

     
···

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

     

       
87
       
 
       
    {

     

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

     

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

     

       
90
       
 
       
        {

     

       
91
       
 
       
            MakeMoveResult result;

     

       
92
       
 
       
            result.column_state = column_state;

     
···

       
137
       
 
       
    }

     

       
138
       
 
       


     

       
139
       
 
       
    // Building check_for_win winning board lookup table

     

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

     

       
141
       
 
       
    {

     

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

     

       
143
       
 
       
        {

     

       
144
       
-
       
            uint64_t boards[32];

     

       
145
       
 
       
            uint8_t num_boards = 0;

     

       
146
       
 
       


     

       
147
       
 
       
            // Vertical

     

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

     

       
149
       
 
       
            {

     

       
150
       
-
       
                uint64_t winning_board_state = 0;

     

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

     

       
152
       
 
       
                {

     

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

     

       
154
       
 
       
                }

     
···

       
158
       
 
       
            }

     

       
159
       
 
       


     

       
160
       
 
       
            // Horizontal

     

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

     

       
162
       
 
       
            {

     

       
163
       
-
       
                uint64_t winning_board_state = 0;

     

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

     

       
165
       
 
       
                {

     

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

     

       
167
       
 
       
                }

     
···

       
180
       
 
       
                    --diag_col;

     

       
181
       
 
       
                }

     

       
182
       
 
       


     

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

     

       
184
       
 
       
                {

     

       
185
       
-
       
                    uint64_t winning_board_state = 0;

     

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

     

       
187
       
 
       
                    {

     

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

     

       
189
       
 
       
                    }

     
···

       
200
       
 
       
            {

     

       
201
       
 
       
                int8_t diag_row = table_row;

     

       
202
       
 
       
                uint8_t diag_col = table_col;

     

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

     

       
204
       
 
       
                {

     

       
205
       
 
       
                    ++diag_row;

     

       
206
       
 
       
                    --diag_col;

     

       
207
       
 
       
                }

     

       
208
       
 
       


     

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

     

       
210
       
 
       
                {

     

       
211
       
-
       
                    uint64_t winning_board_state = 0;

     

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

     

       
213
       
 
       
                    {

     

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

     

       
215
       
 
       
                    }

     
···

       
224
       
 
       


     

       
225
       
 
       
            WinningBoardCollection board_collection;

     

       
226
       
 
       
            board_collection.num_boards = num_boards;

     

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

     

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

     

       
229
       
 
       


     

       
230
       
 
       
            check_for_win_processed_winning_boards_table[table_row][table_col] = board_collection;

     

       
231
       
 
       
        }

     
···

       
234
       
 
       


     

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

     

       
236
       
 
       
{

     

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

     

       
238
       
 
       


     

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

     

       
240
       
 
       
}

     
···

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

     

       
243
       
 
       
{

     

       
244
       
 
       
    assert(last_move_player <= 1);

     

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

     

       
246
       
 
       


     

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

     

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

     

       
249
       
 
       
    {

     

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

     

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

     

       
252
       
 
       
    }

     

       
253
       
 
       


     

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

     

       
255
       
 
       


     

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

     

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

     

       
258
       
 
       
    {

     

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

     

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

     

       
261
       
 
       
        {

     

       
262
       
 
       
            return true;

     
···

       
280
       
 
       
    int64_t score = 0;

     

       
281
       
 
       
};

     

       
282
       
 
       


     

       
283
       
-
       
void get_move_scores(int64_t final_scores[7])

     

       
284
       
 
       
{

     

       
285
       
 
       
    MoveEvalNode nodes[44];

     

       
286
       
 
       
    init_board(nodes[0].state);

     
···

       
358
       
 
       
            ++nodes[depth].curr_move_column;

     

       
359
       
 
       


     

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

     

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

     

       
362
       
 
       
            {

     

       
363
       
 
       
                min_depth = depth < min_depth ? depth : min_depth;

     

       
364
       
 
       


     
···

       
392
       
 
       


     

       
393
       
 
       
void sprint_board(BoardState state, char* buffer)

     

       
394
       
 
       
{

     

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

     

       
396
       
-
       
    buffer += 16;

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
398
       
 
       
    {

     

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

     

       
400
       
 
       
        buffer += 1;

     

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

     

       
402
       
 
       
        {

     

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

     

       
404
       
 
       
            {

     
···

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

     

       
423
       
 
       
        buffer += 1;

     

       
424
       
 
       
    }

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
426
       
 
       
}

     

       
427
       
 
       


     

       
428
       
 
       
void print_board(BoardState state)

     

···

       
9
       
 
       
struct WinningBoardCollection

     

       
10
       
 
       
{

     

       
11
       
 
       
    uint8_t num_boards;

     

       
12
       
+
       
    binary_board* boards;

     

       
13
       
 
       
};

     

       
14
       
 
       


     

       
15
       
 
       
MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       
16
       
 
       
MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       
17
       
 
       


     

       
18
       
+
       
const uint8_t CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE = MAX_FULL_COLUMN + 1;

     

       
19
       
 
       
uint8_t check_for_win_processed_column_table[2][CHECK_FOR_WIN_PROCESSED_COLUMN_TABLE_SIZE];

     

       
20
       
+
       
WinningBoardCollection check_for_win_processed_winning_boards_table[NUM_ROWS][NUM_COLUMNS];

     

       
21
       
 
       


     

       
22
       
 
       
void init_board(BoardState state)

     

       
23
       
 
       
{

     

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

     

       
25
       
 
       
    {

     

       
26
       
 
       
        state[col] = 1;

     

       
27
       
 
       
    }

     
···

       
29
       
 
       


     

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

     

       
31
       
 
       
{

     

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

     

       
33
       
 
       


     

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

     

       
35
       
 
       
}

     

       
36
       
 
       


     

       
37
       
 
       
int8_t make_move_column(uint8_t player, uint8_t* column_state)

     

       
38
       
 
       
{

     

       
39
       
+
       
    if (*column_state >= MIN_FULL_COLUMN)

     

       
40
       
 
       
        return -1;

     

       
41
       
 
       


     

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

     
···

       
73
       
 
       
    }

     

       
74
       
 
       
}

     

       
75
       
 
       


     

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

     

       
77
       
 
       
{

     

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

     

       
79
       
 
       
}

     

       
80
       
 
       


     

       
81
       
 
       
void init_core()

     
···

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

     

       
87
       
 
       
    {

     

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

     

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

     

       
90
       
 
       
        {

     

       
91
       
 
       
            MakeMoveResult result;

     

       
92
       
 
       
            result.column_state = column_state;

     
···

       
137
       
 
       
    }

     

       
138
       
 
       


     

       
139
       
 
       
    // Building check_for_win winning board lookup table

     

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

     

       
141
       
 
       
    {

     

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

     

       
143
       
 
       
        {

     

       
144
       
+
       
            binary_board boards[32];

     

       
145
       
 
       
            uint8_t num_boards = 0;

     

       
146
       
 
       


     

       
147
       
 
       
            // Vertical

     

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

     

       
149
       
 
       
            {

     

       
150
       
+
       
                binary_board winning_board_state = 0;

     

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

     

       
152
       
 
       
                {

     

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

     

       
154
       
 
       
                }

     
···

       
158
       
 
       
            }

     

       
159
       
 
       


     

       
160
       
 
       
            // Horizontal

     

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

     

       
162
       
 
       
            {

     

       
163
       
+
       
                binary_board winning_board_state = 0;

     

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

     

       
165
       
 
       
                {

     

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

     

       
167
       
 
       
                }

     
···

       
180
       
 
       
                    --diag_col;

     

       
181
       
 
       
                }

     

       
182
       
 
       


     

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

     

       
184
       
 
       
                {

     

       
185
       
+
       
                    binary_board winning_board_state = 0;

     

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

     

       
187
       
 
       
                    {

     

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

     

       
189
       
 
       
                    }

     
···

       
200
       
 
       
            {

     

       
201
       
 
       
                int8_t diag_row = table_row;

     

       
202
       
 
       
                uint8_t diag_col = table_col;

     

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

     

       
204
       
 
       
                {

     

       
205
       
 
       
                    ++diag_row;

     

       
206
       
 
       
                    --diag_col;

     

       
207
       
 
       
                }

     

       
208
       
 
       


     

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

     

       
210
       
 
       
                {

     

       
211
       
+
       
                    binary_board winning_board_state = 0;

     

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

     

       
213
       
 
       
                    {

     

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

     

       
215
       
 
       
                    }

     
···

       
224
       
 
       


     

       
225
       
 
       
            WinningBoardCollection board_collection;

     

       
226
       
 
       
            board_collection.num_boards = num_boards;

     

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

     

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

     

       
229
       
 
       


     

       
230
       
 
       
            check_for_win_processed_winning_boards_table[table_row][table_col] = board_collection;

     

       
231
       
 
       
        }

     
···

       
234
       
 
       


     

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

     

       
236
       
 
       
{

     

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

     

       
238
       
 
       


     

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

     

       
240
       
 
       
}

     
···

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

     

       
243
       
 
       
{

     

       
244
       
 
       
    assert(last_move_player <= 1);

     

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

     

       
246
       
 
       


     

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

     

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

     

       
249
       
 
       
    {

     

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

     

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

     

       
252
       
 
       
    }

     

       
253
       
 
       


     

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

     

       
255
       
 
       


     

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

     

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

     

       
258
       
 
       
    {

     

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

     

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

     

       
261
       
 
       
        {

     

       
262
       
 
       
            return true;

     
···

       
280
       
 
       
    int64_t score = 0;

     

       
281
       
 
       
};

     

       
282
       
 
       


     

       
283
       
+
       
void get_move_scores(int64_t final_scores[NUM_COLUMNS])

     

       
284
       
 
       
{

     

       
285
       
 
       
    MoveEvalNode nodes[44];

     

       
286
       
 
       
    init_board(nodes[0].state);

     
···

       
358
       
 
       
            ++nodes[depth].curr_move_column;

     

       
359
       
 
       


     

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

     

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

     

       
362
       
 
       
            {

     

       
363
       
 
       
                min_depth = depth < min_depth ? depth : min_depth;

     

       
364
       
 
       


     
···

       
392
       
 
       


     

       
393
       
 
       
void sprint_board(BoardState state, char* buffer)

     

       
394
       
 
       
{

     

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

     

       
396
       
+
       
    {

     

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

     

       
398
       
+
       
        buffer += 2;

     

       
399
       
+
       
    }

     

       
400
       
+
       


     

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

     

       
402
       
+
       
    buffer += 2;

     

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

     

       
404
       
 
       
    {

     

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

     

       
406
       
 
       
        buffer += 1;

     

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

     

       
408
       
 
       
        {

     

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

     

       
410
       
 
       
            {

     
···

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

     

       
429
       
 
       
        buffer += 1;

     

       
430
       
 
       
    }

     

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

     

       
432
       
+
       
    {

     

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

     

       
434
       
+
       
        buffer += 2;

     

       
435
       
+
       
    }

     

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

     

       
437
       
 
       
}

     

       
438
       
 
       


     

       
439
       
 
       
void print_board(BoardState state)

     

···

       
3
       
 
       
#include <cassert>

     

       
4
       
 
       
#include <stdint.h>

     

       
5
       
 
       


     

       
6
       
-
       
typedef uint8_t BoardState[7];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7
       
 
       


     

       
8
       
 
       
void init_board(BoardState state);

     

       
9
       
 
       
void init_core();

     
···

       
15
       
 
       
    uint8_t column_state;

     

       
16
       
 
       
};

     

       
17
       
 
       


     

       
18
       
-
       
const uint8_t MAKE_MOVE_TABLE_PARTIAL_SIZE = 0b01000000;

     

       
19
       
-
       
const uint8_t MAKE_MOVE_TABLE_FULL_SIZE = 0b01111111;

     

       
20
       
 
       


     

       
21
       
 
       
extern MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       
22
       
 
       
extern MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       
23
       
 
       


     

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

     

       
25
       
 
       
{

     

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

     

       
27
       
 
       


     

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

     

       
29
       
 
       
        return -1;

     

       
30
       
 
       


     

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

     
···

       
35
       
 
       


     

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

     

       
37
       
 
       
{

     

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

     

       
39
       
 
       


     

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

     

       
41
       
 
       
    state[column] = result.column_state;

     
···

       
44
       
 
       


     

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

     

       
46
       
 
       
bool check_for_win(BoardState state);

     

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

     

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

     

       
49
       
 
       
void print_board(BoardState state);

     

···

       
3
       
 
       
#include <cassert>

     

       
4
       
 
       
#include <stdint.h>

     

       
5
       
 
       


     

       
6
       
+
       
const uint8_t NUM_ROWS = 6;

     

       
7
       
+
       
const uint8_t NUM_COLUMNS = 7;

     

       
8
       
+
       
const uint8_t NUM_TO_WIN = 4;

     

       
9
       
+
       
const uint8_t MIN_FULL_COLUMN = 0b01000000;

     

       
10
       
+
       
const uint8_t MAX_FULL_COLUMN = 0b01111111;

     

       
11
       
+
       
typedef uint64_t binary_board;

     

       
12
       
+
       


     

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

     

       
14
       
+
       


     

       
15
       
+
       
typedef uint8_t BoardState[NUM_COLUMNS];

     

       
16
       
 
       


     

       
17
       
 
       
void init_board(BoardState state);

     

       
18
       
 
       
void init_core();

     
···

       
24
       
 
       
    uint8_t column_state;

     

       
25
       
 
       
};

     

       
26
       
 
       


     

       
27
       
+
       
const uint8_t MAKE_MOVE_TABLE_PARTIAL_SIZE = MIN_FULL_COLUMN;

     

       
28
       
+
       
const uint8_t MAKE_MOVE_TABLE_FULL_SIZE = MAX_FULL_COLUMN + 1;

     

       
29
       
 
       


     

       
30
       
 
       
extern MakeMoveResult make_move_table_partial[2][MAKE_MOVE_TABLE_PARTIAL_SIZE];

     

       
31
       
 
       
extern MakeMoveResult make_move_table_full[2][MAKE_MOVE_TABLE_FULL_SIZE];

     

       
32
       
 
       


     

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

     

       
34
       
 
       
{

     

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

     

       
36
       
 
       


     

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

     

       
38
       
 
       
        return -1;

     

       
39
       
 
       


     

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

     
···

       
44
       
 
       


     

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

     

       
46
       
 
       
{

     

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

     

       
48
       
 
       


     

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

     

       
50
       
 
       
    state[column] = result.column_state;

     
···

       
53
       
 
       


     

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

     

       
55
       
 
       
bool check_for_win(BoardState state);

     

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

     

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

     

       
58
       
 
       
void print_board(BoardState state);

     

···

       
19
       
 
       
    //     }

     

       
20
       
 
       
    // }

     

       
21
       
 
       


     

       
22
       
-
       
    while (true)

     

       
23
       
-
       
    {

     

       
24
       
 
       
        // // Print board

     

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

     

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

     
···

       
57
       
 
       
        //     break;

     

       
58
       
 
       
        // }

     

       
59
       
 
       


     

       
60
       
-
       
        int64_t final_scores[7];

     

       
61
       
 
       
        get_move_scores(final_scores);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
62
       
 
       


     

       
63
       
 
       
        // uint64_t eval_end_time = SDL_GetPerformanceCounter();

     

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

     
···

       
77
       
 
       
        // }

     

       
78
       
 
       


     

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

     

       
80
       
-
       
    }

     

       
81
       
 
       


     

       
82
       
 
       
    return 0;

     

       
83
       
 
       
}
     

···

       
19
       
 
       
    //     }

     

       
20
       
 
       
    // }

     

       
21
       
 
       


     

       
22
       
+
       
    // while (true)

     

       
23
       
+
       
    // {

     

       
24
       
 
       
        // // Print board

     

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

     

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

     
···

       
57
       
 
       
        //     break;

     

       
58
       
 
       
        // }

     

       
59
       
 
       


     

       
60
       
+
       
        int64_t final_scores[NUM_COLUMNS];

     

       
61
       
 
       
        get_move_scores(final_scores);

     

       
62
       
+
       
        printf("final scores: ");

     

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

     

       
64
       
+
       
        {

     

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

     

       
66
       
+
       
            if (i + 1 < NUM_COLUMNS)

     

       
67
       
+
       
            {

     

       
68
       
+
       
                printf(" | ");

     

       
69
       
+
       
            }

     

       
70
       
+
       
            else

     

       
71
       
+
       
            {

     

       
72
       
+
       
                printf("\n");

     

       
73
       
+
       
            }

     

       
74
       
+
       
        }

     

       
75
       
 
       


     

       
76
       
 
       
        // uint64_t eval_end_time = SDL_GetPerformanceCounter();

     

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

     
···

       
90
       
 
       
        // }

     

       
91
       
 
       


     

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

     

       
93
       
+
       
    // }

     

       
94
       
 
       


     

       
95
       
 
       
    return 0;

     

       
96
       
 
       
}