stellar

Fix performance issue, slight problem with engine...

9 files changed, 143 insertions(+), 150 deletions(-)

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

@@ -23,28 +23,16 @@ U64 Board::get_bitboard_occupancy(void) const { 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(square, get_bitboard_occupancy());

U64 Board::get_bitboard_piece_attacks(piece::Type type, Color color, Square from) const {

return piece::get_attack(type, color, from, 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);

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

return get_bitboard_piece_attacks(type, color, square) & ~get_bitboard_color(color);

} Color Board::get_square_piece_color(Square square) const {

@@ -57,7 +45,7 @@ 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();

return piece::Type::NONE;

} const piece::Piece *Board::get_square_piece(Square square) const {

@@ -93,22 +81,22 @@ 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::pop_bitboard_piece(piece::Type type, Square square) {

bit_pop(pieces[to_underlying(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::set_bitboard_piece(piece::Type type, Square square) {

bit_set(pieces[to_underlying(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::pop_piece(piece::Type type, Color side, Square square) {

pop_bitboard_color(side, square);

pop_bitboard_piece(type, square);

}

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

set_bitboard_color(piece.color, square);

set_bitboard_piece(piece, square);

void Board::set_piece(piece::Type type, Color side, Square square) {

set_bitboard_color(side, square);

set_bitboard_piece(type, square);

} /* Queries */

@@ -121,16 +109,16 @@ bool Board::is_square_attacked(Square square, Color side) const { Color side_other = (side == Color::BLACK) ? Color::WHITE : Color::BLACK; for (piece::Type type : piece::TypeIter()) {

if (get_bitboard_piece_attacks(piece::get(type, side_other), square) &

get_bitboard_piece(piece::get(type, side)))

if (get_bitboard_piece_attacks(type, side_other, square) & get_bitboard_piece(type, side)) {

return 1;

}

} 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_piece_attack_square(piece::Type type, Color color, Square source, Square target) const {

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

} bool Board::is_check(void) const {

@@ -144,7 +132,8 @@ Board::Board(const std::string &fen) { int file = 0, rank = 7, i; for (i = 0; fen[i] != ' '; i++) { if (isalpha(fen[i])) {

set_piece(piece::get_from_code(fen[i]), static_cast<Square>(rank * 8 + file));

const piece::Piece &piece = piece::get_from_code(fen[i]);

set_piece(piece.type, piece.color, static_cast<Square>(rank * 8 + file));

file++; } else if (isdigit(fen[i])) { file += fen[i] - '0';

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

@@ -23,7 +23,7 @@ Board board; TTable ttable(C64(0x400000)); Move pv_table[MAX_PLY][MAX_PLY]; Move killer[2][MAX_PLY];

U32 history[16][64];

U32 history[12][64];

int pv_length[MAX_PLY]; bool follow_pv; U64 nodes;

@@ -31,8 +31,8 @@ U32 ply; Move move_list_best_move; U32 inline move_list_score(Move move) {

const piece::Type type = move.piece().type;

if (move.is_capture()) return piece::score(type, move.piece_capture().type) + 10000;

const piece::Type type = move.piece();

if (move.is_capture()) return piece::score(type, move.captured()) + 10000;

if (killer[0][ply] == move) return 9000; if (killer[1][ply] == move) return 8000; return history[to_underlying(type)][to_underlying(move.target())];

@@ -268,7 +268,8 @@ int negamax(int alpha, int beta, int depth, bool null) { if (score > alpha) { if (!move.is_capture()) {

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

int index = piece::get(move.piece(), board.get_side()).index;

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

} alpha = score;

@@ -302,7 +303,7 @@ int negamax(int alpha, int beta, int depth, bool null) { void move_print_UCI(Move move) { std::cout << square_to_coordinates(move.source()) << square_to_coordinates(move.target());

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

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

} void search_position(int depth) {

@@ -413,7 +414,8 @@ Move parse_move(char *move_string) { const Move move = list[i]; if (move.source() == source && move.target() == target) { if (move_string[4]) {

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

char code = piece::get(move.promoted(), board.get_side()).code;

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

} return move; }

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

@@ -33,12 +33,9 @@ class Board { 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;

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;

U64 get_bitboard_piece_attacks(piece::Type piece, Color color, Square from) const;

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

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

@@ -54,17 +51,17 @@ class Board { 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_bitboard_piece(piece::Type type, Square square);

void set_bitboard_piece(piece::Type type, Square square);

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

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

void pop_piece(piece::Type type, Color side, Square square);

void set_piece(piece::Type type, Color side, Square square);

/* Queries */ 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_piece_attack_square(piece::Type type, Color color, Square source, Square target) const;

bool is_check(void) const; private:

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

@@ -11,12 +11,11 @@ struct Move { Move() = default;

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) {

}

Move(Square source, Square target, piece::Type piece, piece::Type capture, piece::Type promote, bool dbl,

bool enpassant, bool castle)

: source_i(to_underlying(source)), target_i(to_underlying(target)), piece_i(to_underlying(piece)),

capture_i(to_underlying(capture)), promote_i(to_underlying(promote)), dbl(dbl),

enpassant(enpassant), castle(castle) {}

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

@@ -26,32 +25,30 @@ struct Move { 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; }

bool is_capture(void) const { return capture_i != to_underlying(piece::Type::NONE); }

bool is_promote(void) const { return promote_i != to_underlying(piece::Type::NONE); }

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

const piece::Type piece(void) const { return static_cast<piece::Type>(piece_i); }

const piece::Type captured(void) const { return static_cast<piece::Type>(capture_i); }

const piece::Type promoted(void) const { return static_cast<piece::Type>(promote_i); }

bool make(Board &board, bool attack_only) const; friend std::ostream &operator<<(std::ostream &os, Move move); private:

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

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

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

inline void piece_remove(Board &board, piece::Type type, Color color, Square square) const;

inline void piece_set(Board &board, piece::Type type, Color color, Square square) const;

inline void piece_move(Board &board, piece::Type type, Color color, 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;

unsigned piece_i : 3;

unsigned capture_i : 3;

unsigned promote_i : 3;

bool dbl : 1; bool enpassant : 1; bool castle : 1;

bool capture : 1;

bool promote : 1;

}; #endif

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

@@ -15,7 +15,7 @@ enum class Type { ROOK, QUEEN, KING,

TypeSIZE

NONE = 7,

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

@@ -96,6 +96,12 @@ constexpr const Piece &get(Type type, Color color) { return table[static_cast<int>(color)][static_cast<int>(type)]; }

constexpr const U64 get_attack(Type type, Color color, Square from, U64 occupancy) {

return get(type, color)(from, occupancy);

}

constexpr const char get_code(Type type, Color color = Color::WHITE) { return get(type, color).code; }

constexpr const U64 get_index(Type type, Color color) { return get(type, color).index; }

constexpr const Piece &get_from_code(char code) { Color color = isupper(code) ? Color::WHITE : Color::BLACK;

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

@@ -16,8 +16,8 @@ class Zobrist { 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_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)];

static inline constexpr U64 key_piece(piece::Type type, Color color, Square square) {

return keys_piece[piece::get_index(type, color)][to_underlying(square)];

} static inline U64 hash(const Board &board) {

@@ -25,18 +25,14 @@ class Zobrist { 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);

int piece_white_index = piece::get_index(type, Color::WHITE);

U64 bitboard_white = board.get_bitboard_piece(type, Color::WHITE);

bitboard_for_each_bit(square, bitboard_white) { key_final ^= keys_piece[piece_white_index][square]; }

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

int piece_black_index = piece_black.index;

U64 bitboard_black = board.get_bitboard_piece(piece_black);

int piece_black_index = piece::get_index(type, Color::BLACK);

U64 bitboard_black = board.get_bitboard_piece(type, Color::BLACK);

bitboard_for_each_bit(square, bitboard_black) { key_final ^= keys_piece[piece_black_index][square]; }

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

@@ -5,21 +5,23 @@ #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_remove(Board &board, piece::Type type, Color color, Square square) const {

board.pop_piece(type, color, square);

board.xor_hash(Zobrist::key_piece(type, color, 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_set(Board &board, piece::Type type, Color color, Square square) const {

board.set_piece(type, color, square);

board.xor_hash(Zobrist::key_piece(type, color, 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);

void Move::piece_move(Board &board, piece::Type type, Color color, Square source, Square target) const {

piece_remove(board, type, color, source);

piece_set(board, type, color, target);

}

using piece::Type::ROOK;

bool Move::make(Board &board, bool attack_only) const { static constexpr const int castling_rights[64] = { // clang-format off

@@ -38,8 +40,8 @@ bool Move::make(Board &board, bool attack_only) const { if (is_capture()) return make(board, false); return 0; } else {

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

const Color color = board.get_side();

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

const Square source = this->source(); const Square target = this->target();

@@ -48,34 +50,32 @@ bool Move::make(Board &board, bool attack_only) const { if (!is_capture()) { if (is_promote()) {

piece_remove(board, piece, source);

piece_set(board, piece_promote(), target);

piece_remove(board, piece(), color, source);

piece_set(board, promoted(), color, target);

} else {

piece_move(board, piece, source, target);

piece_move(board, piece(), color, source, target);

} } else { if (is_enpassant()) {

piece_move(board, piece, source, target);

piece_remove(board, piece_capture(), ntarget);

piece_move(board, piece(), color, source, target);

piece_remove(board, captured(), colorOther, ntarget);

} else if (is_promote()) {

piece_remove(board, piece, source);

piece_remove(board, piece_capture(), target);

piece_set(board, piece_promote(), target);

piece_remove(board, piece(), color, source);

piece_remove(board, captured(), colorOther, target);

piece_set(board, promoted(), color, target);

} else {

piece_remove(board, piece_capture(), target);

piece_move(board, piece, source, target);

piece_remove(board, captured(), colorOther, target);

piece_move(board, piece(), color, 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);

if (target == Square::g1) piece_move(board, ROOK, Color::WHITE, Square::h1, Square::f1);

if (target == Square::c1) piece_move(board, ROOK, Color::WHITE, Square::a1, Square::d1);

if (target == Square::g8) piece_move(board, ROOK, Color::BLACK, Square::h8, Square::f8);

if (target == Square::c8) piece_move(board, ROOK, Color::BLACK, Square::a8, Square::d8);

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

@@ -94,9 +94,9 @@ bool Move::make(Board &board, bool attack_only) const { std::ostream &operator<<(std::ostream &os, 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 << piece::get_code(move.piece()) << " ";

os << (move.is_capture() ? piece::get_code(move.captured()) : '.') << " ";

os << (move.is_promote() ? piece::get_code(move.promoted()) : '.') << " ";

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

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

@@ -1,4 +1,5 @@ #include "movelist.hpp"

#include "piece.hpp"

#include <iomanip> #define pawn_canPromote(color, source) \

@@ -9,6 +10,14 @@ ((color == Color::BLACK && source >= Square::a7 && source <= Square::h7) || \ (color == Color::WHITE && source >= Square::a2 && source <= Square::h2))

using piece::Type::BISHOP;

using piece::Type::KING;

using piece::Type::KNIGHT;

using piece::Type::NONE;

using piece::Type::PAWN;

using piece::Type::QUEEN;

using piece::Type::ROOK;

void MoveList::generate(const Board &board) { this->clear();

@@ -18,104 +27,92 @@ void MoveList::generate(const Board &board) { 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);

U64 bitboard = board.get_bitboard_piece(PAWN, color);

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)) {

list.push_back(

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

list.push_back(

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

list.push_back(

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

list.push_back(

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

list.push_back(Move(src, tgt, PAWN, NONE, KNIGHT, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, NONE, BISHOP, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, NONE, ROOK, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, NONE, QUEEN, 0, 0, 0));

} else {

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

list.push_back(Move(src, tgt, PAWN, NONE, NONE, 0, 0, 0));

// two ahead const Square tgt = static_cast<Square>(tgt_i + add); if (pawn_onStart(color, src) && !board.is_square_occupied(tgt))

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

list.push_back(Move(src, tgt, PAWN, NONE, NONE, 1, 0, 0));

} } // capture

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

U64 attack =

board.get_bitboard_piece_attacks(PAWN, color, 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);

const piece::Type capture = board.get_square_piece_type(tgt);

if (pawn_canPromote(color, src)) {

list.push_back(

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

list.push_back(

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

list.push_back(

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

list.push_back(

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

list.push_back(Move(src, tgt, PAWN, capture, KNIGHT, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, capture, BISHOP, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, capture, ROOK, 0, 0, 0));

list.push_back(Move(src, tgt, PAWN, capture, QUEEN, 0, 0, 0));

} else {

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

list.push_back(Move(src, tgt, PAWN, capture, NONE, 0, 0, 0));

} } // en passant const Square enpassant = board.get_enpassant();

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

list.push_back(

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

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

list.push_back(Move(src, enpassant, PAWN, PAWN, NONE, 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);

U64 bitboard = board.get_bitboard_piece(type, color);

bitboard_for_each_bit(src_i, bitboard) { const Square src = static_cast<Square>(src_i);

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

U64 attack = board.get_bitboard_piece_moves(type, color, src);

bitboard_for_each_bit(tgt_i, attack) { const Square tgt = static_cast<Square>(tgt_i);

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

list.push_back(Move(src, tgt, type, board.get_square_piece_type(tgt), NONE, 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))

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

list.push_back(Move(Square::e1, Square::g1, KING, NONE, NONE, 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))

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

list.push_back(Move(Square::e1, Square::c1, KING, NONE, NONE, 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))

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

list.push_back(Move(Square::e8, Square::g8, KING, NONE, NONE, 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))

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

list.push_back(Move(Square::e8, Square::c8, KING, NONE, NONE, 0, 0, 1));

} } }

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

@@ -17,14 +17,16 @@ class Perft { typedef std::counting_semaphore<THREAD_MAX> semaphore_t; Perft(semaphore_t &sem) : sem(sem) {} void operator()(const Board &board_start, Move move, int depth) {

sem.acquire();

Board board = board_start;

if (move.make(board, 0)) {

if (depth > 1)

test(board, depth - 1);

else

score(board, move);

if (!move.make(board, 0)) return;

sem.acquire();

if (depth > 1) {

test(board, depth - 1);

} else {

score(board, move);

}

mutex.acquire(); result += local; mutex.release();

@@ -67,6 +69,13 @@ class Perft { score(copy, list[i]); } }

void debug(const Board &before, Move move, const Board &after) {

std::cout << std::setw(16) << std::hex << before.get_hash() << " ";

std::cout << move << " ";

std::cout << std::setw(16) << std::hex << after.get_hash() << "\n";

}

void score(const Board &board, Move move) { local.node++; #ifdef USE_FULL_COUNT

@@ -77,7 +86,6 @@ class Perft { if (move.is_promote()) local.promote++; #endif }

result_t local; semaphore_t &sem; static std::binary_semaphore mutex;

@@ -100,6 +108,7 @@ void perft_test(const char *fen, int depth, int thread_num) { for (auto &thread : threads) thread.join();

std::cout << std::dec;

std::cout << " Nodes: " << Perft::result.node << "\n"; #ifdef USE_FULL_COUNT std::cout << " Captures: " << Perft::result.capture << "\n";