stellar

Rewrite attack, piece and board

35 files changed, 1069 insertions(+), 835 deletions(-)

diff --git a/ CMakeLists.txt b/ CMakeLists.txt

@@ -6,7 +6,7 @@ project( VERSION 0.0.18 DESCRIPTION "Chess engine written in C" HOMEPAGE_URL https://git.dimitrijedobrota.com/stellar.git

LANGUAGES C

LANGUAGES C CXX

) set(CMAKE_C_STANDARD 99)

diff --git a/ src/attacks/CMakeLists.txt b/ src/attacks/CMakeLists.txt

@@ -1,7 +1,7 @@ add_library(attacks OBJECT

attacks.c

internal.c

magic.c

attacks.cpp

internal.cpp

magic.cpp

) target_include_directories(attacks

@@ -14,14 +14,14 @@ project( MagicGenerator VERSION 1.0.0 DESCRIPTION "Generator of magic numbers for bishup and rook attacks"

LANGUAGES C

LANGUAGES CXX

) add_executable(magic

internal.c

magic.c

magic_generate.c

internal.cpp

magic.cpp

magic_generate.cpp

) target_link_libraries(magic

diff --git a/ src/attacks/attacks.c b/ src/attacks/attacks.c

@@ -1,93 +0,0 @@

#include "attacks.h"

#include "internal.h"

#include "magic.h"

#define UNUSED(x) (void)(x)

// Magic constants

U64 attacks_wpawn_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return pawn_attacks[WHITE][square];

}

U64 attacks_bpawn_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return pawn_attacks[BLACK][square];

}

U64 attacks_knight_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return knight_attacks[square];

}

U64 attakcs_king_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return king_attacks[square];

}

U64 attacks_bishop_get(Square square, U64 occupancy) {

occupancy &= bishop_masks[square];

occupancy = hash(occupancy, bishop_magic_numbers[square],

bishop_relevant_bits[square]);

return bishop_attacks[square][occupancy];

}

U64 attacks_rook_get(Square square, U64 occupancy) {

occupancy &= rook_masks[square];

occupancy =

hash(occupancy, rook_magic_numbers[square], rook_relevant_bits[square]);

return rook_attacks[square][occupancy];

}

U64 attacks_queen_get(Square square, U64 occupancy) {

return (attacks_bishop_get(square, occupancy) |

attacks_rook_get(square, occupancy));

}

void attacks_init_leapers(void) {

for (Square square = 0; square < 64; square++) {

pawn_attacks[WHITE][square] = pawn_mask(WHITE, square);

pawn_attacks[BLACK][square] = pawn_mask(BLACK, square);

knight_attacks[square] = knight_mask(square);

king_attacks[square] = king_mask(square);

}

}

void attacks_init_sliders(int bishop) {

for (Square square = 0; square < 64; square++) {

U64 attack_mask;

if (bishop) {

bishop_masks[square] = bishop_mask(square);

attack_mask = bishop_masks[square];

} else {

rook_masks[square] = rook_mask(square);

attack_mask = rook_masks[square];

}

int relevant_bits = bit_count(attack_mask);

int occupancy_indicies = 1 << relevant_bits;

for (int index = 0; index < occupancy_indicies; index++) {

U64 occupancy = set_occupancy(index, relevant_bits, attack_mask);

if (bishop) {

int magic_index = (occupancy * bishop_magic_numbers[square]) >>

(64 - bishop_relevant_bits[square]);

bishop_attacks[square][magic_index] =

bishop_on_the_fly(square, occupancy);

} else {

int magic_index = hash(occupancy, rook_magic_numbers[square],

rook_relevant_bits[square]);

rook_attacks[square][magic_index] =

rook_on_the_fly(square, occupancy);

}

}

}

}

void attacks_init(void) {

attacks_init_leapers();

attacks_init_sliders(0);

attacks_init_sliders(1);

}

diff --git a/ src/attacks/attacks.cpp b/ src/attacks/attacks.cpp

@@ -0,0 +1,99 @@

#include "attacks.hpp"

#include "internal.hpp"

#include "magic.hpp"

#include "utils_cpp.hpp"

#define UNUSED(x) (void)(x)

U64 attacks_wpawn_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return pawn_attacks[to_underlying(Color::WHITE)][to_underlying(square)];

}

U64 attacks_bpawn_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return pawn_attacks[to_underlying(Color::BLACK)][to_underlying(square)];

}

U64 attacks_knight_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return knight_attacks[to_underlying(square)];

}

U64 attacks_king_get(Square square, U64 occupancy) {

UNUSED(occupancy);

return king_attacks[to_underlying(square)];

}

U64 attacks_bishop_get(Square square, U64 occupancy) {

int square_i = to_underlying(square);

occupancy &= bishop_masks[square_i];

occupancy = hash(occupancy, bishop_magic_numbers[square_i],

bishop_relevant_bits[square_i]);

return bishop_attacks[square_i][occupancy];

}

U64 attacks_rook_get(Square square, U64 occupancy) {

int square_i = to_underlying(square);

occupancy &= rook_masks[square_i];

occupancy = hash(occupancy, rook_magic_numbers[square_i],

rook_relevant_bits[square_i]);

return rook_attacks[square_i][occupancy];

}

U64 attacks_queen_get(Square square, U64 occupancy) {

return (attacks_bishop_get(square, occupancy) |

attacks_rook_get(square, occupancy));

}

void attacks_init_leapers(void) {

for (Square square : SquareIter()) {

uint8_t square_i;

pawn_attacks[to_underlying(Color::WHITE)][square_i] =

pawn_mask(Color::WHITE, square);

pawn_attacks[to_underlying(Color::BLACK)][square_i] =

pawn_mask(Color::BLACK, square);

knight_attacks[square_i] = knight_mask(square);

king_attacks[square_i] = king_mask(square);

}

}

void attacks_init_sliders(int bishop) {

for (Square square : SquareIter()) {

uint8_t square_i;

U64 attack_mask;

if (bishop) {

bishop_masks[square_i] = bishop_mask(square);

attack_mask = bishop_masks[square_i];

} else {

rook_masks[square_i] = rook_mask(square);

attack_mask = rook_masks[square_i];

}

int relevant_bits = bit_count(attack_mask);

int occupancy_indicies = 1 << relevant_bits;

for (int index = 0; index < occupancy_indicies; index++) {

U64 occupancy = set_occupancy(index, relevant_bits, attack_mask);

if (bishop) {

int magic_index =

(occupancy * bishop_magic_numbers[square_i]) >>

(64 - bishop_relevant_bits[square_i]);

bishop_attacks[square_i][magic_index] =

bishop_on_the_fly(square, occupancy);

} else {

int magic_index = hash(occupancy, rook_magic_numbers[square_i],

rook_relevant_bits[square_i]);

rook_attacks[square_i][magic_index] =

rook_on_the_fly(square, occupancy);

}

}

}

}

void attacks_init(void) {

attacks_init_leapers();

attacks_init_sliders(0);

attacks_init_sliders(1);

}

diff --git a/ src/attacks/internal.c b/ src/attacks/internal.c

@@ -1,141 +0,0 @@

#include "internal.h"

U64 king_attacks[64];

U64 knight_attacks[64];

U64 pawn_attacks[2][64];

U64 rook_attacks[64][4096]; // 2048K

U64 bishop_attacks[64][512]; // 256 K

U64 rook_masks[64];

U64 bishop_masks[64];

// clang-format off

const int bishop_relevant_bits[64] = {

6, 5, 5, 5, 5, 5, 5, 6,

5, 5, 5, 5, 5, 5, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 7, 9, 9, 7, 5, 5,

5, 5, 7, 9, 9, 7, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 5, 5, 5, 5, 5, 5,

6, 5, 5, 5, 5, 5, 5, 6,

};

const int rook_relevant_bits[64] = {

12, 11, 11, 11, 11, 11, 11, 12,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

12, 11, 11, 11, 11, 11, 11, 12,

};

// clang-format on

int hash(U64 key, U64 magic, int relevant_bits) {

return (key * magic) >> (64 - relevant_bits);

}

U64 set_occupancy(int index, int bits_in_mask, U64 attack_mask) {

U64 occupancy = C64(0);

for (int count = 0; count < bits_in_mask; count++) {

Square square = bit_lsb_index(attack_mask);

bit_pop(attack_mask, square);

if (index & (1 << count)) bit_set(occupancy, square);

}

return occupancy;

}

U64 attacks_slide_mask(Square square, U64 block, const direction_f dir[4],

int len[4]) {

U64 bitboard = C64(0), attacks = C64(0), tmp;

int i, j;

bit_set(bitboard, square);

for (i = 0; i < 4; i++) {

for (j = 0, tmp = bitboard; j < len[i]; j++) {

attacks |= tmp = (dir[i])(tmp);

if (tmp & block) break;

}

}

return attacks;

}

