stellar

Improve Move and MoveList

24 files changed, 523 insertions(+), 591 deletions(-)

diff --git a/ .clang-format b/ .clang-format

@@ -36,7 +36,7 @@ AllowAllParametersOfDeclarationOnNextLine: true AllowShortEnumsOnASingleLine: false AllowShortBlocksOnASingleLine: Never AllowShortCaseLabelsOnASingleLine: false

AllowShortFunctionsOnASingleLine: false

AllowShortFunctionsOnASingleLine: true

AllowShortLambdasOnASingleLine: All AllowShortIfStatementsOnASingleLine: true AllowShortLoopsOnASingleLine: false

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

@@ -10,30 +10,18 @@ /* 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;

}

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_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(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);

@@ -51,6 +39,14 @@ U64 Board::get_bitboard_piece_attacks(const piece::Piece &piece, Square square) return piece(square, get_bitboard_occupancy()); }

U64 Board::get_bitboard_piece_moves(piece::Type piece, Color color, Square square) const {

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

}

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

return get_bitboard_piece_attacks(piece, square) & ~get_bitboard_color(piece.color);

}

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;

@@ -74,12 +70,8 @@ const piece::Piece *Board::get_square_piece(Square square) const { /* Setters */

void Board::xor_hash(U64 op) {

hash ^= op;

}

void Board::and_castle(uint8_t right) {

castle &= right;

}

void Board::xor_hash(U64 op) { hash ^= op; }

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

