stellar

Pawn hash table

7 files changed, 120 insertions(+), 46 deletions(-)

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

@@ -3,7 +3,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON) project( Stellar

VERSION 1.3.7

VERSION 1.3.8

DESCRIPTION "Chess engine written in C++" HOMEPAGE_URL https://git.dimitrijedobrota.com/stellar.git LANGUAGES CXX

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

@@ -12,6 +12,7 @@ namespace zobrist { /* Init arrays for Zobris hashing */

U32 keys_pawn[2][64] = {0};

U64 keys_piece[2][12][64] = {0}; U64 keys_enpassant[64] = {0}; U64 keys_castle[16] = {0};

@@ -57,6 +58,7 @@ Board::Board(const std::string &fen) { enpassant = fen[++i] != '-' ? from_coordinates(fen.substr(i, 2)) : Square::no_sq;

hash_pawn = zobrist::hash_pawn(*this);

hash = zobrist::hash(*this); }

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

@@ -28,10 +28,11 @@ class Board { /* Getters */

[[nodiscard]] inline constexpr U64 get_hash() const;

[[nodiscard]] inline constexpr Color get_side() const;

[[nodiscard]] inline constexpr uint8_t get_castle() const;

[[nodiscard]] inline constexpr Square get_enpassant() const;

[[nodiscard]] inline constexpr U64 get_hash() const { return hash; }

[[nodiscard]] inline constexpr Color get_side() const { return side; }

[[nodiscard]] inline constexpr uint8_t get_castle() const { return castle; }

[[nodiscard]] inline constexpr Square get_enpassant() const { return enpassant; }

[[nodiscard]] inline constexpr U64 get_hash_pawn() const { return hash_pawn; }

[[nodiscard]] inline constexpr U64 get_bitboard_color(Color side) const; [[nodiscard]] inline constexpr U64 get_bitboard_occupancy() const;

@@ -49,6 +50,8 @@ class Board { /* Setters */ inline constexpr void xor_hash(U64 op);

inline constexpr void xor_hash_pawn(U32 op);

inline constexpr void switch_side(); inline constexpr void and_castle(uint8_t right); inline constexpr void set_enpassant(Square target);

@@ -74,16 +77,12 @@ class Board { U64 colors[2] = {0}; U64 pieces[6] = {0}; U64 hash = 0;

U32 hash_pawn = 0;

Color side = WHITE; Square enpassant = Square::no_sq; uint8_t castle = 0; };

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

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

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

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

constexpr U64 Board::get_bitboard_color(Color side) const { return colors[side]; } constexpr U64 Board::get_bitboard_occupancy() const { return colors[WHITE] | colors[BLACK]; } constexpr U64 Board::get_bitboard_piece(Type piece) const { return pieces[piece]; }

@@ -122,6 +121,8 @@ constexpr Type Board::get_square_piece_type(Square square) const { /* Setters */ constexpr void Board::xor_hash(U64 op) { hash ^= op; }

constexpr void Board::xor_hash_pawn(U32 op) { hash_pawn ^= op; }

constexpr void Board::and_castle(uint8_t right) { hash ^= zobrist::key_castle(castle); castle &= right;

@@ -203,4 +204,17 @@ U64 zobrist::hash(const Board &board) { return key_final; }

U32 zobrist::hash_pawn(const Board &board) {

U32 key_final = C32(0);

uint8_t square = 0;

U64 bitboard_white = board.get_bitboard_piece(PAWN, WHITE);

bitboard_for_each_bit(square, bitboard_white) { key_final ^= keys_pawn[WHITE][square]; }

U64 bitboard_black = board.get_bitboard_piece(PAWN, BLACK);

bitboard_for_each_bit(square, bitboard_black) { key_final ^= keys_pawn[BLACK][square]; }

return key_final;

}

#endif

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

@@ -11,6 +11,7 @@ class Board; namespace zobrist {

extern U32 keys_pawn[2][64];

extern U64 keys_piece[2][12][64]; extern U64 keys_enpassant[64]; extern U64 keys_castle[16];

@@ -35,12 +36,22 @@ inline void init() { for (int castle = 0; castle < 16; castle++) { keys_castle[castle] = gen3(); }

Random gen4(C32(3642040919));

for (int c = 0; c < 2; c++) {

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

keys_pawn[c][square] = gen4.get_U32();

}

}

}; inline U64 hash(const Board &board);

inline U32 hash_pawn(const Board &board);

inline constexpr U64 key_side() { return keys_side; } inline constexpr U64 key_castle(int exp) { return keys_castle[exp]; } inline constexpr U64 key_enpassant(Square square) { return keys_enpassant[square]; }

inline constexpr U64 key_pawn(Color color, Square square) { return keys_pawn[color][square]; }

inline constexpr U64 key_piece(Type type, Color color, Square square) { return keys_piece[color][type][square]; }

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

@@ -6,6 +6,7 @@ #include "utils.hpp" #include <array>

#include <vector>

namespace evaluate {

@@ -63,8 +64,38 @@ inline constexpr const mask_passed_array mask_passed = []() constexpr -> mask_pa return mask_passed; }();

using score::Phase::ENDGAME;

using score::Phase::OPENING;

struct Hashe {

U32 key;

int16_t opening;

int16_t endgame;

int16_t total;

};

template <U32 SIZE> struct PTable {

static void clear() { memset(table, 0x00, SIZE * sizeof(Hashe)); }

[[nodiscard]] static inline U32 read(U32 hash, Color side) {

const U32 key = side * SIZE + hash % SIZE;

const Hashe &phashe = table[key];

return phashe.key == hash ? key : __UINT32_MAX__;

}

[[nodiscard]] static inline int16_t read_opening(U32 key) { return table[key].opening; }

[[nodiscard]] static inline int16_t read_endgame(U32 key) { return table[key].endgame; }

[[nodiscard]] static inline int16_t read_total(U32 key) { return table[key].total; }

static inline void write(U32 hash, Color side, int16_t opening, int16_t endgame, int16_t total) {

table[side * SIZE + hash % SIZE] = {hash, opening, endgame, total};

}

private:

static std::array<Hashe, 2 * SIZE> table;

};

template <U32 SIZE> std::array<Hashe, 2 * SIZE> PTable<SIZE>::table = {{{0}}};

PTable<65537> ptable;

uint16_t score_game_phase(const Board &board) { int16_t total = 0;

@@ -76,34 +107,47 @@ uint16_t score_game_phase(const Board &board) { } int16_t score_position_side(const Board &board, const Color side, const uint16_t phase_score) {

U64 bitboard;

using score::Phase::ENDGAME;

using score::Phase::OPENING;

int16_t total = 0, opening = 0, endgame = 0;

U64 bitboard;

int8_t square_i; const U64 pawns = board.get_bitboard_piece(PAWN); const U64 pawnsS = board.get_bitboard_piece(PAWN, side); const U64 pawnsO = pawns & ~pawnsS;

bitboard = board.get_bitboard_piece(PAWN, side);

bitboard_for_each_bit(square_i, bitboard) {

const auto square = static_cast<Square>(square_i);

opening += score::get(PAWN, side, square, OPENING) + score::get(PAWN, OPENING);

endgame += score::get(PAWN, side, square, ENDGAME) + score::get(PAWN, ENDGAME);

// check isolated, doubled and passed pawns

const uint8_t file = get_file(square), rank = get_rank(square);

if (!(mask_isolated[file] & pawnsS)) {

opening -= score::pawn_isolated_opening;

endgame -= score::pawn_isolated_endgame;

}

int16_t total = 0, opening = 0, endgame = 0;

if (bit::count(pawnsS & mask_file[file]) > 1) {

opening -= score::pawn_double_opening;

endgame -= score::pawn_double_endgame;

const U32 hash = board.get_hash_pawn();

const U32 key = ptable.read(hash, side);

if (key == __UINT32_MAX__) {

bitboard = board.get_bitboard_piece(PAWN, side);

bitboard_for_each_bit(square_i, bitboard) {

const auto square = static_cast<Square>(square_i);

opening += score::get(PAWN, side, square, OPENING) + score::get(PAWN, OPENING);

endgame += score::get(PAWN, side, square, ENDGAME) + score::get(PAWN, ENDGAME);

// check isolated, doubled and passed pawns

const uint8_t file = get_file(square), rank = get_rank(square);

if (!(mask_isolated[file] & pawnsS)) {

opening -= score::pawn_isolated_opening;

endgame -= score::pawn_isolated_endgame;

}

if (bit::count(pawnsS & mask_file[file]) > 1) {

opening -= score::pawn_double_opening;

endgame -= score::pawn_double_endgame;

}

if (!(pawnsO & mask_passed[side][square_i])) total += score::pawn_passed[side][rank];

}

if (!(pawnsO & mask_passed[side][square_i])) total += score::pawn_passed[side][rank];

ptable.write(hash, side, opening, endgame, total);

} else {

opening = ptable.read_opening(key);

endgame = ptable.read_endgame(key);

total = ptable.read_total(key);

} bitboard = board.get_bitboard_piece(KNIGHT, side);

@@ -151,10 +195,9 @@ int16_t score_position_side(const Board &board, const Color side, const uint16_t if (!(pawnsS & mask_file[file])) total -= score::file_open_semi; }

opening += total, endgame += total;

if (phase_score > score::phase_opening) return opening;

if (phase_score < score::phase_endgame) return endgame;

return score::interpolate(phase_score, opening, endgame);

if (phase_score > score::phase_opening) return opening + total;

if (phase_score < score::phase_endgame) return endgame + total;

return score::interpolate(phase_score, opening, endgame) + total;

} int16_t score_position(const Board &board) {

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

@@ -7,12 +7,16 @@ void Move::piece_remove(Board &board, Type type, Color color, Square square) const { board.pop_piece(type, color, square);

board.xor_hash(zobrist::key_piece(type, color, square));

if (type == PAWN) board.xor_hash_pawn(zobrist::key_pawn(color, square));

} void Move::piece_set(Board &board, Type type, Color color, Square square) const { board.set_piece(type, color, square);

board.xor_hash(zobrist::key_piece(type, color, square));

if (type == PAWN) board.xor_hash_pawn(zobrist::key_pawn(color, square));

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

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

@@ -34,23 +34,23 @@ struct Move { return a.source_i == b.source_i && a.target_i == b.target_i && a.flags_i == b.flags_i; }

[[nodiscard]] Square source() const { return static_cast<Square>(source_i); }

[[nodiscard]] Square target() const { return static_cast<Square>(target_i); }

[[nodiscard]] constexpr Square source() const { return static_cast<Square>(source_i); }

[[nodiscard]] constexpr Square target() const { return static_cast<Square>(target_i); }

[[nodiscard]] bool is_capture() const { return flags_i != PQUIET && (flags_i & CAPTURE); }

[[nodiscard]] bool is_promote() const { return flags_i & 0x8; }

[[nodiscard]] constexpr bool is_capture() const { return flags_i != PQUIET && (flags_i & CAPTURE); }

[[nodiscard]] constexpr bool is_promote() const { return flags_i & 0x8; }

[[nodiscard]] bool is_double() const { return flags_i == DOUBLE; }

[[nodiscard]] bool is_repeatable() const { return flags_i == QUIET; }

[[nodiscard]] bool is_quiet() const { return flags_i == QUIET || flags_i == PQUIET; }

[[nodiscard]] constexpr bool is_double() const { return flags_i == DOUBLE; }

[[nodiscard]] constexpr bool is_repeatable() const { return flags_i == QUIET; }

[[nodiscard]] constexpr bool is_quiet() const { return flags_i == QUIET || flags_i == PQUIET; }

[[nodiscard]] bool is_castle() const { return flags_i == CASTLEK || flags_i == CASTLEQ; }

[[nodiscard]] bool is_castle_king() const { return flags_i == CASTLEK; }

[[nodiscard]] bool is_castle_queen() const { return flags_i == CASTLEQ; }

[[nodiscard]] constexpr bool is_castle() const { return flags_i == CASTLEK || flags_i == CASTLEQ; }

[[nodiscard]] constexpr bool is_castle_king() const { return flags_i == CASTLEK; }

[[nodiscard]] constexpr bool is_castle_queen() const { return flags_i == CASTLEQ; }

[[nodiscard]] bool is_enpassant() const { return flags_i == ENPASSANT; }

[[nodiscard]] constexpr bool is_enpassant() const { return flags_i == ENPASSANT; }

[[nodiscard]] const Type promoted() const { return static_cast<Type>((flags_i & 0x3) + 1); }

[[nodiscard]] constexpr const Type promoted() const { return static_cast<Type>((flags_i & 0x3) + 1); }

bool make(Board &board) const;