// Mask Attacks

const direction_f attacks_bishop_direction[4] = {noEaOne, noWeOne, soEaOne,

soWeOne};

const direction_f attacks_rook_direction[4] = {westOne, soutOne, eastOne,

nortOne};

U64 pawn_mask(int side, Square square) {

U64 bitboard = C64(0);

bit_set(bitboard, square);

if (side == WHITE)

return noWeOne(bitboard) | noEaOne(bitboard);

else

return soWeOne(bitboard) | soEaOne(bitboard);

}

U64 knight_mask(Square square) {

U64 bitboard = C64(0), attacks = C64(0), tmp;

bit_set(bitboard, square);

tmp = nortOne(nortOne(bitboard));

attacks |= westOne(tmp) | eastOne(tmp);

tmp = soutOne(soutOne(bitboard));

attacks |= westOne(tmp) | eastOne(tmp);

tmp = westOne(westOne(bitboard));

attacks |= soutOne(tmp) | nortOne(tmp);

tmp = eastOne(eastOne(bitboard));

attacks |= soutOne(tmp) | nortOne(tmp);

return attacks;

}

U64 king_mask(Square square) {

U64 bitboard = C64(0), attacks = C64(0);

bit_set(bitboard, square);

attacks |= westOne(bitboard) | eastOne(bitboard);

attacks |= soutOne(bitboard) | nortOne(bitboard);

attacks |= soutOne(bitboard) | nortOne(bitboard);

attacks |= soEaOne(bitboard) | noEaOne(bitboard);

attacks |= soWeOne(bitboard) | noWeOne(bitboard);

return attacks;

}

U64 bishop_mask(Square square) {

int tr = square / 8, tf = square % 8;

int len[4] = {MIN(7 - tf, 7 - tr) - 1, MIN(tf, 7 - tr) - 1,

MIN(7 - tf, tr) - 1, MIN(tf, tr) - 1};

return attacks_slide_mask(square, C64(0), attacks_bishop_direction, len);

}

U64 rook_mask(Square square) {

int tr = square / 8, tf = square % 8;

int len[4] = {tf - 1, tr - 1, 6 - tf, 6 - tr};

return attacks_slide_mask(square, C64(0), attacks_rook_direction, len);

}

U64 bishop_on_the_fly(Square square, U64 block) {

int tr = square / 8, tf = square % 8;

int len[4] = {MIN(7 - tf, 7 - tr), MIN(tf, 7 - tr), MIN(7 - tf, tr),

MIN(tf, tr)};

return attacks_slide_mask(square, block, attacks_bishop_direction, len);

}

U64 rook_on_the_fly(Square square, U64 block) {

int tr = square / 8, tf = square % 8;

int len[4] = {tf, tr, 7 - tf, 7 - tr};

return attacks_slide_mask(square, block, attacks_rook_direction, len);

}

diff --git a/ src/attacks/internal.cpp b/ src/attacks/internal.cpp

@@ -0,0 +1,148 @@

#include "internal.h"

#include "utils_cpp.hpp"

#include <algorithm> // std::min

U64 king_attacks[64];

U64 knight_attacks[64];

U64 pawn_attacks[2][64];

U64 rook_attacks[64][4096]; // 2048K

U64 bishop_attacks[64][512]; // 256 K

U64 rook_masks[64];

U64 bishop_masks[64];

// clang-format off

const int bishop_relevant_bits[64] = {

6, 5, 5, 5, 5, 5, 5, 6,

5, 5, 5, 5, 5, 5, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 7, 9, 9, 7, 5, 5,

5, 5, 7, 9, 9, 7, 5, 5,

5, 5, 7, 7, 7, 7, 5, 5,

5, 5, 5, 5, 5, 5, 5, 5,

6, 5, 5, 5, 5, 5, 5, 6,

};

const int rook_relevant_bits[64] = {

12, 11, 11, 11, 11, 11, 11, 12,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

11, 10, 10, 10, 10, 10, 10, 11,

12, 11, 11, 11, 11, 11, 11, 12,

};

// clang-format on

int hash(U64 key, U64 magic, int relevant_bits) {

return (key * magic) >> (64 - relevant_bits);

}

U64 set_occupancy(int index, int bits_in_mask, U64 attack_mask) {

U64 occupancy = C64(0);

for (int count = 0; count < bits_in_mask; count++) {

uint8_t square = bit_lsb_index(attack_mask);

bit_pop(attack_mask, square);

if (index & (1 << count)) bit_set(occupancy, square);

}

return occupancy;

}

U64 attacks_slide_mask(Square square, U64 block, const direction_f dir[4],

int len[4]) {

U64 bitboard = C64(0), attacks = C64(0), tmp;

int i, j;

bit_set(bitboard, to_underlying(square));

for (i = 0; i < 4; i++) {

for (j = 0, tmp = bitboard; j < len[i]; j++) {

attacks |= tmp = (dir[i])(tmp);

if (tmp & block) break;

}

}

return attacks;

}

// Mask Attacks

const direction_f attacks_bishop_direction[4] = {noEaOne, noWeOne, soEaOne,

soWeOne};

const direction_f attacks_rook_direction[4] = {westOne, soutOne, eastOne,

nortOne};

U64 pawn_mask(Color side, Square square) {

U64 bitboard = C64(0);

bit_set(bitboard, to_underlying(square));

if (side == Color::WHITE)

return noWeOne(bitboard) | noEaOne(bitboard);

else

return soWeOne(bitboard) | soEaOne(bitboard);

}

U64 knight_mask(Square square) {

U64 bitboard = C64(0), attacks = C64(0), tmp;

bit_set(bitboard, to_underlying(square));

tmp = nortOne(nortOne(bitboard));

attacks |= westOne(tmp) | eastOne(tmp);

tmp = soutOne(soutOne(bitboard));

attacks |= westOne(tmp) | eastOne(tmp);

tmp = westOne(westOne(bitboard));

attacks |= soutOne(tmp) | nortOne(tmp);

tmp = eastOne(eastOne(bitboard));

attacks |= soutOne(tmp) | nortOne(tmp);

return attacks;

}

U64 king_mask(Square square) {

U64 bitboard = C64(0), attacks = C64(0);

bit_set(bitboard, to_underlying(square));

attacks |= westOne(bitboard) | eastOne(bitboard);

attacks |= soutOne(bitboard) | nortOne(bitboard);

attacks |= soutOne(bitboard) | nortOne(bitboard);

attacks |= soEaOne(bitboard) | noEaOne(bitboard);

attacks |= soWeOne(bitboard) | noWeOne(bitboard);

return attacks;

}

U64 bishop_mask(Square square) {

uint8_t square_i = to_underlying(square);

int tr = square_i / 8, tf = square_i % 8;

int len[4] = {std::min(7 - tf, 7 - tr) - 1, std::min(tf, 7 - tr) - 1,

std::min(7 - tf, tr) - 1, std::min(tf, tr) - 1};

return attacks_slide_mask(square, C64(0), attacks_bishop_direction, len);

}

U64 rook_mask(Square square) {

uint8_t square_i = to_underlying(square);

int tr = square_i / 8, tf = square_i % 8;

int len[4] = {tf - 1, tr - 1, 6 - tf, 6 - tr};

return attacks_slide_mask(square, C64(0), attacks_rook_direction, len);

}

U64 bishop_on_the_fly(Square square, U64 block) {

uint8_t square_i = to_underlying(square);

int tr = square_i / 8, tf = square_i % 8;

int len[4] = {std::min(7 - tf, 7 - tr), std::min(tf, 7 - tr),

std::min(7 - tf, tr), std::min(tf, tr)};

return attacks_slide_mask(square, block, attacks_bishop_direction, len);

}

U64 rook_on_the_fly(Square square, U64 block) {

uint8_t square_i = to_underlying(square);

int tr = square_i / 8, tf = square_i % 8;

int len[4] = {tf, tr, 7 - tf, 7 - tr};

return attacks_slide_mask(square, block, attacks_rook_direction, len);

}

diff --git a/ src/attacks/internal.h b/ src/attacks/internal.h

@@ -1,8 +1,7 @@ #ifndef STELLAR_ATTAKCS_INTERNAL_H #define STELLAR_ATTAKCS_INTERNAL_H

#include "piece.h" // BLACK, WHITE

#include "utils.h"

#include "utils_cpp.hpp"

extern U64 king_attacks[64]; // king attack table [square] extern U64 knight_attacks[64]; // knight attack table [square]

@@ -24,7 +23,7 @@ U64 bishop_mask(Square square); U64 bishop_on_the_fly(Square square, U64 block); U64 king_mask(Square square); U64 knight_mask(Square square);

U64 pawn_mask(int side, Square square);

U64 pawn_mask(Color side, Square square);