void Board::switch_side(void) { side = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;

@@ -137,6 +129,10 @@ bool Board::is_square_attacked(Square square, Color side) const { return 0; }

bool Board::is_piece_attack_square(const piece::Piece &piece, Square source, Square target) const {

return get_bitboard_piece_attacks(piece, source) & (C64(1) << to_underlying(target));

}

bool Board::is_check(void) const { U64 king = pieces[to_underlying(piece::Type::KING)] & colors[to_underlying(side)]; Color side_other = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;

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

@@ -5,7 +5,8 @@ #include "attack.hpp" #include "board.hpp"

#include "moves.hpp"

#include "move.hpp"

#include "movelist.hpp"

#include "score.hpp" #include "stats.hpp" #include "transposition.hpp"

@@ -18,26 +19,6 @@ #define WINDOW 50

void move_list_sort_pv(std::vector<MoveE> &list, Stats &stats, Move best) {

for (MoveE &move : list) {

if (move_cmp(best, move.move)) {

move.score = 30000;

return;

}

}

if (stats.ply && stats.follow_pv) {

stats.follow_pv = 0;

for (MoveE &move : list) {

if (move_cmp(stats.pv_table[0][stats.ply], move.move)) {

move.score = 20000;

stats.follow_pv = 1;

break;

}

}

}

}

/* SEARCHING */ int evaluate(const Board &board) {

@@ -65,13 +46,11 @@ int evaluate(const Board &board) { return score; }

int is_repetition() {

return 0;

}

int is_repetition() { return 0; }

int stats_move_make(Stats &stats, Board &copy, Move move, int flag) { copy = stats.board;

if (!move_make(move, stats.board, flag)) {

if (!move.make(stats.board, flag)) {

stats.board = copy; return 0; }

@@ -110,12 +89,20 @@ int quiescence(Stats &stats, int alpha, int beta) { if (score > alpha) alpha = score; Board copy;

std::vector<MoveE> list = move_list_generate(stats.board);

Score_move_list(stats, list);

move_list_sort_pv(list, stats, {0});

move_list_sort(list);

bool pv_flag = false;

const auto score_move = [&stats, &pv_flag](Move move) -> U32 {

if (stats.ply && stats.follow_pv) {

stats.follow_pv = 0;

if (stats.pv_table[0][stats.ply] == move) {

pv_flag = true;

return 20000;

}

}

return Score_move(stats, move);

};

stats.follow_pv = pv_flag;

for (const auto [move, _] : list) {

for (const auto [move, _] : MoveList(stats.board, score_move)) {

if (!stats_move_make(stats, copy, move, 1)) continue; score = -quiescence(stats, -beta, -alpha); stats_move_unmake(stats, copy);

@@ -133,8 +120,8 @@ int quiescence(Stats &stats, int alpha, int beta) { int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { int pv_node = (beta - alpha) > 1; HasheFlag flag = HasheFlag::Alpha;

Move bestMove = {0};

int futility = 0;

Move bestMove;

Board copy; stats.pv_length[stats.ply] = stats.ply;

@@ -196,19 +183,28 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { if (depth < 4 && abs(alpha) < MATE_SCORE && staticEval + margin[depth] <= alpha) futility = 1; }

std::vector<MoveE> list = move_list_generate(stats.board);

Score_move_list(stats, list);

move_list_sort_pv(list, stats, bestMove);

move_list_sort(list);

bool pv_flag = false;

const auto score_move = [&stats, &bestMove, &pv_flag](Move move) -> U32 {

if (move == bestMove) return 30000;

if (stats.ply && stats.follow_pv) {

stats.follow_pv = 0;

if (stats.pv_table[0][stats.ply] == move) {

pv_flag = true;

return 20000;

}

}

return Score_move(stats, move);

};

stats.follow_pv = pv_flag;

int legal_moves = 0; int searched = 0;

for (const auto [move, _] : list) {

for (const auto [move, _] : MoveList(stats.board, score_move)) {

if (!stats_move_make(stats, copy, move, 0)) continue; legal_moves++; // futility pruning

if (futility && searched && !move_capture(move) && !move_promote(move) && !stats.board.is_check()) {

if (futility && searched && !move.is_capture() && !move.is_promote() && !stats.board.is_check()) {

stats_move_unmake(stats, copy); continue; }

@@ -218,11 +214,11 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { } else { // Late Move Reduction if (!pv_node && searched >= FULL_DEPTH && depth >= REDUCTION_LIMIT && !isCheck &&

!move_capture(move) && !move_promote(move) &&

(move_source(move) != move_source(stats.killer[0][stats.ply]) ||

move_target(move) != move_target(stats.killer[0][stats.ply])) &&

(move_source(move) != move_source(stats.killer[1][stats.ply]) ||

move_target(move) != move_target(stats.killer[1][stats.ply]))) {

!move.is_capture() && !move.is_promote() &&

(move.source() != stats.killer[0][stats.ply].source() ||

move.target() != stats.killer[0][stats.ply].target()) &&

(move.source() != stats.killer[1][stats.ply].source() ||

move.target() != stats.killer[1][stats.ply].target())) {

score = -negamax(stats, -alpha - 1, -alpha, depth - 2, true); } else score = alpha + 1;

@@ -242,8 +238,8 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { searched++; if (score > alpha) {

if (!move_capture(move)) {

stats.history[move_piece(move).index][move_target(move)] += depth;

if (!move.is_capture()) {

stats.history[move.piece().index][to_underlying(move.target())] += depth;

} alpha = score;

@@ -254,7 +250,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { if (score >= beta) { stats.ttable.write(stats, bestMove, beta, depth, HasheFlag::Beta);

if (!move_capture(move)) {

if (!move.is_capture()) {

stats.killer[1][stats.ply] = stats.killer[0][stats.ply]; stats.killer[0][stats.ply] = move; }

@@ -276,23 +272,22 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) { } void move_print_UCI(Move move) {

printf("%s%s", square_to_coordinates(static_cast<Square>(move_source(move))),

square_to_coordinates(static_cast<Square>(move_target(move))));

if (move_promote(move)) printf("%c", (move_piece_promote(move).code));

std::cout << square_to_coordinates(move.source()) << square_to_coordinates(move.target());

if (move.is_promote()) std::cout << move.piece_promote().code;

} TTable ttable(C64(0x400000)); void search_position(Board &board, int depth) {

Stats stats = {ttable, board, 0};

Stats stats = {ttable, board};

int alpha = -INFINITY, beta = INFINITY;

int alpha = -SCORE_INFINITY, beta = SCORE_INFINITY;

for (int crnt = 1; crnt <= depth;) { stats.follow_pv = 1; int score = negamax(stats, alpha, beta, crnt, true); if ((score <= alpha) || (score >= beta)) {

alpha = -INFINITY;

beta = INFINITY;

alpha = -SCORE_INFINITY;

beta = SCORE_INFINITY;

continue; } alpha = score - WINDOW;

@@ -300,27 +295,28 @@ void search_position(Board &board, int depth) { if (stats.pv_length[0]) { if (score > -MATE_VALUE && score < -MATE_SCORE) {

printf("info score mate %d depth %d nodes %ld pv ", -(score + MATE_VALUE) / 2 - 1, crnt,

stats.nodes);

std::cout << "info score mate " << -(score + MATE_VALUE) / 2 - 1;

} else if (score > MATE_SCORE && score < MATE_VALUE) {

printf("info score mate %d depth %d nodes %ld pv ", (MATE_VALUE - score) / 2 + 1, crnt,

stats.nodes);

std::cout << "info score mate " << (MATE_VALUE - score) / 2 + 1;

} else {

printf("info score cp %d depth %d nodes %ld pv ", score, crnt, stats.nodes);

std::cout << "info score " << score;

}

std::cout << " depth " << crnt;

std::cout << " nodes " << stats.nodes;

std::cout << " pv ";

for (int i = 0; i < stats.pv_length[0]; i++) { move_print_UCI(stats.pv_table[0][i]);

printf(" ");

std::cout << " ";

}

printf("\n");

std::cout << "\n";

} crnt++; }

printf("bestmove ");

std::cout << "bestmove ";

move_print_UCI(stats.pv_table[0][0]);

printf("\n");

std::cout << "\n";

} void print_info(void) {

@@ -354,9 +350,7 @@ void Instruction_free(Instruction **p) { delete (*p); }

char *Instruction_token(Instruction *self) {

return self->token;

}

char *Instruction_token(Instruction *self) { return self->token; }

char *Instruction_token_n(Instruction *self, int n) { while (isspace(*self->crnt) && *self->crnt != '\0') self->crnt++;

@@ -382,28 +376,21 @@ char *Instruction_token_n(Instruction *self, int n) { return self->token; }

char *Instruction_token_next(Instruction *self) {

return Instruction_token_n(self, 1);

}

Move parse_move(Board &board, char *move_string) {

Move result = {0};

char *Instruction_token_next(Instruction *self) { return Instruction_token_n(self, 1); }

uint8_t source = to_underlying(square_from_coordinates(move_string));

uint8_t target = to_underlying(square_from_coordinates(move_string + 2));

Move parse_move(const Board &board, char *move_string) {

Square source = square_from_coordinates(move_string);

Square target = square_from_coordinates(move_string + 2);

std::vector<MoveE> list = move_list_generate(board);

for (const auto [move, _] : list) {

if (move_source(move) == source && move_target(move) == target) {

for (const auto [move, _] : MoveList(board)) {

if (move.source() == source && move.target() == target) {

if (move_string[4]) {

if (tolower(move_piece_promote(move).code) != move_string[4]) continue;

if (tolower(move.piece_promote().code) != move_string[4]) continue;

}

result = move;

break;

return move;

} }

return result;

return {};

} Board *Instruction_parse(Instruction *self, Board &board) {

@@ -434,8 +421,8 @@ Board *Instruction_parse(Instruction *self, Board &board) { if (strcmp(token, "moves") == 0) { while ((token = Instruction_token_next(self))) { Move move = parse_move(board, token);

if (!move_cmp(move, {0})) {

move_make(move, board, 0);

if (move == Move()) {

move.make(board, 0);

} else { printf("Invalid move %s!\n", token); }

diff --git a/ src/engine/score.cpp b/ src/engine/score.cpp

@@ -1,5 +1,5 @@ #include "score.hpp"

#include "moves.hpp"

#include "move.hpp"

#include "stats.hpp" #include "utils_cpp.hpp"

@@ -98,33 +98,26 @@ const Square mirror_score[128] = }; // clang-format on

int Score_value(piece::Type piece) {

return Scores[to_underlying(piece)].value;

}

int Score_value(piece::Type piece) { return Scores[to_underlying(piece)].value; }

int Score_position(piece::Type piece, Color color, Square square) { if (color == Color::BLACK) square = mirror_score[to_underlying(square)]; return Scores[to_underlying(piece)].position[to_underlying(square)]; }

int Score_move(const Stats &stats, Move move) {

const int piece = to_underlying(move_piece(move).type);

const int capture = to_underlying(move_piece_capture(move).type);

if (move_capture(move)) {

return Scores[piece].capture[capture] + 10000;

}

U32 Score_move(const Stats &stats, Move move) {

const int piece = to_underlying(move.piece().type);

const int capture = to_underlying(move.piece_capture().type);

if (move_cmp(stats.killer[0][stats.ply], move))

return 9000;

else if (move_cmp(stats.killer[1][stats.ply], move))

return 8000;

if (move.is_capture()) return Scores[piece].capture[capture] + 10000;

if (stats.killer[0][stats.ply] == move) return 9000;

if (stats.killer[1][stats.ply] == move) return 8000;

return stats.history[piece][move_target(move)];

return stats.history[piece][to_underlying(move.target())];

}

void Score_move_list(const Stats &stats, std::vector<MoveE> &list) {

for (MoveE &move : list) {

move.score = Score_move(stats, move.move);

void Score_move_list(const Stats &stats, MoveList &list) {

for (auto &moveE : list) {

moveE.score = Score_move(stats, moveE.move);

} }

diff --git a/ src/engine/score.hpp b/ src/engine/score.hpp

@@ -2,14 +2,15 @@ #define STELLAR_SCORE_H #include "board.hpp"

#include "moves.hpp"

#include "movelist.hpp"

#include "stats.hpp"

#define INFINITY 50000

#define SCORE_INFINITY 50000

#define MATE_VALUE 49000 #define MATE_SCORE 48000

void Score_move_list(const Stats &stats, std::vector<MoveE> &list);

U32 Score_move(const Stats &stats, Move move);

void Score_move_list(const Stats &stats, MoveList &list);

int Score_position(piece::Type piece, Color color, Square square); int Score_capture(piece::Type src, piece::Type tgt); int Score_value(piece::Type piece);

diff --git a/ src/engine/stats.hpp b/ src/engine/stats.hpp

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

#include "moves.hpp"

#include "move.hpp"

#include "utils_cpp.hpp" #define MAX_PLY 64

diff --git a/ src/engine/transposition.hpp b/ src/engine/transposition.hpp

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

#include "moves.hpp"

#include "move.hpp"

#include "stats.hpp" #include "utils_cpp.hpp"

@@ -28,12 +28,9 @@ struct Hashe { class TTable { public:

TTable(U64 size) : table(size, {0}) {

}

TTable(U64 size) : table(size, {0}) {}

void clear() {

table.clear();

};

void clear() { table.clear(); };

void write(const Stats &stats, Move best, int score, int depth, HasheFlag flag); int read(const Stats &stats, Move *best, int alpha, int beta, int depth) const;

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

@@ -50,9 +50,7 @@ class SliderRook : public Slider { return (key * rook_magic_numbers[square_i]) >> (64 - relevant_bits[square_i]); }

virtual constexpr U64 mask(Square square) const override {

return masks[to_underlying(square)];

}

virtual constexpr U64 mask(Square square) const override { return masks[to_underlying(square)]; }

virtual constexpr U64 mask_fly(Square square, U64 block) const override { uint8_t square_i = to_underlying(square);

@@ -98,9 +96,7 @@ class SliderBishop : public Slider { return (key * bishop_magic_numbers[square_i]) >> (64 - relevant_bits[square_i]); }

virtual constexpr U64 mask(Square square) const override {

return masks[to_underlying(square)];

}

virtual constexpr U64 mask(Square square) const override { return masks[to_underlying(square)]; }

virtual constexpr U64 mask_fly(Square square, U64 block) const override { uint8_t square_i = to_underlying(square);

@@ -197,8 +193,7 @@ class Bishop : public Attack { class King : public Attack { public:

constexpr King() {

}

constexpr King() {}

virtual constexpr U64 operator()(Square square, U64 occupancy) const override { return attacks[to_underlying(square)];

@@ -229,8 +224,7 @@ class King : public Attack { class Knight : public Attack { public:

constexpr Knight() {

}

constexpr Knight() {}

virtual constexpr U64 operator()(Square square, U64 occupancy) const override { return attacks[to_underlying(square)];

@@ -264,8 +258,7 @@ class Knight : public Attack { class PawnW : public Attack { public:

constexpr PawnW() {

}

constexpr PawnW() {}

virtual constexpr U64 operator()(Square square, U64 occupancy) const override { return attacks[to_underlying(square)];

@@ -290,8 +283,7 @@ class PawnW : public Attack { class PawnB : public Attack { public:

constexpr PawnB() {

}

constexpr PawnB() {}

virtual constexpr U64 operator()(Square square, U64 occupancy) const override { return attacks[to_underlying(square)];

@@ -323,8 +315,7 @@ inline constexpr const PawnB pawnB; class Queen : public Attack { public:

constexpr Queen() {

}

constexpr Queen() {}

virtual constexpr U64 operator()(Square square, U64 occupancy) const override { return rook(square, occupancy) | bishop(square, occupancy);

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

@@ -17,8 +17,7 @@ class Board { BQ = 8 };

Board() {

}

Board() {}

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

@@ -39,6 +38,8 @@ class Board { 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;

U64 get_bitboard_piece_moves(piece::Type piece, Color color, Square square) const;

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

Color get_square_piece_color(Square square) const; piece::Type get_square_piece_type(Square square) const;

@@ -64,6 +65,7 @@ class Board { bool is_square_attacked(Square Square, Color side) const; bool is_square_occupied(Square Square) const;

bool is_piece_attack_square(const piece::Piece &piece, Square source, Square target) const;

bool is_check(void) const; private:

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

@@ -0,0 +1,57 @@

#ifndef STELLAR_MOVES_H

#define STELLAR_MOVES_H

#include "board.hpp"

#include "piece.hpp"

#include "utils_cpp.hpp"

#include <iostream>

#include <vector>

struct Move {

Move(){};

Move(Square source, Square target, const piece::Piece *piece, const piece::Piece *capture,

const piece::Piece *promote, bool dbl, bool enpassant, bool castle)

: source_i(to_underlying(source)), target_i(to_underlying(target)), piece_i(piece->index),

piece_capture_i(capture ? capture->index : 0), piece_promote_i(promote ? promote->index : 0),

dbl(dbl), enpassant(enpassant), castle(castle), capture(capture != NULL), promote(promote != NULL) {

}

bool operator==(const Move &m) const = default;

Square source(void) const { return static_cast<Square>(source_i); }

Square target(void) const { return static_cast<Square>(target_i); }

bool is_double(void) const { return dbl; }

bool is_enpassant(void) const { return enpassant; }

bool is_castle(void) const { return castle; }

bool is_capture(void) const { return capture; }

bool is_promote(void) const { return promote; }

const piece::Piece &piece(void) const { return piece::get_from_index(piece_i); }

const piece::Piece &piece_capture(void) const { return piece::get_from_index(piece_capture_i); }

const piece::Piece &piece_promote(void) const { return piece::get_from_index(piece_promote_i); }

bool make(Board &board, bool attack_only) const;

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

private:

void piece_remove(Board &board, const piece::Piece &piece, Square square) const;

void piece_set(Board &board, const piece::Piece &piece, Square square) const;

void piece_move(Board &board, const piece::Piece &piece, Square source, Square target) const;

unsigned source_i : 6;

unsigned target_i : 6;

unsigned piece_i : 5;

unsigned piece_capture_i : 5;

unsigned piece_promote_i : 5;

bool dbl : 1;

bool enpassant : 1;

bool castle : 1;

bool capture : 1;

bool promote : 1;

};

#endif

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

@@ -0,0 +1,62 @@

#ifndef STELLAR_MOVE_LIST_H

#define STELLAR_MOVE_LIST_H

#include "board.hpp"

#include "move.hpp"

#include "utils_cpp.hpp"

#include <functional>

#include <iostream>

#include <vector>

class MoveList {

public:

typedef std::function<U32(const Move &)> score_f;

struct MoveListE {

Move move;

U32 score;

auto operator<=>(const MoveListE &mle) { return mle.score <=> score; }

};

private:

using list_t = std::vector<MoveListE>;

public:

MoveList(const Board &board, score_f score = nullptr) : list(), score_move(score) {

list.reserve(256);

generate(board);

sort(list.begin(), list.end());

}

auto size() const { return list.size(); }

MoveListE &operator[](size_t idx) { return list[idx]; }

const MoveListE &operator[](size_t idx) const { return list[idx]; }

friend std::ostream &operator<<(std::ostream &os, const MoveList &list);

using iterator = list_t::iterator;

using const_iterator = list_t::const_iterator;

iterator begin() { return list.begin(); }

iterator end() { return list.end(); }

const_iterator begin() const { return list.begin(); }

const_iterator end() const { return list.end(); }

const_iterator cbegin() const { return list.cbegin(); }

const_iterator cend() const { return list.cend(); }

private:

void push_back(const MoveListE &&mle) { list.push_back(mle); }

void push_back(const Move &&move) { push_back({move, score_move ? score_move(move) : 0}); }

void generate(const Board &board);

void clear() { list.clear(); }

list_t list;

score_f score_move;

};

#endif

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

@@ -1,49 +0,0 @@

#ifndef STELLAR_MOVES_H

#define STELLAR_MOVES_H

#include "board.hpp"

#include "piece.hpp"

#include <iostream>

#include <vector>

struct Move {

unsigned source : 6;

unsigned target : 6;

unsigned piece : 5;

unsigned piece_capture : 5;

unsigned piece_promote : 5;

bool dbl : 1;

bool enpassant : 1;

bool castle : 1;

bool capture : 1;

bool promote : 1;

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

};

struct MoveE {

Move move;

int score;

};

Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece, const piece::Piece *capture,

const piece::Piece *promote, bool dbl, bool enpassant, bool castle);

std::vector<MoveE> move_list_generate(const Board &board);

int move_make(Move move, Board &board, int flag);

void move_list_sort(std::vector<MoveE> &list);

int move_cmp(Move a, Move b);

#define move_source(move) (move.source)

#define move_target(move) (move.target)

#define move_double(move) (move.dbl)

#define move_enpassant(move) (move.enpassant)

#define move_castle(move) (move.castle)

#define move_capture(move) (move.capture)

#define move_promote(move) (move.promote)

#define move_piece(move) (piece::get_from_index(move.piece))

#define move_piece_capture(move) (piece::get_from_index(move.piece_capture))

#define move_piece_promote(move) (piece::get_from_index(move.piece_promote))

#endif

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

@@ -21,9 +21,7 @@ typedef Iterator<Type, Type::PAWN, Type::KING> TypeIter; class Piece { public:

constexpr U64 operator()(Square square, U64 occupancy) const {

return attack(square, occupancy);

}

constexpr U64 operator()(Square square, U64 occupancy) const { return attack(square, occupancy); }

const Type type; const Color color;

@@ -34,8 +32,7 @@ class Piece { protected: constexpr Piece(Type type, Color color, char code, const char *symbol, const attack::Attack &attack) : type(type), color(color), code(code), symbol(symbol), index(index_calc(color, type)),

attack(attack) {

}

attack(attack) {}

constexpr uint8_t index_calc(Color color, Type type) { return to_underlying(color) * 6 + to_underlying(type);

@@ -50,48 +47,42 @@ class Pawn : public Piece { constexpr Pawn(Color color) : Piece(Type::PAWN, color, color == Color::WHITE ? 'P' : 'p', color == Color::WHITE ? "■ " : "■ ", color == Color::WHITE ? *(attack::Attack *)&attack::pawnW

: *(attack::Attack *)&attack::pawnB) {

}

: *(attack::Attack *)&attack::pawnB) {}

}; class Knight : public Piece { public: constexpr Knight(Color color) : Piece(Type::KNIGHT, color, color == Color::WHITE ? 'N' : 'n', color == Color::WHITE ? "■ " : "■ ",

attack::knight) {

}

attack::knight) {}

}; class Bishop : public Piece { public: constexpr Bishop(Color color) : Piece(Type::BISHOP, color, color == Color::WHITE ? 'B' : 'b', color == Color::WHITE ? "■ " : "■ ",

attack::bishop) {

}

attack::bishop) {}

}; class Rook : public Piece { public: constexpr Rook(Color color) : Piece(Type::ROOK, color, color == Color::WHITE ? 'R' : 'r', color == Color::WHITE ? "■ " : "■ ",

attack::rook) {

}

attack::rook) {}

}; class Queen : public Piece { public: constexpr Queen(Color color) : Piece(Type::QUEEN, color, color == Color::WHITE ? 'Q' : 'q', color == Color::WHITE ? "■ " : "■ ",

attack::queen) {

}

attack::queen) {}

}; class King : public Piece { public: constexpr King(Color color) : Piece(Type::KING, color, color == Color::WHITE ? 'K' : 'k', color == Color::WHITE ? "■ " : "■ ",

attack::king) {

}

attack::king) {}

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

@@ -116,9 +107,7 @@ constexpr const Piece &get_from_code(char code) { throw std::exception(); }

constexpr const Piece &get_from_index(uint8_t index) {

return table[index / 6][index % 6];

}

constexpr const Piece &get_from_index(uint8_t index) { return table[index / 6][index % 6]; }

} // namespace piece

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

@@ -5,18 +5,12 @@ class Random { public:

constexpr Random(void) {

}

constexpr Random(U64 seed) : state(seed) {

}

constexpr Random(void) {}

constexpr Random(U64 seed) : state(seed) {}

constexpr U64 operator()(void) {

return get_U64();

}

constexpr U64 operator()(void) { return get_U64(); }

constexpr void reset(void) {

state = seed;

}

constexpr void reset(void) { state = seed; }

constexpr U32 get_U32(void) { U32 number = state;

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

@@ -14,28 +14,20 @@ template <typename C, C beginVal, C endVal> class Iterator { int val; public:

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

}

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

}

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 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;

}

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

}; #define C64(constantU64) constantU64##ULL

@@ -84,17 +76,11 @@ inline const char *square_to_coordinates(Square square) { // clang-format on // useful bit functions

constexpr bool bit_get(const U64 &bitboard, uint8_t square) {

return (bitboard >> (square)) & C64(1);

}

constexpr bool bit_get(const U64 &bitboard, uint8_t square) { return (bitboard >> (square)) & C64(1); }

constexpr void bit_set(U64 &bitboard, uint8_t square) {

bitboard |= (C64(1) << square);

}

constexpr void bit_set(U64 &bitboard, uint8_t square) { bitboard |= (C64(1) << square); }

constexpr void bit_pop(U64 &bitboard, uint8_t square) {

bitboard &= ~(C64(1) << (square));

}

constexpr void bit_pop(U64 &bitboard, uint8_t square) { bitboard &= ~(C64(1) << (square)); }

constexpr uint8_t bit_count(U64 bitboard) { #if __has_builtin(__builtin_popcountll)

@@ -127,30 +113,14 @@ inline constexpr const U64 notAFile = C64(0xfefefefefefefefe); inline constexpr const U64 notHFile = C64(0x7f7f7f7f7f7f7f7f); typedef U64 (*direction_f)(U64);

inline constexpr U64 soutOne(U64 b) {

return b >> 8;

}

inline constexpr U64 nortOne(U64 b) {

return b << 8;

}

inline constexpr U64 eastOne(U64 b) {

return (b & notHFile) << 1;

}

inline constexpr U64 westOne(U64 b) {

return (b & notAFile) >> 1;

}

inline constexpr U64 soEaOne(U64 b) {

return (b & notHFile) >> 7;

}

inline constexpr U64 soWeOne(U64 b) {

return (b & notAFile) >> 9;

}

inline constexpr U64 noEaOne(U64 b) {

return (b & notHFile) << 9;

}

inline constexpr U64 noWeOne(U64 b) {

return (b & notAFile) << 7;

}

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

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

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

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

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

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

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

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

#define start_position "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 "

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

@@ -13,17 +13,11 @@ class Zobrist { public: Zobrist() = delete;

static inline constexpr U64 key_side(void) {

return keys_side;

}

static inline constexpr U64 key_side(void) { return keys_side; }

static inline constexpr U64 key_castle(int exp) {

return keys_castle[exp];

}

static inline constexpr U64 key_castle(int exp) { return keys_castle[exp]; }

static inline constexpr U64 key_enpassant(Square square) {

return keys_enpassant[to_underlying(square)];

}

static inline constexpr U64 key_enpassant(Square square) { return keys_enpassant[to_underlying(square)]; }

static inline constexpr U64 key_piece(const piece::Piece &piece, Square square) { return keys_piece[piece.index][to_underlying(square)];

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

@@ -0,0 +1,8 @@

add_library(moves OBJECT

move.cpp

movelist.cpp

)

target_include_directories(moves

PUBLIC "${PROJECT_SOURCE_DIR}/src/include"

)

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

@@ -0,0 +1,105 @@

#include "move.hpp"

#include "utils_cpp.hpp"

#include "zobrist.hpp"

#include <algorithm>

#include <iomanip>

void Move::piece_remove(Board &board, const piece::Piece &piece, Square square) const {

board.pop_piece(piece, square);

board.xor_hash(Zobrist::key_piece(piece, square));

}

void Move::piece_set(Board &board, const piece::Piece &piece, Square square) const {

board.set_piece(piece, square);

board.xor_hash(Zobrist::key_piece(piece, square));

}

void Move::piece_move(Board &board, const piece::Piece &piece, Square source, Square target) const {

piece_remove(board, piece, source);

piece_set(board, piece, target);

}

bool Move::make(Board &board, bool attack_only) const {

static constexpr const int castling_rights[64] = {

// clang-format off

13, 15, 15, 15, 12, 15, 15, 14,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

7, 15, 15, 15, 3, 15, 15, 11,

// clang-format on

};

if (attack_only) {

if (is_capture()) return make(board, false);

return 0;

} else {

const piece::Piece &piece = this->piece();

const Color color = board.get_side();

const Square source = this->source();

const Square target = this->target();

const Square ntarget =

static_cast<Square>(to_underlying(this->target()) + (color == Color::WHITE ? -8 : +8));

if (!is_capture()) {

if (is_promote()) {

piece_remove(board, piece, source);

piece_set(board, piece_promote(), target);

} else {

piece_move(board, piece, source, target);

}

} else {

if (is_enpassant()) {

piece_move(board, piece, source, target);

piece_remove(board, piece_capture(), ntarget);

} else if (is_promote()) {

piece_remove(board, piece, source);

piece_remove(board, piece_capture(), target);

piece_set(board, piece_promote(), target);

} else {

piece_remove(board, piece_capture(), target);

piece_move(board, piece, source, target);

}

}

board.set_enpassant(is_double() ? ntarget : Square::no_sq);

if (is_castle()) {

static constexpr const piece::Piece &rook_white = piece::get(piece::Type::ROOK, Color::WHITE);

static constexpr const piece::Piece &rook_black = piece::get(piece::Type::ROOK, Color::BLACK);

if (target == Square::g1) piece_move(board, rook_white, Square::h1, Square::f1);

if (target == Square::c1) piece_move(board, rook_white, Square::a1, Square::d1);

if (target == Square::g8) piece_move(board, rook_black, Square::h8, Square::f8);

if (target == Square::c8) piece_move(board, rook_black, Square::a8, Square::d8);

}

board.xor_hash(Zobrist::key_castle(board.get_castle()));

board.and_castle(castling_rights[to_underlying(this->source())]);

board.and_castle(castling_rights[to_underlying(this->target())]);

board.xor_hash(Zobrist::key_castle(board.get_castle()));

if (!board.is_check()) {

board.switch_side();

return 1;

}

return 0;

}

}

std::ostream &operator<<(std::ostream &os, const Move &move) {

os << square_to_coordinates(move.source()) << " ";

os << square_to_coordinates(move.target()) << " ";

os << move.piece().code << " ";

os << (move.is_capture() ? move.piece_capture().code : '.') << " ";

os << (move.is_promote() ? move.piece_promote().code : '.') << " ";

os << move.is_double() << " ";

os << move.is_enpassant() << " ";

os << move.is_castle();

return os;

}

diff --git a/ src/move/movelist.cpp b/ src/move/movelist.cpp

@@ -0,0 +1,120 @@

#include "movelist.hpp"

#define pawn_canPromote(color, source) \

((color == Color::WHITE && source >= Square::a7 && source <= Square::h7) || \

(color == Color::BLACK && source >= Square::a2 && source <= Square::h2))

#define pawn_onStart(color, source) \

((color == Color::BLACK && source >= Square::a7 && source <= Square::h7) || \

(color == Color::WHITE && source >= Square::a2 && source <= Square::h2))

void MoveList::generate(const Board &board) {

this->clear();

uint8_t src_i, tgt_i;

Color color = board.get_side();

Color colorOther = color == Color::BLACK ? Color::WHITE : Color::BLACK;

// pawn moves

const piece::Piece &pawn = piece::get(piece::Type::PAWN, color);

const int add = (color == Color::WHITE) ? +8 : -8;

U64 bitboard = board.get_bitboard_piece(pawn);

bitboard_for_each_bit(src_i, bitboard) {

const Square src = static_cast<Square>(src_i);

const Square tgt = static_cast<Square>(tgt_i = src_i + add);

if (!board.is_square_occupied(tgt)) {

if (pawn_canPromote(color, src)) {

push_back(Move(src, tgt, &pawn, nullptr, &piece::get(piece::Type::KNIGHT, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, nullptr, &piece::get(piece::Type::BISHOP, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, nullptr, &piece::get(piece::Type::ROOK, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, nullptr, &piece::get(piece::Type::QUEEN, color), 0, 0, 0));

} else {

push_back(Move(src, tgt, &pawn, 0, 0, 0, 0, 0));

// two ahead

const Square tgt = static_cast<Square>(tgt_i + add);

if (pawn_onStart(color, src) && !board.is_square_occupied(tgt))

push_back(Move(src, tgt, &pawn, 0, 0, 1, 0, 0));

}

}

// capture

U64 attack = board.get_bitboard_piece_attacks(pawn, src) & board.get_bitboard_color(colorOther);

bitboard_for_each_bit(tgt_i, attack) {

const Square tgt = static_cast<Square>(tgt_i);

const piece::Piece *capture = board.get_square_piece(tgt);

if (pawn_canPromote(color, src)) {

push_back(Move(src, tgt, &pawn, capture, &piece::get(piece::Type::KNIGHT, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, capture, &piece::get(piece::Type::BISHOP, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, capture, &piece::get(piece::Type::ROOK, color), 0, 0, 0));

push_back(Move(src, tgt, &pawn, capture, &piece::get(piece::Type::QUEEN, color), 0, 0, 0));

} else {

push_back(Move(src, tgt, &pawn, capture, 0, 0, 0, 0));

}

}

// en passant

const Square enpassant = board.get_enpassant();

if (enpassant != Square::no_sq && board.is_piece_attack_square(pawn, src, enpassant))

push_back(Move(src, enpassant, &pawn, &piece::get(piece::Type::PAWN, colorOther), 0, 0, 1, 0));

}

// All piece move

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

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

U64 bitboard = board.get_bitboard_piece(piece);

bitboard_for_each_bit(src_i, bitboard) {

const Square src = static_cast<Square>(src_i);

U64 attack = board.get_bitboard_piece_moves(piece, src);

bitboard_for_each_bit(tgt_i, attack) {

const Square tgt = static_cast<Square>(tgt_i);

push_back(Move(src, tgt, &piece, board.get_square_piece(tgt), 0, 0, 0, 0));

}

}

}

// Castling

if (color == Color::WHITE) {

static const piece::Piece &piece = piece::get(piece::Type::KING, Color::WHITE);

if (!board.is_square_attacked(Square::e1, Color::BLACK)) {

if (board.get_castle() & to_underlying(Board::Castle::WK)) {

if (!board.is_square_occupied(Square::f1) && !board.is_square_occupied(Square::g1) &&

!board.is_square_attacked(Square::f1, Color::BLACK))

push_back(Move(Square::e1, Square::g1, &piece, 0, 0, 0, 0, 1));

}

if (board.get_castle() & to_underlying(Board::Castle::WQ)) {

if (!board.is_square_occupied(Square::d1) && !board.is_square_occupied(Square::c1) &&

!board.is_square_occupied(Square::b1) &&

!board.is_square_attacked(Square::d1, Color::BLACK) &&

!board.is_square_attacked(Square::c1, Color::BLACK))

push_back(Move(Square::e1, Square::c1, &piece, 0, 0, 0, 0, 1));

}

}

} else {

static const piece::Piece &piece = piece::get(piece::Type::KING, Color::BLACK);

if (!board.is_square_attacked(Square::e8, Color::WHITE)) {

if (board.get_castle() & to_underlying(Board::Castle::BK)) {

if (!board.is_square_occupied(Square::f8) && !board.is_square_occupied(Square::g8) &&

!board.is_square_attacked(Square::f8, Color::WHITE))

push_back(Move(Square::e8, Square::g8, &piece, 0, 0, 0, 0, 1));

}

if (board.get_castle() & to_underlying(Board::Castle::BQ)) {

if (!board.is_square_occupied(Square::d8) && !board.is_square_occupied(Square::c8) &&

!board.is_square_occupied(Square::b8) &&

!board.is_square_attacked(Square::d8, Color::WHITE) &&

!board.is_square_attacked(Square::c8, Color::WHITE))

push_back(Move(Square::e8, Square::c8, &piece, 0, 0, 0, 0, 1));

}

}

}

}

std::ostream &operator<<(std::ostream &os, const MoveList &list) {

os << "Size: " << list.list.size();

for (const auto &moveE : list.list) {

os << moveE.score << ": " << moveE.move << "\n";

}

return os;

}

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

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

add_library(moves OBJECT

moves.cpp

moves_make.cpp

moves_generate.cpp

)

target_include_directories(moves

PUBLIC "${PROJECT_SOURCE_DIR}/src/include"

)

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

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

#include "moves.hpp"

#include "utils_cpp.hpp"

#include <algorithm>

#include <iomanip>

int move_cmp(Move a, Move b) {

return *(uint32_t *)&a == *(uint32_t *)&b;

}

Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece, const piece::Piece *capture,

const piece::Piece *promote, bool dbl, bool enpassant, bool castle) {

return {

.source = src,

.target = tgt,

.piece = piece->index,

.piece_capture = capture ? capture->index : 0u,

.piece_promote = promote ? promote->index : 0u,

.dbl = dbl,

.enpassant = enpassant,

.castle = castle,

.capture = capture != NULL,

.promote = promote != NULL,

};

}

void move_list_sort(std::vector<MoveE> &list) {

std::sort(list.begin(), list.end(), [](const MoveE &a, const MoveE &b) { return a.score < b.score; });

}

void move_list_print(const std::vector<MoveE> &list) {

printf("Score From To Pi Cap Prmt Dbl Enp Cst C P\n");

for (const MoveE &move : list) {

printf("%5d: ", move.score);

// move_print(move.move);

}

printf("Total: %lu\n", list.size());

}

std::ostream &operator<<(std::ostream &os, const Move &move) {

os << square_to_coordinates(static_cast<Square>(move_source(move))) << " ";

os << square_to_coordinates(static_cast<Square>(move_target(move))) << " ";

os << move_piece(move).code << " ";

os << (move_capture(move) ? move_piece_capture(move).code : '.') << " ";

os << (move_promote(move) ? move_piece_promote(move).code : '.') << " ";

os << move_double(move) << " ";

os << move_enpassant(move) << " ";

os << move_castle(move);

return os;

}

diff --git a/ src/moves/moves_generate.cpp b/ src/moves/moves_generate.cpp

@@ -1,137 +0,0 @@

#include "board.hpp"

#include "moves.hpp"

#include "piece.hpp"

#include "utils_cpp.hpp"

#define pawn_canPromote(color, source) \

((color == Color::WHITE && source >= Square::a7 && source <= Square::h7) || \

(color == Color::BLACK && source >= Square::a2 && source <= Square::h2))

#define pawn_onStart(color, source) \

((color == Color::BLACK && source >= Square::a7 && source <= Square::h7) || \

(color == Color::WHITE && source >= Square::a2 && source <= Square::h2))

#define pawn_promote(source, target, piece, capture) \

res.push_back( \

{move_encode(source, target, &piece, capture, &piece::get(piece::Type::KNIGHT, color), 0, 0, 0), \

0}); \

res.push_back( \

{move_encode(source, target, &piece, capture, &piece::get(piece::Type::BISHOP, color), 0, 0, 0), \

0}); \

res.push_back( \

{move_encode(source, target, &piece, capture, &piece::get(piece::Type::ROOK, color), 0, 0, 0), 0}); \

res.push_back( \

{move_encode(source, target, &piece, capture, &piece::get(piece::Type::QUEEN, color), 0, 0, 0), 0});

std::vector<MoveE> move_list_generate(const Board &board) {

uint8_t src_i, tgt_i;

Color color = board.get_side();

Color colorOther = color == Color::BLACK ? Color::WHITE : Color::BLACK;

std::vector<MoveE> res;

res.reserve(256);

// pawn moves

const piece::Piece &piece = piece::get(piece::Type::PAWN, color);

U64 bitboard = board.get_bitboard_piece(piece);

bitboard_for_each_bit(src_i, bitboard) {

// quiet

int add = (color == Color::WHITE) ? +8 : -8;

tgt_i = src_i + add;

Square src = static_cast<Square>(src_i);

Square tgt = static_cast<Square>(tgt_i);

if (!board.is_square_occupied(tgt)) {

if (pawn_canPromote(color, src)) {

pawn_promote(src_i, tgt_i, piece, nullptr);

} else {

res.push_back({move_encode(src_i, tgt_i, &piece, 0, 0, 0, 0, 0), 0});

// two ahead

Square tgt = static_cast<Square>(tgt_i + add);

if (pawn_onStart(color, src) && !board.is_square_occupied(tgt))

res.push_back({move_encode(src_i, tgt_i + add, &piece, 0, 0, 1, 0, 0), 0});

}

}

// capture

U64 attack = board.get_bitboard_piece_attacks(piece, src) & board.get_bitboard_color(colorOther);

bitboard_for_each_bit(tgt_i, attack) {

Square tgt = static_cast<Square>(tgt_i);

const piece::Piece *capture = board.get_square_piece(tgt);

if (pawn_canPromote(color, src)) {

pawn_promote(src_i, tgt_i, piece, capture);

} else {

res.push_back({move_encode(src_i, tgt_i, &piece, capture, 0, 0, 0, 0), 0});

}

}

// en passant

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

board.get_bitboard_piece_attacks(piece, static_cast<Square>(src_i)) &

(C64(1) << to_underlying(board.get_enpassant())))

res.push_back({move_encode(src_i, to_underlying(board.get_enpassant()), &piece,

&piece::get(piece::Type::PAWN, colorOther), 0, 0, 1, 0),

0});

}

// All piece move

auto type_it = piece::TypeIter().begin();

for (++type_it; type_it != type_it.end(); ++type_it) {

const piece::Piece &piece = piece::get(*type_it, color);

U64 bitboard = board.get_bitboard_piece(piece);

bitboard_for_each_bit(src_i, bitboard) {

Square src = static_cast<Square>(src_i);

U64 attack = board.get_bitboard_piece_attacks(piece, src) & ~board.get_bitboard_color(color);

bitboard_for_each_bit(tgt_i, attack) {

Square tgt = static_cast<Square>(tgt_i);

res.push_back(

{move_encode(src_i, tgt_i, &piece, board.get_square_piece(tgt), 0, 0, 0, 0), 0});

}

}

}

// Castling

if (color == Color::WHITE) {

static const piece::Piece &piece = piece::get(piece::Type::KING, Color::WHITE);

if (board.get_castle() & to_underlying(Board::Castle::WK)) {

if (!board.is_square_occupied(Square::f1) && !board.is_square_occupied(Square::g1) &&

!board.is_square_attacked(Square::e1, Color::BLACK) &&

!board.is_square_attacked(Square::f1, Color::BLACK))

res.push_back(

{move_encode(to_underlying(Square::e1), to_underlying(Square::g1), &piece, 0, 0, 0, 0, 1),

0});

}

if (board.get_castle() & to_underlying(Board::Castle::WQ)) {

if (!board.is_square_occupied(Square::d1) && !board.is_square_occupied(Square::c1) &&

!board.is_square_occupied(Square::b1) &&

!board.is_square_attacked(Square::e1, Color::BLACK) &&

!board.is_square_attacked(Square::d1, Color::BLACK))

res.push_back(

{move_encode(to_underlying(Square::e1), to_underlying(Square::c1), &piece, 0, 0, 0, 0, 1),

0});

}

} else {

static const piece::Piece &piece = piece::get(piece::Type::KING, Color::BLACK);

if (board.get_castle() & to_underlying(Board::Castle::BK)) {

if (!board.is_square_occupied(Square::f8) && !board.is_square_occupied(Square::g8) &&

!board.is_square_attacked(Square::e8, Color::WHITE) &&

!board.is_square_attacked(Square::f8, Color::WHITE))

res.push_back(

{move_encode(to_underlying(Square::e8), to_underlying(Square::g8), &piece, 0, 0, 0, 0, 1),

0});

}

if (board.get_castle() & to_underlying(Board::Castle::BQ)) {

if (!board.is_square_occupied(Square::d8) && !board.is_square_occupied(Square::c8) &&

!board.is_square_occupied(Square::b8) &&

!board.is_square_attacked(Square::e8, Color::WHITE) &&

!board.is_square_attacked(Square::d8, Color::WHITE))

res.push_back(

{move_encode(to_underlying(Square::e8), to_underlying(Square::c8), &piece, 0, 0, 0, 0, 1),

0});

}

}

res.resize(res.size());

return res;

}

diff --git a/ src/moves/moves_make.cpp b/ src/moves/moves_make.cpp

@@ -1,88 +0,0 @@

#include "board.hpp"

#include "moves.hpp"

#include "zobrist.hpp"

// clang-format off

const int castling_rights[64] = {

13, 15, 15, 15, 12, 15, 15, 14,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15,

7, 15, 15, 15, 3, 15, 15, 11,

};

// clang-format on

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

board.pop_piece(piece, square);

board.xor_hash(Zobrist::key_piece(piece, square));

}

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

board.set_piece(piece, square);

board.xor_hash(Zobrist::key_piece(piece, square));

}

void _piece_move(Board &board, const piece::Piece &piece, Square source, Square target) {

_piece_remove(board, piece, source);

_piece_set(board, piece, target);

}

int move_make(Move move, Board &board, int flag) {

if (flag) {

if (move_capture(move)) return move_make(move, board, 0);

return 0;

} else {

const piece::Piece &piece = move_piece(move);

const Color color = board.get_side();

const Square source = static_cast<Square>(move_source(move));

const Square target = static_cast<Square>(move_target(move));

const Square ntarget = static_cast<Square>(move_target(move) + (color == Color::WHITE ? -8 : +8));

if (!move_capture(move)) {

if (move_promote(move)) {

_piece_remove(board, piece, source);

_piece_set(board, move_piece_promote(move), target);

} else {

_piece_move(board, piece, source, target);

}

} else {

if (move_enpassant(move)) {

_piece_move(board, piece, source, target);

_piece_remove(board, move_piece_capture(move), ntarget);

} else if (move_promote(move)) {

_piece_remove(board, piece, source);

_piece_remove(board, move_piece_capture(move), target);

_piece_set(board, move_piece_promote(move), target);

} else {

_piece_remove(board, piece, source);

_piece_remove(board, move_piece_capture(move), target);

_piece_set(board, piece, target);

}

}

board.set_enpassant(move_double(move) ? ntarget : Square::no_sq);

if (move_castle(move)) {

static constexpr const piece::Piece &rook_white = piece::get(piece::Type::ROOK, Color::WHITE);

static constexpr const piece::Piece &rook_black = piece::get(piece::Type::ROOK, Color::BLACK);

if (target == Square::g1) _piece_move(board, rook_white, Square::h1, Square::f1);

if (target == Square::c1) _piece_move(board, rook_white, Square::a1, Square::d1);

if (target == Square::g8) _piece_move(board, rook_black, Square::h8, Square::f8);

if (target == Square::c8) _piece_move(board, rook_black, Square::a8, Square::d8);

}

board.xor_hash(Zobrist::key_castle(board.get_castle()));

board.and_castle(castling_rights[move_source(move)]);

board.and_castle(castling_rights[move_target(move)]);

board.xor_hash(Zobrist::key_castle(board.get_castle()));

if (!board.is_check()) {

board.switch_side();

return 1;

}

return 0;

}

}

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

@@ -7,7 +7,8 @@ #include "attack.hpp" #include "board.hpp"

#include "moves.hpp"

#include "move.hpp"

#include "movelist.hpp"

#include "perft.hpp" #include "utils_cpp.hpp" #include "zobrist.hpp"

@@ -46,15 +47,11 @@ void perft_result_add(PerftResult *base, PerftResult *add) { #endif }

typedef std::vector<MoveE> MoveList;

void perft_driver(Board &board, int depth, PerftResult *result) {

MoveList moveList = move_list_generate(board);

Board copy;

for (const auto [move, _] : moveList) {

for (const auto [move, _] : MoveList(board)) {

copy = board;

if (!move_make(move, copy, 0)) continue;

if (!move.make(copy, 0)) continue;

if (depth != 1) { perft_driver(copy, depth - 1, result);

@@ -62,10 +59,10 @@ void perft_driver(Board &board, int depth, PerftResult *result) { result->node++; #ifdef USE_FULL_COUNT if (copy.is_check()) result->check++;

if (move_capture(move)) result->capture++;

if (move_enpassant(move)) result->enpassant++;

if (move_castle(move)) result->castle++;

if (move_promote(move)) result->promote++;

if (move.get_capture()) result->capture++;

if (move.get_enpassant()) result->enpassant++;

if (move.get_castle()) result->castle++;

if (move.get_promote()) result->promote++;

#endif } }

@@ -73,7 +70,7 @@ void perft_driver(Board &board, int depth, PerftResult *result) { typedef struct perf_shared perf_shared; struct perf_shared {

MoveList list;

const MoveList &list;

int depth; const char *fen; pthread_mutex_t mutex;

@@ -99,7 +96,7 @@ void *perft_thread(void *arg) { result = {0}; copy = board;

if (!move_make(move, copy, 0)) continue;

if (!move.make(copy, 0)) continue;

if (shared->depth != 1) { perft_driver(copy, shared->depth - 1, &result);

@@ -107,10 +104,10 @@ void *perft_thread(void *arg) { result.node++; #ifdef USE_FULL_COUNT if (copy.is_check()) result.check++;

if (move_capture(move)) result.capture++;

if (move_enpassant(move)) result.enpassant++;

if (move_castle(move)) result.castle++;

if (move_promote(move)) result.promote++;

if (move.get_capture()) result.capture++;

if (move.get_enpassant()) result.enpassant++;

if (move.get_castle()) result.castle++;

if (move.get_promote()) result.promote++;

#endif } }

@@ -119,8 +116,10 @@ void *perft_thread(void *arg) { PerftResult perft_test(const char *fen, int depth, int thread_num) { pthread_t *threads = new pthread_t(thread_num);

MoveList *list = new MoveList(Board(fen));

perf_shared shared = {

.list = move_list_generate(Board(fen)),

.list = *list,

.depth = depth, .fen = fen, };

@@ -132,6 +131,7 @@ PerftResult perft_test(const char *fen, int depth, int thread_num) { for (int i = 0; i < thread_num; i++) pthread_join(threads[i], NULL);

delete list;

delete threads; return shared.result; }