U64 rook_mask(Square square); U64 rook_on_the_fly(Square square, U64 block);

diff --git a/ src/attacks/internal.hpp b/ src/attacks/internal.hpp

@@ -0,0 +1,30 @@

#ifndef STELLAR_ATTAKCS_INTERNAL_H

#define STELLAR_ATTAKCS_INTERNAL_H

#include "utils_cpp.hpp"

extern U64 king_attacks[64]; // king attack table [square]

extern U64 knight_attacks[64]; // knight attack table [square]

extern U64 pawn_attacks[2][64]; // pawn attack table [side][square]

extern U64 rook_attacks[64][4096]; // rook attack table [square][occupancies]

extern U64 bishop_attacks[64][512]; // bishop attack table [square][occupancies]

extern U64 rook_masks[64]; // rook attack mask

extern U64 bishop_masks[64]; // bishop attack mask

extern const int rook_relevant_bits[64];

extern const int bishop_relevant_bits[64];

int hash(U64 key, U64 magic, int relevant_bits);

U64 set_occupancy(int index, int bits_in_mask, U64 attack_mask);

U64 bishop_mask(Square square);

U64 bishop_on_the_fly(Square square, U64 block);

U64 king_mask(Square square);

U64 knight_mask(Square square);

U64 pawn_mask(Color side, Square square);

U64 rook_mask(Square square);

U64 rook_on_the_fly(Square square, U64 block);

#endif

diff --git a/ src/attacks/magic.c b/ src/attacks/magic.c

@@ -1,51 +0,0 @@

#include "magic.h"

const U64 bishop_magic_numbers[64] = {

C64(0x40040844404084), C64(0x2004208a004208), C64(0x10190041080202),

C64(0x108060845042010), C64(0x581104180800210), C64(0x2112080446200010),

C64(0x1080820820060210), C64(0x3c0808410220200), C64(0x4050404440404),

C64(0x21001420088), C64(0x24d0080801082102), C64(0x1020a0a020400),

C64(0x40308200402), C64(0x4011002100800), C64(0x401484104104005),

C64(0x801010402020200), C64(0x400210c3880100), C64(0x404022024108200),

C64(0x810018200204102), C64(0x4002801a02003), C64(0x85040820080400),

C64(0x810102c808880400), C64(0xe900410884800), C64(0x8002020480840102),

C64(0x220200865090201), C64(0x2010100a02021202), C64(0x152048408022401),

C64(0x20080002081110), C64(0x4001001021004000), C64(0x800040400a011002),

C64(0xe4004081011002), C64(0x1c004001012080), C64(0x8004200962a00220),

C64(0x8422100208500202), C64(0x2000402200300c08), C64(0x8646020080080080),

C64(0x80020a0200100808), C64(0x2010004880111000), C64(0x623000a080011400),

C64(0x42008c0340209202), C64(0x209188240001000), C64(0x400408a884001800),

C64(0x110400a6080400), C64(0x1840060a44020800), C64(0x90080104000041),

C64(0x201011000808101), C64(0x1a2208080504f080), C64(0x8012020600211212),

C64(0x500861011240000), C64(0x180806108200800), C64(0x4000020e01040044),

C64(0x300000261044000a), C64(0x802241102020002), C64(0x20906061210001),

C64(0x5a84841004010310), C64(0x4010801011c04), C64(0xa010109502200),

C64(0x4a02012000), C64(0x500201010098b028), C64(0x8040002811040900),

C64(0x28000010020204), C64(0x6000020202d0240), C64(0x8918844842082200),

C64(0x4010011029020020),

};

const U64 rook_magic_numbers[64] = {

C64(0x8a80104000800020), C64(0x140002000100040), C64(0x2801880a0017001),

C64(0x100081001000420), C64(0x200020010080420), C64(0x3001c0002010008),

C64(0x8480008002000100), C64(0x2080088004402900), C64(0x800098204000),

C64(0x2024401000200040), C64(0x100802000801000), C64(0x120800800801000),

C64(0x208808088000400), C64(0x2802200800400), C64(0x2200800100020080),

C64(0x801000060821100), C64(0x80044006422000), C64(0x100808020004000),

C64(0x12108a0010204200), C64(0x140848010000802), C64(0x481828014002800),

C64(0x8094004002004100), C64(0x4010040010010802), C64(0x20008806104),

C64(0x100400080208000), C64(0x2040002120081000), C64(0x21200680100081),

C64(0x20100080080080), C64(0x2000a00200410), C64(0x20080800400),

C64(0x80088400100102), C64(0x80004600042881), C64(0x4040008040800020),

C64(0x440003000200801), C64(0x4200011004500), C64(0x188020010100100),

C64(0x14800401802800), C64(0x2080040080800200), C64(0x124080204001001),

C64(0x200046502000484), C64(0x480400080088020), C64(0x1000422010034000),

C64(0x30200100110040), C64(0x100021010009), C64(0x2002080100110004),

C64(0x202008004008002), C64(0x20020004010100), C64(0x2048440040820001),

C64(0x101002200408200), C64(0x40802000401080), C64(0x4008142004410100),

C64(0x2060820c0120200), C64(0x1001004080100), C64(0x20c020080040080),

C64(0x2935610830022400), C64(0x44440041009200), C64(0x280001040802101),

C64(0x2100190040002085), C64(0x80c0084100102001), C64(0x4024081001000421),

C64(0x20030a0244872), C64(0x12001008414402), C64(0x2006104900a0804),

C64(0x1004081002402),

};

diff --git a/ src/attacks/magic.cpp b/ src/attacks/magic.cpp

@@ -0,0 +1,51 @@

#include "magic.hpp"

const U64 bishop_magic_numbers[64] = {

C64(0x40040844404084), C64(0x2004208a004208), C64(0x10190041080202),

C64(0x108060845042010), C64(0x581104180800210), C64(0x2112080446200010),

C64(0x1080820820060210), C64(0x3c0808410220200), C64(0x4050404440404),

C64(0x21001420088), C64(0x24d0080801082102), C64(0x1020a0a020400),

C64(0x40308200402), C64(0x4011002100800), C64(0x401484104104005),

C64(0x801010402020200), C64(0x400210c3880100), C64(0x404022024108200),

C64(0x810018200204102), C64(0x4002801a02003), C64(0x85040820080400),

C64(0x810102c808880400), C64(0xe900410884800), C64(0x8002020480840102),

C64(0x220200865090201), C64(0x2010100a02021202), C64(0x152048408022401),

C64(0x20080002081110), C64(0x4001001021004000), C64(0x800040400a011002),

C64(0xe4004081011002), C64(0x1c004001012080), C64(0x8004200962a00220),

C64(0x8422100208500202), C64(0x2000402200300c08), C64(0x8646020080080080),

C64(0x80020a0200100808), C64(0x2010004880111000), C64(0x623000a080011400),

C64(0x42008c0340209202), C64(0x209188240001000), C64(0x400408a884001800),

C64(0x110400a6080400), C64(0x1840060a44020800), C64(0x90080104000041),

C64(0x201011000808101), C64(0x1a2208080504f080), C64(0x8012020600211212),

C64(0x500861011240000), C64(0x180806108200800), C64(0x4000020e01040044),

C64(0x300000261044000a), C64(0x802241102020002), C64(0x20906061210001),

C64(0x5a84841004010310), C64(0x4010801011c04), C64(0xa010109502200),

C64(0x4a02012000), C64(0x500201010098b028), C64(0x8040002811040900),

C64(0x28000010020204), C64(0x6000020202d0240), C64(0x8918844842082200),

C64(0x4010011029020020),

};

const U64 rook_magic_numbers[64] = {

C64(0x8a80104000800020), C64(0x140002000100040), C64(0x2801880a0017001),

C64(0x100081001000420), C64(0x200020010080420), C64(0x3001c0002010008),

C64(0x8480008002000100), C64(0x2080088004402900), C64(0x800098204000),

C64(0x2024401000200040), C64(0x100802000801000), C64(0x120800800801000),

C64(0x208808088000400), C64(0x2802200800400), C64(0x2200800100020080),

C64(0x801000060821100), C64(0x80044006422000), C64(0x100808020004000),

C64(0x12108a0010204200), C64(0x140848010000802), C64(0x481828014002800),

C64(0x8094004002004100), C64(0x4010040010010802), C64(0x20008806104),

C64(0x100400080208000), C64(0x2040002120081000), C64(0x21200680100081),

C64(0x20100080080080), C64(0x2000a00200410), C64(0x20080800400),

C64(0x80088400100102), C64(0x80004600042881), C64(0x4040008040800020),

C64(0x440003000200801), C64(0x4200011004500), C64(0x188020010100100),

C64(0x14800401802800), C64(0x2080040080800200), C64(0x124080204001001),

C64(0x200046502000484), C64(0x480400080088020), C64(0x1000422010034000),

C64(0x30200100110040), C64(0x100021010009), C64(0x2002080100110004),

C64(0x202008004008002), C64(0x20020004010100), C64(0x2048440040820001),

C64(0x101002200408200), C64(0x40802000401080), C64(0x4008142004410100),

C64(0x2060820c0120200), C64(0x1001004080100), C64(0x20c020080040080),

C64(0x2935610830022400), C64(0x44440041009200), C64(0x280001040802101),

C64(0x2100190040002085), C64(0x80c0084100102001), C64(0x4024081001000421),

C64(0x20030a0244872), C64(0x12001008414402), C64(0x2006104900a0804),

C64(0x1004081002402),

};

diff --git a/ src/attacks/magic.h b/ src/attacks/magic.h

@@ -1,9 +0,0 @@

#ifndef STELLAR_ATTACKS_MAGIC_H

#define STELLAR_ATTACKS_MAGIC_H

#include "utils.h"

extern const U64 bishop_magic_numbers[64];

extern const U64 rook_magic_numbers[64];

#endif

diff --git a/ src/attacks/magic.hpp b/ src/attacks/magic.hpp

@@ -0,0 +1,9 @@

#ifndef STELLAR_ATTACKS_MAGIC_H

#define STELLAR_ATTACKS_MAGIC_H

#include "utils_cpp.hpp"

extern const U64 bishop_magic_numbers[64];

extern const U64 rook_magic_numbers[64];

#endif

diff --git a/ src/attacks/magic_generate.c b/ src/attacks/magic_generate.c

@@ -1,64 +0,0 @@

#include "internal.h"

#include "random.h"

#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

const char *FORMAT = "C64(0x%llx),\n";

U64 generate_magic_number() {

return random_get_U64() & random_get_U64() & random_get_U64();

}

U64 find_magic_number(Square square, int relevant_bits, int bishop) {

U64 occupancies[4096], attacks[4096], used_attacks[4096];

U64 attack_mask = bishop ? bishop_mask(square) : rook_mask(square);

int occupancy_indicies = 1 << relevant_bits;

for (int index = 0; index < occupancy_indicies; index++) {

occupancies[index] = set_occupancy(index, relevant_bits, attack_mask);

attacks[index] = bishop ? bishop_on_the_fly(square, occupancies[index])

: rook_on_the_fly(square, occupancies[index]);

}

for (int random_count = 0; random_count < 100000000; random_count++) {

U64 magic_number = generate_magic_number();

if (bit_count((attack_mask * magic_number) & C64(0xFF00000000000000)) <

6)

continue;

memset(used_attacks, C64(0), sizeof(used_attacks));

int index, fail;

for (index = 0, fail = 0; !fail && index < occupancy_indicies;

index++) {

int magic_index =

hash(occupancies[index], magic_number, relevant_bits);

if (used_attacks[magic_index] == C64(0))

used_attacks[magic_index] = attacks[index];

else if (used_attacks[magic_index] != attacks[index])

fail = 1;

}

if (!fail) return magic_number;

}

return C64(0);

}

int main(void) {

random_state_reset();

printf("Bishup Magic Numbers:\n");

for (int i = 0; i < 64; i++)

printf(FORMAT, find_magic_number(i, bishop_relevant_bits[i], 1));

printf("Rook Magic Numbers:\n");

for (int i = 0; i < 64; i++)

printf(FORMAT, find_magic_number(i, rook_relevant_bits[i], 0));

return 0;

}

diff --git a/ src/attacks/magic_generate.cpp b/ src/attacks/magic_generate.cpp

@@ -0,0 +1,64 @@

#include "internal.h"

#include "random.h"

#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

const char *FORMAT = "C64(0x%llx),\n";

U64 generate_magic_number() {

return random_get_U64() & random_get_U64() & random_get_U64();

}

U64 find_magic_number(Square square, int relevant_bits, int bishop) {

U64 occupancies[4096], attacks[4096], used_attacks[4096];

U64 attack_mask = bishop ? bishop_mask(square) : rook_mask(square);

int occupancy_indicies = 1 << relevant_bits;

for (int index = 0; index < occupancy_indicies; index++) {

occupancies[index] = set_occupancy(index, relevant_bits, attack_mask);

attacks[index] = bishop ? bishop_on_the_fly(square, occupancies[index])

: rook_on_the_fly(square, occupancies[index]);

}

for (int random_count = 0; random_count < 100000000; random_count++) {

U64 magic_number = generate_magic_number();

if (bit_count((attack_mask * magic_number) & C64(0xFF00000000000000)) <

6)

continue;

memset(used_attacks, C64(0), sizeof(used_attacks));

int index, fail;

for (index = 0, fail = 0; !fail && index < occupancy_indicies;

index++) {

int magic_index =

hash(occupancies[index], magic_number, relevant_bits);

if (used_attacks[magic_index] == C64(0))

used_attacks[magic_index] = attacks[index];

else if (used_attacks[magic_index] != attacks[index])

fail = 1;

}

if (!fail) return magic_number;

}

return C64(0);

}

int main(void) {

random_state_reset();

printf("Bishup Magic Numbers:\n");

for (int i = 0; i < 64; i++)

printf(FORMAT, find_magic_number(i, bishop_relevant_bits[i], 1));

printf("Rook Magic Numbers:\n");

for (int i = 0; i < 64; i++)

printf(FORMAT, find_magic_number(i, rook_relevant_bits[i], 0));

return 0;

}

diff --git a/ src/board/board.c b/ src/board/board.c

@@ -1,210 +0,0 @@

#include <ctype.h>

#include <stdio.h>

#include <string.h>

#include <cul/assert.h>

#include <cul/mem.h>

#include "board.h"

#include "utils.h"

#include "zobrist.h"

Board *board_new(void) {

Board *p;

NEW0(p);

return p;

}

void board_free(Board **p) { FREE(*p); }

void board_copy(const Board *self, Board *dest) { *dest = *self; }

Square board_enpassant(const Board *self) { return self->enpassant; }

eCastle board_castle(const Board *self) { return self->castle; }

eColor board_side(const Board *self) { return self->side; }

U64 board_color(const Board *self, eColor color) { return self->color[color]; }

U64 board_piece(const Board *self, ePiece piece) { return self->piece[piece]; }

U64 board_hash(const Board *self) { return self->hash; }

U64 board_occupancy(const Board *self) {

return self->color[WHITE] | self->color[BLACK];

}

U64 board_pieceSet(const Board *self, Piece piece) {

return self->piece[piece_piece(piece)] & self->color[piece_color(piece)];

}

void board_color_pop(Board *self, eColor color, Square target) {

bit_pop(self->color[color], target);

}

void board_color_set(Board *self, eColor color, Square target) {

bit_set(self->color[color], target);

}

U64 board_color_get(const Board *self, eColor color, Square target) {

return bit_get(self->color[color], target);

}

int board_piece_get(const Board *self, Square square) {

for (int i = 0; i < 6; i++)

if (bit_get(self->piece[i], square)) return i;

return -1;

}

void board_piece_pop(Board *self, Piece piece, Square square) {

bit_pop(self->piece[piece_piece(piece)], square);

bit_pop(self->color[piece_color(piece)], square);

}

void board_piece_set(Board *self, Piece piece, Square square) {

bit_set(self->piece[piece_piece(piece)], square);

bit_set(self->color[piece_color(piece)], square);

}

U64 board_piece_attacks(const Board *self, Piece piece, Square src) {

return piece_attacks(piece)(src, board_occupancy(self));

}

int board_isCheck(const Board *self) {

U64 king = self->piece[KING] & self->color[self->side];

return board_square_isAttack(self, bit_lsb_index(king), !self->side);

}

int board_square_isOccupied(const Board *self, Square square) {

return bit_get(board_occupancy(self), square);

}

int board_square_isAttack(const Board *self, Square square, eColor side) {

U64 occupancy = self->color[WHITE] | self->color[BLACK];

for (int i = KING; i >= PAWN; i--) {

if (piece_attacks(piece_get(i, !side))(square, occupancy) &

self->piece[i] & self->color[side])

return 1;

}

return 0;

}

void board_side_switch(Board *self) {

self->side = !self->side;

self->hash ^= zobrist_key_side();

}

void board_enpassant_set(Board *self, Square target) {

if (self->enpassant != no_sq)

self->hash ^= zobrist_key_enpassant(self->enpassant);

if (target != no_sq) self->hash ^= zobrist_key_enpassant(target);

self->enpassant = target;

}

void board_castle_and(Board *self, int exp) { self->castle &= exp; }

Piece board_square_piece(const Board *self, Square square, eColor color) {

for (ePiece i = 0; i < 6; i++)

if (bit_get(self->piece[i], square)) return piece_get(i, color);

return NULL;

}

Board *board_from_FEN(Board *board, const char *fen) {

if (!board) NEW(board);

memset(board, 0, sizeof(*board));

board->side = -1;

board->enpassant = no_sq;

board->castle = 0;

int file = 0, rank = 7;

for (Piece piece; *fen != ' '; fen++) {

Square square = rank * 8 + file;

if (isalpha(*fen)) {

if (!(piece = piece_from_code(*fen))) assert(0);

bit_set(board->color[piece_color(piece)], square);

bit_set(board->piece[piece_piece(piece)], square);

file++;

} else if (isdigit(*fen)) {

file += *fen - '0';

} else if (*fen == '/') {

file = 0;

rank--;

} else {

assert(0);

}

}

fen++;

if (*fen == 'w')

board->side = WHITE;

else if (*fen == 'b')

board->side = BLACK;

else

assert(0);

for (fen += 2; *fen != ' '; fen++) {

switch (*fen) {

case 'K':

board->castle |= WK;

break;

case 'Q':

board->castle |= WQ;

break;

case 'k':

board->castle |= BK;

break;

case 'q':

board->castle |= BQ;

break;

case '-':

break;

default:

assert(0);

}

}

fen++;

if (*fen != '-') {

board->enpassant = coordinates_to_square(fen);

}

board->hash = zobrist_hash(board);

return board;

}

void board_print(const Board *self) {

for (int rank = 0; rank < 8; rank++) {

for (int file = 0; file < 8; file++) {

Square square = (7 - rank) * 8 + file;

Piece piece = NULL;

int color = -1;

if (bit_get(self->color[WHITE], square))

color = WHITE;

else if (bit_get(self->color[BLACK], square))

color = BLACK;

if (color != -1) {

for (int piece_index = 0; piece_index < 6; piece_index++) {

if (bit_get(self->piece[piece_index], square)) {

piece = piece_get(piece_index, color);

break;

}

}

}

if (!file) printf(" %d ", 8 - rank);

printf("%c ", (piece) ? piece_asci(piece) : '.');

}

printf("\n");

}

printf(" A B C D E F G H\n");

printf(" Side: %s\n", (self->side == WHITE) ? "white" : "black");

printf("Enpassant: %s\n", square_to_coordinates[self->enpassant]);

printf(" Castling: %c%c%c%c\n", (self->castle & WK) ? 'K' : '-',

(self->castle & WQ) ? 'Q' : '-', (self->castle & BK) ? 'k' : '-',

(self->castle & BQ) ? 'q' : '-');

printf(" Hash: %llx\n", self->hash);

printf("\n");

}

diff --git a/ src/board/board.cpp b/ src/board/board.cpp

@@ -0,0 +1,210 @@

#include <ctype.h>

#include <stdio.h>

#include <string.h>

#include "board.hpp"

#include "piece.hpp"

#include "utils_cpp.hpp"

#include "zobrist.hpp"

/* Getters */

Color Board::get_side(void) const { return side; }

U64 Board::get_hash(void) const { return hash; }

uint8_t Board::get_castle(void) const { return castle; }

Square Board::get_enpassant(void) const { return enpassant; }

U64 Board::get_bitboard_color(Color side) const {

return colors[to_underlying(side)];

}

U64 Board::get_bitboard_occupancy(void) const {

return colors[to_underlying(Color::WHITE)] |

colors[to_underlying(Color::BLACK)];

}

U64 Board::get_bitboard_piece(piece::Type piece) const {

return pieces[to_underlying(piece)];

}

U64 Board::get_bitboard_piece(const piece::Piece &piece) const {

return get_bitboard_piece(piece.type, piece.color);

}

U64 Board::get_bitboard_piece(piece::Type piece, Color color) const {

return pieces[to_underlying(piece)] & colors[to_underlying(color)];

}

U64 Board::get_bitboard_piece_attacks(piece::Type piece, Color color,

Square square) const {

return get_bitboard_piece_attacks(piece::get(piece, color), square);

}

U64 Board::get_bitboard_piece_attacks(const piece::Piece &piece,

Square square) const {

return piece.attacks(square, get_bitboard_occupancy());

}

Color Board::get_square_piece_color(Square square) const {

if (bit_get(colors[to_underlying(Color::WHITE)], to_underlying(square)))

return Color::WHITE;

if (bit_get(colors[to_underlying(Color::BLACK)], to_underlying(square)))

return Color::BLACK;

throw std::exception();

}

piece::Type Board::get_square_piece_type(Square square) const {

for (piece::Type type : piece::TypeIter()) {

if (bit_get(pieces[to_underlying(type)], to_underlying(square)))

return type;

}

throw std::exception();

}

const piece::Piece &Board::get_square_piece(Square square) const {

return piece::get(get_square_piece_type(square),

get_square_piece_color(square));

}

/* Setters */

void Board::and_castle(Castle right) { castle &= to_underlying(right); }

void Board::switch_side(void) {

side = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;

hash ^= zobrist_key_side();

}

void Board::set_enpassant(Square target) {

if (enpassant != Square::no_sq) hash ^= zobrist_key_enpassant(enpassant);

if (target != Square::no_sq) hash ^= zobrist_key_enpassant(target);

enpassant = target;

}

void Board::pop_bitboard_color(Color color, Square square) {

bit_pop(colors[to_underlying(color)], to_underlying(square));

}

void Board::set_bitboard_color(Color color, Square square) {

bit_set(colors[to_underlying(color)], to_underlying(square));

}

void Board::pop_bitboard_piece(const piece::Piece &piece, Square square) {

bit_pop(pieces[to_underlying(piece.type)], to_underlying(square));

}

void Board::set_bitboard_piece(const piece::Piece &piece, Square square) {

bit_set(pieces[to_underlying(piece.type)], to_underlying(square));

}

void Board::pop_piece(const piece::Piece &piece, Square square) {

pop_bitboard_color(piece.color, square);

pop_bitboard_piece(piece, square);

}

void Board::set_piece(const piece::Piece &piece, Square square) {

set_bitboard_color(piece.color, square);

set_bitboard_piece(piece, square);

}

/* Queries */

bool Board::is_square_occupied(Square square) const {

return bit_get(get_bitboard_occupancy(), to_underlying(square));

}

bool Board::is_square_attacked(Square square, Color side) const {

// side switch because of pawns

Color side_other = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;

for (piece::Type type : piece::TypeIter()) {

const piece::Piece &piece = piece::get(type, side_other);

if (get_bitboard_piece_attacks(piece, square) &

get_bitboard_piece(piece))

return 1;

}

return 0;

}

bool Board::is_check(void) const {

U64 king =

pieces[to_underlying(piece::Type::KING)] & colors[to_underlying(side)];

Square square = static_cast<Square>(bit_lsb_index(king));

return is_square_attacked(square, side);

}

Board::Board(const std::string &fen) {

*this = {0};

side = Color::WHITE;

enpassant = Square::no_sq;

castle = 0;

int file = 0, rank = 7, i;

for (i = 0; i < fen.size(); i++) {

if (isalpha(fen[i])) {

set_piece(piece::get_from_code(fen[i]),

static_cast<Square>(rank * 8 + file));

file++;

} else if (isdigit(fen[i])) {

file += fen[i] - '0';

} else if (fen[i] == '/') {

file = 0;

rank--;

} else {

throw std::exception();

}

}

i++;

if (fen[i] == 'w')

side = Color::WHITE;

else if (fen[i] == 'b')

side = Color::BLACK;

else

throw std::exception();

for (i += 2; fen[i] != ' '; i++) {

if (fen[i] == 'K')

castle |= to_underlying(Castle::WK);

else if (fen[i] == 'Q')

castle |= to_underlying(Castle::WQ);

else if (fen[i] == 'k')

castle |= to_underlying(Castle::BK);

else if (fen[i] == 'q')

castle |= to_underlying(Castle::BQ);

else

throw std::exception();

}

if (fen[++i] != '-') enpassant = square_from_coordinates(fen.data() + i);

hash = zobrist_hash(*this);

}

std::ostream &operator<<(std::ostream &os, const Board &board) {

for (int rank = 0; rank < 8; rank++) {

for (int file = 0; file < 8; file++) {

try {

Square square = static_cast<Square>((7 - rank) * 8 + file);

os << board.get_square_piece(square).code;

} catch (std::exception e) {

os << ". ";

}

}

printf("\n");

}

os << " A B C D E F G H\n";

os << " Side: ";

os << ((board.side == Color::WHITE) ? "white" : "black") << "\n";

os << "Enpassant: " << square_to_coordinates(board.enpassant) << "\n";

os << " Castle:";

os << ((board.castle & to_underlying(Board::Castle::WK)) ? 'K' : '-');

os << ((board.castle & to_underlying(Board::Castle::WQ)) ? 'Q' : '-');

os << ((board.castle & to_underlying(Board::Castle::BK)) ? 'k' : '-');

os << ((board.castle & to_underlying(Board::Castle::BQ)) ? 'q' : '-');

os << "\n Hash:" << board.hash << "\n\n";

return os;

}

diff --git a/ src/board/zobrist.c b/ src/board/zobrist.c

@@ -1,73 +0,0 @@

#include "zobrist.h"

#include "board.h"

#include "piece.h"

#include "random.h"

#include "utils.h"

U64 castle_keys[16];

U64 enpassant_keys[64];

U64 piece_keys[16][64];

U64 side_key;

U64 zobrist_key_side(void) { return side_key; }

U64 zobrist_key_castle(int exp) { return castle_keys[exp]; }

U64 zobrist_key_enpassant(Square square) { return enpassant_keys[square]; }

U64 zobrist_key_piece(Piece piece, Square square) {

return piece_keys[piece_index(piece)][square];

}

void init_hash_keys() {

random_state_reset();

for (int piece = PAWN; piece <= KING; piece++) {

int piece_index_white = piece_index(piece_get(piece, WHITE));

int piece_index_black = piece_index(piece_get(piece, BLACK));

for (int square = 0; square < 64; square++) {

piece_keys[piece_index_white][square] = random_get_U64();

piece_keys[piece_index_black][square] = random_get_U64();

}

}

for (int square = 0; square < 64; square++) {

enpassant_keys[square] = random_get_U64();

}

for (int castle = 0; castle < 16; castle++) {

castle_keys[castle] = random_get_U64();

}

side_key = random_get_U64();

}

void zobrist_init(void) { init_hash_keys(); }

U64 zobrist_hash(const Board *board) {

U64 key_final = C64(0);

Square square;

for (int piece = PAWN; piece <= KING; piece++) {

Piece piece_white = piece_get(piece, WHITE);

U64 bitboard_white = board_pieceSet(board, piece_white);

int piece_white_index = piece_index(piece_white);

bitboard_for_each_bit(square, bitboard_white) {

key_final ^= piece_keys[piece_white_index][square];

}

Piece piece_black = piece_get(piece, BLACK);

U64 bitboard_black = board_pieceSet(board, piece_black);

int piece_black_index = piece_index(piece_black);

bitboard_for_each_bit(square, bitboard_black) {

key_final ^= piece_keys[piece_black_index][square];

}

}

key_final ^= castle_keys[board_castle(board)];

if (board_side(board)) key_final ^= side_key;

if (board_enpassant(board) != no_sq)

key_final ^= enpassant_keys[board_enpassant(board)];

return key_final;

}

diff --git a/ src/board/zobrist.cpp b/ src/board/zobrist.cpp

@@ -0,0 +1,74 @@

#include "zobrist.hpp"

#include "piece.hpp"

#include "random.hpp"

#include "utils_cpp.hpp"

U64 castle_keys[16];

U64 enpassant_keys[64];

U64 piece_keys[16][64];

U64 side_key;

U64 zobrist_key_side(void) { return side_key; }

U64 zobrist_key_castle(int exp) { return castle_keys[exp]; }

U64 zobrist_key_enpassant(Square square) {

return enpassant_keys[to_underlying(square)];

}

U64 zobrist_key_piece(const piece::Piece &piece, Square square) {

return piece_keys[piece.index][to_underlying(square)];

}

void init_hash_keys() {

random_state_reset();

for (piece::Type type : piece::TypeIter()) {

int piece_index_white = piece::get(type, Color::WHITE).index;

int piece_index_black = piece::get(type, Color::BLACK).index;

for (int square = 0; square < 64; square++) {

piece_keys[piece_index_white][square] = random_get_U64();

piece_keys[piece_index_black][square] = random_get_U64();

}

}

for (int square = 0; square < 64; square++) {

enpassant_keys[square] = random_get_U64();

}

for (int castle = 0; castle < 16; castle++) {

castle_keys[castle] = random_get_U64();

}

side_key = random_get_U64();

}

void zobrist_init(void) { init_hash_keys(); }

U64 zobrist_hash(const Board &board) {

U64 key_final = C64(0);

uint8_t square;

for (piece::Type type : piece::TypeIter()) {

const piece::Piece &piece_white = piece::get(type, Color::WHITE);

int piece_white_index = piece_white.index;

U64 bitboard_white = board.get_bitboard_piece(piece_white);

bitboard_for_each_bit(square, bitboard_white) {

key_final ^= piece_keys[piece_white_index][square];

}

const piece::Piece &piece_black = piece::get(type, Color::BLACK);

int piece_black_index = piece_white.index;

U64 bitboard_black = board.get_bitboard_piece(piece_black);

bitboard_for_each_bit(square, bitboard_black) {

key_final ^= piece_keys[piece_black_index][square];

}

}

key_final ^= castle_keys[board.get_castle()];

if (board.get_side() == Color::BLACK) key_final ^= side_key;

if (board.get_enpassant() != Square::no_sq)

key_final ^= enpassant_keys[to_underlying(board.get_enpassant())];

return key_final;

}

diff --git a/ src/include/attacks.h b/ src/include/attacks.h

@@ -1,16 +0,0 @@

#ifndef STELLAR_ATTACKS_H

#define STELLAR_ATTACKS_H

#include "utils.h"

void attacks_init(void);

U64 attacks_wpawn_get(Square square, U64 occupancy);

U64 attacks_bpawn_get(Square square, U64 occupancy);

U64 attacks_knight_get(Square square, U64 occupancy);

U64 attakcs_king_get(Square square, U64 occupancy);

U64 attacks_bishop_get(Square square, U64 occupancy);

U64 attacks_rook_get(Square square, U64 occupancy);

U64 attacks_queen_get(Square square, U64 occupancy);

#endif

diff --git a/ src/include/attacks.hpp b/ src/include/attacks.hpp

@@ -0,0 +1,17 @@

#ifndef STELLAR_ATTACKS_H

#define STELLAR_ATTACKS_H

#include "utils_cpp.hpp"

void attacks_init(void);

typedef U64 (*attack_get_f)(Square square, U64 occupancy);

U64 attacks_wpawn_get(Square square, U64 occupancy);

U64 attacks_bpawn_get(Square square, U64 occupancy);

U64 attacks_knight_get(Square square, U64 occupancy);

U64 attacks_king_get(Square square, U64 occupancy);

U64 attacks_bishop_get(Square square, U64 occupancy);

U64 attacks_rook_get(Square square, U64 occupancy);

U64 attacks_queen_get(Square square, U64 occupancy);

#endif

diff --git a/ src/include/board.h b/ src/include/board.h

@@ -1,59 +0,0 @@

#ifndef STELLAR_BOARD_H

#define STELLAR_BOARD_H

#include "piece.h"

enum enumCastle {

WK = 1,

WQ = 2,

BK = 4,

BQ = 8

};

typedef enum enumCastle eCastle;

typedef struct Board Board;

struct Board {

U64 color[2];

U64 piece[6];

U64 hash;

eColor side;

Square enpassant;

eCastle castle;

};

Board *board_new(void);

void board_free(Board **p);

void board_copy(const Board *self, Board *dest);

U64 board_color(const Board *self, eColor color);

U64 board_occupancy(const Board *self);

U64 board_piece(const Board *self, ePiece piece);

eCastle board_castle(const Board *self);

eColor board_side(const Board *self);

Square board_enpassant(const Board *self);

U64 board_hash(const Board *self);

void board_side_switch(Board *self);

void board_enpassant_set(Board *self, Square target);

void board_castle_and(Board *self, int exp);

U64 board_pieceSet(const Board *self, Piece piece);

U64 board_piece_attacks(const Board *self, Piece piece, Square src);

void board_piece_pop(Board *self, Piece Piece, Square square);

void board_piece_set(Board *self, Piece Piece, Square square);

int board_piece_get(const Board *self, Square square);

U64 board_color_get(const Board *self, eColor color, Square target);

void board_color_pop(Board *self, eColor color, Square target);

void board_color_set(Board *self, eColor color, Square target);

Piece board_square_piece(const Board *self, Square square, eColor side);

int board_square_isAttack(const Board *self, Square square, eColor side);

int board_square_isOccupied(const Board *self, Square square);

Board *board_from_FEN(Board *board, const char *fen);

int board_isCheck(const Board *self);

void board_print(const Board *self);

#endif

diff --git a/ src/include/board.hpp b/ src/include/board.hpp

@@ -0,0 +1,84 @@

#ifndef STELLAR_BOARD_H

#define STELLAR_BOARD_H

#include "piece.hpp"

#include "utils_cpp.hpp"

#include <iostream>

#include <string>

typedef struct Board Board;

class Board {

public:

enum class Castle : uint8_t {

WK = 1,

WQ = 2,

BK = 4,

BQ = 8

};

Board() {}

Board(const std::string &fen);

friend std::ostream &operator<<(std::ostream &os, const Board &board);

/* Getters */

U64 get_hash(void) const;

Color get_side(void) const;

uint8_t get_castle(void) const;

Square get_enpassant(void) const;

U64 get_bitboard_color(Color side) const;

U64 get_bitboard_occupancy(void) const;

U64 get_bitboard_piece(piece::Type piece) const;

U64 get_bitboard_piece(piece::Type piece, Color color) const;

U64 get_bitboard_piece(const piece::Piece &piece) const;

U64 get_bitboard_piece_attacks(piece::Type piece, Color color,

Square square) const;

U64 get_bitboard_piece_attacks(const piece::Piece &piece,

Square square) const;

// exception if not found

Color get_square_piece_color(Square square) const;

piece::Type get_square_piece_type(Square square) const;

const piece::Piece &get_square_piece(Square square) const;

/* Setters */

void switch_side(void);

void and_castle(Castle right);

void set_enpassant(Square target);

void pop_bitboard_color(Color color, Square square);

void set_bitboard_color(Color color, Square square);

void pop_bitboard_piece(const piece::Piece &piece, Square square);

void set_bitboard_piece(const piece::Piece &piece, Square square);

void pop_piece(const piece::Piece &piece, Square square);

void set_piece(const piece::Piece &piece, Square square);

/* Queries */

bool is_square_attacked(Square Square, Color side) const;

bool is_square_occupied(Square Square) const;

bool is_check(void) const;

private:

U64 colors[2];

U64 pieces[6];

U64 hash;

Color side;

Square enpassant;

uint8_t castle;

};

const piece::Piece &board_square_piece(const Board *self, Square square,

Color side);

void board_print(const Board *self);

#endif

diff --git a/ src/include/piece.h b/ src/include/piece.h

@@ -1,36 +0,0 @@

#ifndef STELLAR_PIECE_H

#define STELLAR_PIECE_H

#include "attacks.h"

typedef const struct Piece *Piece;

typedef enum enumColor eColor;

enum enumColor {

WHITE = 0,

BLACK

};

typedef enum enumPiece ePiece;

enum enumPiece {

PAWN = 0,

KNIGHT,

BISHOP,

ROOK,

QUEEN,

KING

};

char piece_asci(Piece self);

attack_f piece_attacks(Piece self);

char piece_code(Piece self);

char *piece_unicode(Piece self);

eColor piece_color(Piece self);

ePiece piece_piece(Piece self);

int piece_index(Piece self);

Piece piece_get(ePiece piece, eColor color);

Piece piece_from_code(char code);

Piece piece_from_index(int index);

#endif

diff --git a/ src/include/piece.hpp b/ src/include/piece.hpp

@@ -0,0 +1,113 @@

#ifndef STELLAR_PIECE_H

#define STELLAR_PIECE_H

#include "attacks.hpp"

#include "utils_cpp.hpp"

#include <cctype>

namespace piece {

enum class Type {

PAWN = 0,

KNIGHT,

BISHOP,

ROOK,

QUEEN,

KING,

TypeSIZE

};

typedef Iterator<Type, Type::PAWN, Type::KING> TypeIter;

class Piece {

public:

const Type type;

const Color color;

const char code;

const char *symbol;

const attack_get_f attacks;

const uint8_t index;

protected:

constexpr Piece(Type type, Color color, char code, const char *symbol,

attack_get_f attacks)

: type(type), color(color), code(code), symbol(symbol),

attacks(attacks), index(index_calc()) {}

constexpr int index_calc() {

return to_underlying(Type::TypeSIZE) * to_underlying(color) *

to_underlying(type);

}

};

class Pawn : public Piece {

public:

constexpr Pawn(Color color)

: Piece(Type::PAWN, color, color == Color::WHITE ? 'P' : 'p',

color == Color::WHITE ? "■ " : "■ ",

color == Color::WHITE ? attacks_wpawn_get : attacks_bpawn_get) {

}

};

class Knight : public Piece {

public:

constexpr Knight(Color color)

: Piece(Type::KNIGHT, color, color == Color::WHITE ? 'N' : 'n',

color == Color::WHITE ? "■ " : "■ ", attacks_knight_get) {}

};

class Bishop : public Piece {

public:

constexpr Bishop(Color color)

: Piece(Type::BISHOP, color, color == Color::WHITE ? 'B' : 'b',

color == Color::WHITE ? "■ " : "■ ", attacks_bishop_get) {}

};

class Rook : public Piece {

public:

constexpr Rook(Color color)

: Piece(Type::ROOK, color, color == Color::WHITE ? 'R' : 'r',

color == Color::WHITE ? "■ " : "■ ", attacks_rook_get) {}

};

class Queen : public Piece {

public:

constexpr Queen(Color color)

: Piece(Type::QUEEN, color, color == Color::WHITE ? 'Q' : 'q',

color == Color::WHITE ? "■ " : "■ ", attacks_queen_get) {}

};

class King : public Piece {

public:

constexpr King(Color color)

: Piece(Type::KING, color, color == Color::WHITE ? 'K' : 'k',

color == Color::WHITE ? "■ " : "■ ", attacks_king_get) {}

};

const constexpr Piece table[2][6] = {

{Pawn(Color::WHITE), Knight(Color::WHITE), Bishop(Color::WHITE),

Rook(Color::WHITE), Queen(Color::WHITE), King(Color::WHITE)},

{Pawn(Color::BLACK), Knight(Color::BLACK), Bishop(Color::BLACK),

Rook(Color::BLACK), Queen(Color::BLACK), King(Color::BLACK)},

};

constexpr const Piece &get(Type type, Color color) {

return table[static_cast<int>(color)][static_cast<int>(type)];

}

constexpr const Piece &get_from_code(char code) {

Color color = isupper(code) ? Color::WHITE : Color::BLACK;

for (Type type : TypeIter()) {

const Piece &piece = get(type, color);

if (piece.code == code) return piece;

}

throw std::exception();

}

// constexpr const Piece &get_from_index(uint8_t index);

} // namespace piece

#endif

diff --git a/ src/include/random.h b/ src/include/random.h

@@ -1,7 +1,7 @@ #ifndef STELLAR_RANDOM_H #define STELLAR_RANDOM_H

#include "utils.h"

#include "utils.hpp"

void random_state_reset(); U32 random_get_U32();

diff --git a/ src/include/random.hpp b/ src/include/random.hpp

@@ -0,0 +1,10 @@

#ifndef STELLAR_RANDOM_H

#define STELLAR_RANDOM_H

#include "utils_cpp.hpp"

void random_state_reset();

U32 random_get_U32();

U64 random_get_U64();

#endif

diff --git a/ src/include/utils.h b/ src/include/utils.h

@@ -48,10 +48,10 @@ enum enumSquare { a8, b8, c8, d8, e8, f8, g8, h8, no_sq }; // clang-format on

typedef enum enumSquare Square;

typedef enum enumSquare eSquare;

extern const char *square_to_coordinates[];

Square coordinates_to_square(const char *cord);

eSquare coordinates_to_square(const char *cord);

// board moving typedef U64 (*direction_f)(U64);

@@ -70,7 +70,7 @@ U64 rotateRight(U64 x, int s); int get_time_ms(void);

typedef U64 (*attack_f)(Square square, U64 occupancy);

typedef U64 (*attack_f)(eSquare square, U64 occupancy);

#define empty_board "8/8/8/8/8/8/8/8 w - - " #define start_position \

diff --git a/ src/include/utils_cpp.hpp b/ src/include/utils_cpp.hpp

@@ -0,0 +1,123 @@

#ifndef STELLAR_UTILS_CPP_H

#define STELLAR_UTILS_CPP_H

#include <cstdint>

#include <exception>

#include <type_traits>

template <typename E>

constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {

return static_cast<typename std::underlying_type<E>::type>(e);

}

template <typename C, C beginVal, C endVal> class Iterator {

typedef typename std::underlying_type<C>::type val_t;

int val;

public:

constexpr Iterator(const C &f) : val(static_cast<val_t>(f)) {}

constexpr Iterator() : val(static_cast<val_t>(beginVal)) {}

constexpr Iterator operator++() {

++val;

return *this;

}

constexpr C operator*() { return static_cast<C>(val); }

constexpr Iterator begin() { return *this; }

constexpr Iterator end() {

// static const Iterator endIter = ++Iterator(endVal);

// return endIter;

return ++Iterator(endVal);

}

constexpr bool operator!=(const Iterator &i) { return val != i.val; }

};

#define C64(constantU64) constantU64##ULL

typedef uint64_t U64;

typedef uint32_t U32;

enum class Color : uint8_t {

WHITE = 0,

BLACK

};

// clang-format off

enum class Square: uint8_t {

a1, b1, c1, d1, e1, f1, g1, h1,

a2, b2, c2, d2, e2, f2, g2, h2,

a3, b3, c3, d3, e3, f3, g3, h3,

a4, b4, c4, d4, e4, f4, g4, h4,

a5, b5, c5, d5, e5, f5, g5, h5,

a6, b6, c6, d6, e6, f6, g6, h6,

a7, b7, c7, d7, e7, f7, g7, h7,

a8, b8, c8, d8, e8, f8, g8, h8, no_sq

};

// clang-format on

typedef Iterator<Square, Square::a1, Square::h8> SquareIter;

inline Square square_from_coordinates(const char *cord) {

return static_cast<Square>((cord[1] - '1') * 8 + (cord[0] - 'a'));

}

// clang-format off

inline const char *square_to_coordinates(Square square) {

static const char *map[]={

"a1", "b1", "c1", "d1", "e1", "f1", "g1", "h1",

"a2", "b2", "c2", "d2", "e2", "f2", "g2", "h2",

"a3", "b3", "c3", "d3", "e3", "f3", "g3", "h3",

"a4", "b4", "c4", "d4", "e4", "f4", "g4", "h4",

"a5", "b5", "c5", "d5", "e5", "f5", "g5", "h5",

"a6", "b6", "c6", "d6", "e6", "f6", "g6", "h6",

"a7", "b7", "c7", "d7", "e7", "f7", "g7", "h7",

"a8", "b8", "c8", "d8", "e8", "f8", "g8", "h8", " "

};

return map[to_underlying(square)];

}

// clang-format on

// useful bit functions

#define bit_get(bitboard, square) (((bitboard) >> (square)) & C64(1))

#define bit_set(bitboard, square) ((bitboard) |= C64(1) << (square))

#define bit_pop(bitboard, square) ((bitboard) &= ~(C64(1) << (square)))

inline uint8_t bit_count(U64 bitboard) {

#if __has_builtin(__builtin_popcountll)

return __builtin_popcountll(bitboard);

#endif

int count = 0;

for (; bitboard > 0; bitboard &= bitboard - 1)

count++;

return count;

}

inline uint8_t bit_lsb_index(U64 bitboard) {

#if __has_builtin(__builtin_ffsll)

return __builtin_ffsll(bitboard) - 1;

#endif

if (!bitboard) return -1;

return bit_count((bitboard & -bitboard) - 1);

}

#define bit_lsb_pop(bitboard) ((bitboard) &= (bitboard) & ((bitboard)-1))

#define bitboard_for_each_bit(var, bb) \

for (var = bit_lsb_index(bb); bb; bit_lsb_pop(bb), var = bit_lsb_index(bb))

// board moving

const U64 universe = C64(0xffffffffffffffff);

const U64 notAFile = C64(0xfefefefefefefefe);

const U64 notHFile = C64(0x7f7f7f7f7f7f7f7f);

typedef U64 (*direction_f)(U64);

inline U64 soutOne(U64 b) { return b >> 8; }

inline U64 nortOne(U64 b) { return b << 8; }

inline U64 eastOne(U64 b) { return (b & notHFile) << 1; }

inline U64 westOne(U64 b) { return (b & notAFile) >> 1; }

inline U64 soEaOne(U64 b) { return (b & notHFile) >> 7; }

inline U64 soWeOne(U64 b) { return (b & notAFile) >> 9; }

inline U64 noEaOne(U64 b) { return (b & notHFile) << 9; }

inline U64 noWeOne(U64 b) { return (b & notAFile) << 7; }

#endif

diff --git a/ src/include/zobrist.h b/ src/include/zobrist.h

@@ -1,14 +0,0 @@

#ifndef STELLAR_ZOBRIST_H

#define STELLAR_ZOBRIST_H

#include "board.h"

void zobrist_init(void);

U64 zobrist_hash(const Board *board);

U64 zobrist_key_side(void);

U64 zobrist_key_castle(int exp);

U64 zobrist_key_enpassant(Square square);

U64 zobrist_key_piece(Piece piece, Square square);

#endif

diff --git a/ src/include/zobrist.hpp b/ src/include/zobrist.hpp

@@ -0,0 +1,14 @@

#ifndef STELLAR_ZOBRIST_H

#define STELLAR_ZOBRIST_H

#include "board.hpp"

void zobrist_init(void);

U64 zobrist_hash(const Board &board);

U64 zobrist_key_side(void);

U64 zobrist_key_castle(int exp);

U64 zobrist_key_enpassant(Square square);

U64 zobrist_key_piece(const piece::Piece &piece, Square square);

#endif

diff --git a/ src/perft/CMakeLists.txt b/ src/perft/CMakeLists.txt

@@ -2,7 +2,7 @@ project( perft VERSION 1.1.0 DESCRIPTION "Performance Test"

LANGUAGES C

LANGUAGES C CXX

) add_executable(perft perft.c)

diff --git a/ src/piece/CMakeLists.txt b/ src/piece/CMakeLists.txt

@@ -1,5 +1,5 @@ add_library(piece OBJECT

piece.c

piece.cpp

) target_include_directories(piece

diff --git a/ src/piece/piece.c b/ src/piece/piece.c

@@ -1,51 +0,0 @@

#include <ctype.h>

#include <stdlib.h>

#include "piece.h"

struct Piece {

attack_f attacks;

char *unicode;

ePiece piece;

eColor color;

char code;

char asci;

};

// clang-format off

const struct Piece Pieces[2][6] = {

[WHITE] = {

[KNIGHT] = {.color = WHITE, .code = 'N', .asci = 'N', .unicode = "♘ ", .piece = KNIGHT, .attacks = attacks_knight_get},

[BISHOP] = {.color = WHITE, .code = 'B', .asci = 'B', .unicode = "♗ ", .piece = BISHOP, .attacks = attacks_bishop_get},

[QUEEN] = {.color = WHITE, .code = 'Q', .asci = 'Q', .unicode = "♕ ", .piece = QUEEN, .attacks = attacks_queen_get},

[KING] = {.color = WHITE, .code = 'K', .asci = 'K', .unicode = "♔ ", .piece = KING, .attacks = attakcs_king_get},

[PAWN] = {.color = WHITE, .code = 'P', .asci = 'P', .unicode = "♙ ", .piece = PAWN, .attacks = attacks_wpawn_get},

[ROOK] = {.color = WHITE, .code = 'R', .asci = 'R', .unicode = "♖ ", .piece = ROOK, .attacks = attacks_rook_get},

},

[BLACK] = {

[KNIGHT] = {.color = BLACK, .code = 'n', .asci = 'n', .unicode = "♞ ", .piece = KNIGHT, .attacks = attacks_knight_get},

[BISHOP] = {.color = BLACK, .code = 'b', .asci = 'b', .unicode = "♝ ", .piece = BISHOP, .attacks = attacks_bishop_get},

[QUEEN] = {.color = BLACK, .code = 'q', .asci = 'q', .unicode = "♛ ", .piece = QUEEN, .attacks = attacks_queen_get},

[KING] = {.color = BLACK, .code = 'k', .asci = 'k', .unicode = "♚ ", .piece = KING, .attacks = attakcs_king_get},

[PAWN] = {.color = BLACK, .code = 'p', .asci = 'p', .unicode = "♟ ", .piece = PAWN, .attacks = attacks_bpawn_get},

[ROOK] = {.color = BLACK, .code = 'r', .asci = 'r', .unicode = "♜ ", .piece = ROOK, .attacks = attacks_rook_get},

},

};

// clang-format on

attack_f piece_attacks(Piece self) { return self->attacks; }

char piece_asci(Piece self) { return self->asci; }

char piece_code(Piece self) { return self->code; }

char *piece_unicode(Piece self) { return self->unicode; }

eColor piece_color(Piece self) { return self->color; }

ePiece piece_piece(Piece self) { return self->piece; }

int piece_index(Piece self) { return self->color * 8 + self->piece; }

Piece piece_get(ePiece piece, eColor color) { return &Pieces[color][piece]; }

Piece piece_from_index(int index) { return &Pieces[index / 8][index % 8]; }

Piece piece_from_code(char code) {

int color = (isupper(code)) ? WHITE : BLACK;

for (int i = 0; i < 6; i++)

if (Pieces[color][i].code == code) return &Pieces[color][i];

return NULL;

}

diff --git a/ src/piece/piece.cpp b/ src/piece/piece.cpp

@@ -0,0 +1,6 @@

#include "piece.hpp"

#include <iostream>

int main(void) {

std::cout << piece::get(piece::Type::PAWN, Color::WHITE).code << std::endl;

}

diff --git a/ src/utils/utils.c b/ src/utils/utils.c

@@ -53,7 +53,7 @@ const char *square_to_coordinates[]={ }; // clang-format on

Square coordinates_to_square(const char *cord) {

eSquare coordinates_to_square(const char *cord) {

return (cord[1] - '1') * 8 + (cord[0] - 'a'); }