diff --git a/Chess/EnumArray.h b/Chess/EnumArray.h new file mode 100644 index 0000000..b9abbb5 --- /dev/null +++ b/Chess/EnumArray.h @@ -0,0 +1,50 @@ +#pragma once + +#include +#include +#include +#include + +namespace SimpleChessEngine { + +template +inline constexpr std::size_t kEnumSize = 0; + +template +concept IndexEnum = std::is_enum_v && (kEnumSize > 0); + +template +struct EnumArray { + using value_type = Value; + using iterator = typename std::array>::iterator; + using const_iterator = + typename std::array>::const_iterator; + + std::array> values; + + [[nodiscard]] constexpr Value& operator[](Key key) noexcept { + return values[std::to_underlying(key)]; + } + [[nodiscard]] constexpr const Value& operator[](Key key) const noexcept { + return values[std::to_underlying(key)]; + } + + [[nodiscard]] static constexpr std::size_t size() noexcept { + return kEnumSize; + } + + [[nodiscard]] constexpr iterator begin() noexcept { return values.begin(); } + [[nodiscard]] constexpr const_iterator begin() const noexcept { + return values.begin(); + } + [[nodiscard]] constexpr iterator end() noexcept { return values.end(); } + [[nodiscard]] constexpr const_iterator end() const noexcept { + return values.end(); + } + + constexpr void fill(const Value& value) { values.fill(value); } + + [[nodiscard]] constexpr bool operator==(const EnumArray&) const = default; +}; + +} // namespace SimpleChessEngine diff --git a/Chess/Evaluation.cpp b/Chess/Evaluation.cpp index e6c06db..b996456 100644 --- a/Chess/Evaluation.cpp +++ b/Chess/Evaluation.cpp @@ -32,7 +32,7 @@ struct KingPawnHashEntry { Bitboard black_pawns{}; BitIndex white_king{-1}; BitIndex black_king{-1}; - std::array king_score{}; + ByPlayer king_score{}; }; struct KingPawnHashTable { @@ -44,10 +44,10 @@ thread_local KingPawnHashTable king_pawn_hash_table; struct PawnEvaluation { TaperedEval score{}; - std::array king_score{}; + ByPlayer king_score{}; }; -[[nodiscard]] const std::array& EvaluateKingPawns( +[[nodiscard]] const ByPlayer& EvaluateKingPawns( const Position& position, Bitboard white_pawns, Bitboard black_pawns, size_t pawn_hash_index); @@ -66,27 +66,25 @@ struct PawnEvaluation { [[nodiscard]] TaperedEval EvaluatePawns(const Bitboard pawns, const Bitboard enemy_pawns, const Player side) { - const auto side_index = static_cast(side); TaperedEval result{}; Bitboard remaining = pawns; while (remaining.Any()) { const BitIndex square = remaining.PopFirstBit(); - if ((pawns & kPawnSpans.rear[side_index][square]).Any()) { + if ((pawns & kPawnSpans.rear[side][square]).Any()) { result += Settings::EvaluationParameters::doubled_pawn; } if ((pawns & kPawnSpans.adjacent_files[square]).None()) { result += Settings::EvaluationParameters::isolated_pawn; } const auto [file_coordinate, rank_coordinate] = GetCoordinates(square); - const auto file = static_cast(file_coordinate); const auto rank = static_cast(rank_coordinate); const auto relative_rank = side == Player::kWhite ? rank : static_cast(7 - rank); result += Settings::EvaluationParameters::pawn_psqt_adjustment[relative_rank] - [file]; - if ((enemy_pawns & kPawnSpans.passed[side_index][square]).Any()) { + [file_coordinate]; + if ((enemy_pawns & kPawnSpans.passed[side][square]).Any()) { continue; } result += Settings::EvaluationParameters::passed_pawn[relative_rank]; @@ -128,7 +126,7 @@ void AddMobility(const Position& position, const Player side, const Bitboard occupied, const Bitboard mobility_area, TaperedEval& result) { const auto& weight = - Settings::EvaluationParameters::mobility[static_cast(piece)]; + Settings::EvaluationParameters::mobility[piece]; if (weight == TaperedEval{}) return; Bitboard pieces = position.GetPiecesByType(side); @@ -172,8 +170,8 @@ void AddPsqtAdjustment(const Position& position, const Player side, side == Player::kWhite ? rank : static_cast(7 - rank); const size_t mirrored_file = std::min(file, static_cast(7 - file)); result += - Settings::EvaluationParameters::psqt_adjustment[static_cast( - piece)][relative_rank][mirrored_file]; + Settings::EvaluationParameters::psqt_adjustment[ + piece][relative_rank][mirrored_file]; } } @@ -213,7 +211,7 @@ void AddPsqtAdjustment(const Position& position, const Player side, result += Settings::EvaluationParameters::king_shield_far; } - const Bitboard file_mask = kFileBB[static_cast(file)]; + const Bitboard file_mask = kFileBB[file]; if ((own_pawns & file_mask).None()) { result += Settings::EvaluationParameters::king_semi_open_file; if ((enemy_pawns & file_mask).None()) { @@ -240,7 +238,7 @@ void AddPsqtAdjustment(const Position& position, const Player side, return result; } -[[nodiscard]] const std::array& EvaluateKingPawns( +[[nodiscard]] const ByPlayer& EvaluateKingPawns( const Position& position, const Bitboard white_pawns, const Bitboard black_pawns, const size_t pawn_hash_index) { const BitIndex white_king = position.GetKingSquare(Player::kWhite); @@ -312,7 +310,7 @@ void AddKingTropism(const Position& position, const Player attacker, const size_t tropism = outer + (pieces & masks[0]).Count(); attack_units += static_cast(tropism) * - Settings::EvaluationParameters::king_attack[static_cast(piece)]; + Settings::EvaluationParameters::king_attack[piece]; } [[nodiscard]] Eval EvaluateKingAttack(const Position& position, @@ -353,9 +351,9 @@ void AddKingTropism(const Position& position, const Player attacker, [[nodiscard]] Eval TaperedEval::operator()(PhaseValue pv) const { const auto mg_limit = - kPhaseValueLimits[static_cast(GamePhase::kMiddleGame)]; + kPhaseValueLimits[GamePhase::kMiddleGame]; const auto eg_limit = - kPhaseValueLimits[static_cast(GamePhase::kEndGame)]; + kPhaseValueLimits[GamePhase::kEndGame]; pv = std::clamp(pv, eg_limit, mg_limit); return (eval[static_cast(GamePhase::kMiddleGame)] * (pv - eg_limit) + eval[static_cast(GamePhase::kEndGame)] * (mg_limit - pv)) / @@ -381,18 +379,15 @@ void AddKingTropism(const Position& position, const Player attacker, const auto us = side_to_move_; const auto them = Flip(us); - const auto us_idx = static_cast(us); - const auto them_idx = static_cast(them); TaperedEval result{}; result += - evaluation_data_.material[us_idx] - evaluation_data_.material[them_idx]; + evaluation_data_.material[us] - evaluation_data_.material[them]; if (Settings::EvaluationParameters::material_enabled) { - for (size_t piece = static_cast(Piece::kPawn); - piece <= static_cast(Piece::kQueen); ++piece) { + for (const auto piece : kPiecesByValue) { const int count_difference = - static_cast(evaluation_data_.piece_counts[us_idx][piece]) - - static_cast(evaluation_data_.piece_counts[them_idx][piece]); + static_cast(evaluation_data_.piece_counts[us][piece]) - + static_cast(evaluation_data_.piece_counts[them][piece]); const TaperedEval correction = Settings::EvaluationParameters::material_value[piece] - kPieceValues[piece]; @@ -400,7 +395,7 @@ void AddKingTropism(const Position& position, const Player attacker, result.eval[1] += count_difference * correction.eval[1]; } } - result += evaluation_data_.psqt[us_idx] - evaluation_data_.psqt[them_idx]; + result += evaluation_data_.psqt[us] - evaluation_data_.psqt[them]; const bool king_safety_active = Settings::EvaluationParameters::king_safety_enabled && (GetPiecesByType(Player::kWhite) | @@ -430,8 +425,8 @@ void AddKingTropism(const Position& position, const Player attacker, if (king_safety_active) { if (Settings::EvaluationParameters::king_pawns_enabled) { result += - EvaluateKingSafety(*this, us, pawn_evaluation.king_score[us_idx]) - - EvaluateKingSafety(*this, them, pawn_evaluation.king_score[them_idx]); + EvaluateKingSafety(*this, us, pawn_evaluation.king_score[us]) - + EvaluateKingSafety(*this, them, pawn_evaluation.king_score[them]); } else { result += EvaluateKingSafety(*this, us, 0) - EvaluateKingSafety(*this, them, 0); diff --git a/Chess/Evaluation.h b/Chess/Evaluation.h index 7b9c62d..53d0ecd 100644 --- a/Chess/Evaluation.h +++ b/Chess/Evaluation.h @@ -11,6 +11,12 @@ using SearchResult = std::optional; enum class GamePhase : std::uint8_t { kMiddleGame, kEndGame }; +template <> +inline constexpr std::size_t kEnumSize = 2; + +template +using ByGamePhase = EnumArray; + constexpr size_t kGamePhases = 2; using PhaseValue = int; @@ -46,32 +52,33 @@ struct TaperedEval { return copy; } -constexpr std::array kPieceValues = {{{0, 0}, - {82, 94}, - {337, 281}, - {365, 297}, - {477, 512}, - {1025, 936}, - {0, 0}}}; +inline constexpr ByPiece kPieceValues = {{{{0, 0}, + {82, 94}, + {337, 281}, + {365, 297}, + {477, 512}, + {1025, 936}, + {0, 0}}}}; constexpr Eval kFullNonPawnMaterial = - kPieceValues[static_cast(Piece::kKnight)] + kPieceValues[Piece::kKnight] .eval[static_cast(GamePhase::kMiddleGame)] * 4 + - kPieceValues[static_cast(Piece::kBishop)] + kPieceValues[Piece::kBishop] .eval[static_cast(GamePhase::kMiddleGame)] * 4 + - kPieceValues[static_cast(Piece::kRook)] + kPieceValues[Piece::kRook] .eval[static_cast(GamePhase::kMiddleGame)] * 4 + - kPieceValues[static_cast(Piece::kQueen)] + kPieceValues[Piece::kQueen] .eval[static_cast(GamePhase::kMiddleGame)] * 2; -constexpr std::array kPhaseValueLimits = {kFullNonPawnMaterial, 0}; +constexpr ByGamePhase kPhaseValueLimits = {{kFullNonPawnMaterial, 0}}; constexpr PhaseValue kLimitsDifference = - kPhaseValueLimits[0] - kPhaseValueLimits[1]; + kPhaseValueLimits[GamePhase::kMiddleGame] - + kPhaseValueLimits[GamePhase::kEndGame]; constexpr Eval kTempoBonus = 20; diff --git a/Chess/Hasher.h b/Chess/Hasher.h index 966e97d..9e232ec 100644 --- a/Chess/Hasher.h +++ b/Chess/Hasher.h @@ -66,10 +66,10 @@ struct Hasher { constexpr bool operator==(const Hasher&) const = default; - std::array, kColors>, kPieceTypes> + ByPiece>> psqt_hash{}; std::array en_croissant_hash{}; - std::array, kColors> cr_hash{}; + ByPlayer> cr_hash{}; Hash stm_hash; }; extern const Hasher kZobristKeys; diff --git a/Chess/Move.h b/Chess/Move.h index 61a1990..bf4d524 100644 --- a/Chess/Move.h +++ b/Chess/Move.h @@ -1,8 +1,11 @@ #pragma once +#include +#include #include #include #include #include "BitBoard.h" +#include "EnumArray.h" #include "Piece.h" namespace SimpleChessEngine { @@ -93,6 +96,14 @@ class Move { enum class CastlingSide : std::uint8_t { k00, k000 }; +template <> +inline constexpr std::size_t kEnumSize = 2; + +inline constexpr std::array kCastlingSides{CastlingSide::k00, CastlingSide::k000}; + +template +using ByCastlingSide = EnumArray; + static_assert(sizeof(Move) == 2, "Move must be exactly 2 bytes"); static_assert(alignof(Move) == 2, "Move should be 2-byte aligned"); static_assert(std::is_trivially_copyable_v, "Move must be trivially copyable"); diff --git a/Chess/MoveGenerator.cpp b/Chess/MoveGenerator.cpp index b7e8f81..fd30b7b 100644 --- a/Chess/MoveGenerator.cpp +++ b/Chess/MoveGenerator.cpp @@ -27,12 +27,10 @@ void MoveGenerator::GenerateCastling(PseudoLegalMoves& moves, const auto side_to_move = position.GetSideToMove(); const auto king_square = position.GetKingSquare(side_to_move); - const auto color_idx = static_cast(side_to_move); for (const auto castling_side : {CastlingSide::k00, CastlingSide::k000}) { if (position.CanPseudoCastle(castling_side)) { - const auto side_idx = static_cast(castling_side); - const auto king_to = kKingCastlingDestination[color_idx][side_idx]; + const auto king_to = kKingCastlingDestination[side_to_move][castling_side]; moves.unchecked_push_back(PseudoLegalMove( Move::Make(king_square, king_to))); @@ -56,14 +54,12 @@ template <> void MoveGenerator::GenerateMovesForPiece( PseudoLegalMoves& moves, Position& position, const Bitboard target) const { const auto us = position.GetSideToMove(); - const auto us_idx = static_cast(us); const auto them = Flip(us); - const auto them_idx = static_cast(them); const auto pawns = position.GetPiecesByType(us); const auto promotion_rank = us == Player::kWhite ? kRankBB[6] : kRankBB[1]; - const auto direction = kPawnMoveDirection[us_idx]; - const auto opposite_direction = kPawnMoveDirection[them_idx]; + const auto direction = kPawnMoveDirection[us]; + const auto opposite_direction = kPawnMoveDirection[them]; const auto non_promoting_pawns = pawns & ~promotion_rank; diff --git a/Chess/MovePicker.cpp b/Chess/MovePicker.cpp index e5f210d..a2ae3e4 100644 --- a/Chess/MovePicker.cpp +++ b/Chess/MovePicker.cpp @@ -51,7 +51,7 @@ void MovePicker::InitPicker(Position& position, const Searcher* searcher, evasions_ = position.IsUnderCheck(); position.ComputePins(position.GetSideToMove()); blockers_ = position.GetIrreversibleData() - .blockers[static_cast(position.GetSideToMove())]; + .blockers[position.GetSideToMove()]; excluded_move_ = excluded_move; tt_move_ = position.IsPseudoLegal(tt_move) ? tt_move : Move::None(); stage_ = Stage::kTT; diff --git a/Chess/PSQT.h b/Chess/PSQT.h index f2e4ae8..ce1aec8 100644 --- a/Chess/PSQT.h +++ b/Chess/PSQT.h @@ -5,11 +5,10 @@ namespace SimpleChessEngine { // clang-format off consteval auto MakePSQT() { - std::array, kPieceTypes>, - kColors> - table = { { + ByPlayer>> + table = { { { // White pieces table - {{// Empty squares values are irrelevant since kNone is not being placed + {{{// Empty squares values are irrelevant since kNone is not being placed // or removed at any time {}, // Pawns @@ -78,10 +77,10 @@ consteval auto MakePSQT() { { 29 , -12 }, { -1 , 17 }, { -20 , 14 }, { -7 , 17 }, { -8 , 17 }, { -4 , 38 }, { -38 , 23 }, { -29 , 11 }, { -65 , -74 }, { 23 , -35 }, { 16 , -18 }, { -15 , -18 }, { -56 , -11 }, { -34 , 15 }, { 2 , 4 }, { 13 , -17 }, }} - }} + }}} // Black pieces table is initialized symmetrically to the white pieces // table -} }; +} } }; // clang-format on for (auto piece : {Piece::kPawn, Piece::kKnight, Piece::kBishop, Piece::kRook, @@ -90,9 +89,8 @@ consteval auto MakePSQT() { ++square) { const auto [file, rank] = GetCoordinates(square); const BitIndex new_square = GetSquareIndex(file, 7 - rank); - table[static_cast(Player::kBlack)][static_cast(piece)] - [new_square] = table[static_cast(Player::kWhite)] - [static_cast(piece)][square]; + table[Player::kBlack][piece][new_square] = + table[Player::kWhite][piece][square]; } } return table; diff --git a/Chess/Piece.h b/Chess/Piece.h index 3429e0d..64a72ce 100644 --- a/Chess/Piece.h +++ b/Chess/Piece.h @@ -1,6 +1,10 @@ #pragma once +#include +#include #include +#include "EnumArray.h" + namespace SimpleChessEngine { /** @@ -21,4 +25,14 @@ enum class Piece : uint8_t { return piece == Piece::kNone; } + +template <> +inline constexpr std::size_t kEnumSize = 7; + +template +using ByPiece = EnumArray; + +inline constexpr std::array kPiecesByValue{Piece::kPawn, Piece::kKnight, + Piece::kBishop, Piece::kRook, + Piece::kQueen}; } // namespace SimpleChessEngine diff --git a/Chess/Player.h b/Chess/Player.h index e0843a9..1d62ebe 100644 --- a/Chess/Player.h +++ b/Chess/Player.h @@ -1,6 +1,10 @@ #pragma once +#include +#include #include +#include "EnumArray.h" + namespace SimpleChessEngine { /** @@ -16,4 +20,12 @@ enum class Player : std::uint8_t { return player == Player::kWhite ? Player::kBlack : Player::kWhite; } + +template <> +inline constexpr std::size_t kEnumSize = 2; + +inline constexpr std::array kPlayers{Player::kWhite, Player::kBlack}; + +template +using ByPlayer = EnumArray; } // namespace SimpleChessEngine diff --git a/Chess/Position.cpp b/Chess/Position.cpp index 10433b2..ede2d12 100644 --- a/Chess/Position.cpp +++ b/Chess/Position.cpp @@ -2,6 +2,7 @@ #include #include +#include #include "Attacks.h" #include "BitBoard.h" @@ -11,6 +12,25 @@ #include "Piece.h" namespace SimpleChessEngine { +static_assert(std::to_underlying(Player::kWhite) == + std::to_underlying(Stockfish::WHITE)); +static_assert(std::to_underlying(Player::kBlack) == + std::to_underlying(Stockfish::BLACK)); +static_assert([] { + constexpr std::array mapping{ + std::pair{Piece::kNone, Stockfish::NO_PIECE_TYPE}, + std::pair{Piece::kPawn, Stockfish::PAWN}, + std::pair{Piece::kKnight, Stockfish::KNIGHT}, + std::pair{Piece::kBishop, Stockfish::BISHOP}, + std::pair{Piece::kRook, Stockfish::ROOK}, + std::pair{Piece::kQueen, Stockfish::QUEEN}, + std::pair{Piece::kKing, Stockfish::KING}}; + for (const auto& [piece, stockfish_piece] : mapping) { + if (std::to_underlying(piece) != std::to_underlying(stockfish_piece)) + return false; + } + return true; +}()); template Bitboard Position::GetPiecesByType(Player player) const; template Bitboard Position::GetPiecesByType( @@ -23,8 +43,8 @@ template Bitboard Position::GetPiecesByType(Player player) const; Eval Position::SimpleMaterialEval() const { - return evaluation_data_.material[static_cast(side_to_move_)].eval[0] - - evaluation_data_.material[static_cast(Flip(side_to_move_))].eval[0]; + return evaluation_data_.material[side_to_move_].eval[0] - + evaluation_data_.material[Flip(side_to_move_)].eval[0]; } /** @@ -41,17 +61,15 @@ void Position::PlacePiece(const BitIndex square, const Piece piece, assert(IsOk(square)); assert(!board_[square]); assert(piece); - const auto piece_idx = static_cast(piece); - const auto color_idx = static_cast(color); board_[square] = piece; - pieces_by_type_[piece_idx].Set(square); - pieces_by_color_[color_idx].Set(square); - ++evaluation_data_.piece_counts[color_idx][piece_idx]; - evaluation_data_.material[color_idx] += kPieceValues[piece_idx]; - evaluation_data_.psqt[color_idx] += kPSQT[color_idx][piece_idx][square]; + pieces_by_type_[piece].Set(square); + pieces_by_color_[color].Set(square); + ++evaluation_data_.piece_counts[color][piece]; + evaluation_data_.material[color] += kPieceValues[piece]; + evaluation_data_.psqt[color] += kPSQT[color][piece][square]; if (piece != Piece::kPawn) - evaluation_data_.non_pawn_material += kPieceValues[piece_idx].eval[0]; - hash_ ^= kZobristKeys.psqt_hash[piece_idx][color_idx][square]; + evaluation_data_.non_pawn_material += kPieceValues[piece].eval[0]; + hash_ ^= kZobristKeys.psqt_hash[piece][color][square]; if (threats) Stockfish::Position{*this}.update_piece_threats( Stockfish::make_piece(static_cast(color), @@ -72,22 +90,20 @@ void Position::RemovePiece(const BitIndex square, const Player color, assert(IsOk(square)); const auto piece = board_[square]; assert(!!piece); - const auto piece_idx = static_cast(piece); - const auto color_idx = static_cast(color); if (threats) Stockfish::Position{*this}.update_piece_threats( Stockfish::make_piece(static_cast(color), static_cast(piece)), false, static_cast(square), threats); - pieces_by_type_[piece_idx].Reset(square); - pieces_by_color_[color_idx].Reset(square); - --evaluation_data_.piece_counts[color_idx][piece_idx]; + pieces_by_type_[piece].Reset(square); + pieces_by_color_[color].Reset(square); + --evaluation_data_.piece_counts[color][piece]; board_[square] = Piece::kNone; - evaluation_data_.material[color_idx] -= kPieceValues[piece_idx]; - evaluation_data_.psqt[color_idx] -= kPSQT[color_idx][piece_idx][square]; + evaluation_data_.material[color] -= kPieceValues[piece]; + evaluation_data_.psqt[color] -= kPSQT[color][piece][square]; if (piece != Piece::kPawn) - evaluation_data_.non_pawn_material -= kPieceValues[piece_idx].eval[0]; - hash_ ^= kZobristKeys.psqt_hash[piece_idx][color_idx][square]; + evaluation_data_.non_pawn_material -= kPieceValues[piece].eval[0]; + hash_ ^= kZobristKeys.psqt_hash[piece][color][square]; } void Position::MovePiece(const BitIndex from, const BitIndex to, @@ -97,8 +113,6 @@ void Position::MovePiece(const BitIndex from, const BitIndex to, const auto piece = board_[from]; assert(!!piece); assert(!board_[to]); - const auto piece_idx = static_cast(piece); - const auto color_idx = static_cast(color); const auto sf_piece = Stockfish::make_piece(static_cast(color), static_cast(piece)); @@ -109,16 +123,16 @@ void Position::MovePiece(const BitIndex from, const BitIndex to, Stockfish::Position{*this}.update_piece_threats( sf_piece, false, static_cast(from), threats, from_to); - pieces_by_type_[piece_idx].Reset(from); - pieces_by_color_[color_idx].Reset(from); - pieces_by_type_[piece_idx].Set(to); - pieces_by_color_[color_idx].Set(to); + pieces_by_type_[piece].Reset(from); + pieces_by_color_[color].Reset(from); + pieces_by_type_[piece].Set(to); + pieces_by_color_[color].Set(to); board_[from] = Piece::kNone; board_[to] = piece; - evaluation_data_.psqt[color_idx] -= kPSQT[color_idx][piece_idx][from]; - evaluation_data_.psqt[color_idx] += kPSQT[color_idx][piece_idx][to]; - hash_ ^= kZobristKeys.psqt_hash[piece_idx][color_idx][from]; - hash_ ^= kZobristKeys.psqt_hash[piece_idx][color_idx][to]; + evaluation_data_.psqt[color] -= kPSQT[color][piece][from]; + evaluation_data_.psqt[color] += kPSQT[color][piece][to]; + hash_ ^= kZobristKeys.psqt_hash[piece][color][from]; + hash_ ^= kZobristKeys.psqt_hash[piece][color][to]; if (threats) Stockfish::Position{*this}.update_piece_threats( sf_piece, true, static_cast(to), threats, from_to); @@ -128,7 +142,7 @@ bool Position::VerifyPinCache() const { const auto cached = irreversible_data_; bool valid = true; for (const auto player : {Player::kWhite, Player::kBlack}) { - const auto side = static_cast(player); + const auto side = player; if (!cached.pins_valid[side]) continue; irreversible_data_.pins_valid[side] = false; ComputePins(player); @@ -145,54 +159,51 @@ bool Position::VerifyIncrementalState() const { static thread_local std::uint64_t checks = 0; if ((checks++ & 4095u) != 0) return true; - std::array pieces_by_type{}; - std::array pieces_by_color{}; - std::array king_position{}; - std::array king_count{}; + ByPiece pieces_by_type{}; + ByPlayer pieces_by_color{}; + ByPlayer king_position{}; + ByPlayer king_count{}; EvaluationData evaluation; Hash hash = side_to_move_ == Player::kBlack ? kZobristKeys.stm_hash : 0; for (std::size_t index = 0; index < kBoardArea; ++index) { const auto square = static_cast(index); const auto piece = board_[square]; - const bool white = pieces_by_color_[0].Test(square); - const bool black = pieces_by_color_[1].Test(square); + const bool white = pieces_by_color_[Player::kWhite].Test(square); + const bool black = pieces_by_color_[Player::kBlack].Test(square); if (piece == Piece::kNone) { if (white || black) return false; continue; } if (white == black) return false; const auto color = white ? Player::kWhite : Player::kBlack; - const auto color_idx = static_cast(color); - const auto piece_idx = static_cast(piece); - pieces_by_type[piece_idx].Set(square); - pieces_by_color[color_idx].Set(square); - ++evaluation.piece_counts[color_idx][piece_idx]; - evaluation.material[color_idx] += kPieceValues[piece_idx]; - evaluation.psqt[color_idx] += kPSQT[color_idx][piece_idx][square]; + pieces_by_type[piece].Set(square); + pieces_by_color[color].Set(square); + ++evaluation.piece_counts[color][piece]; + evaluation.material[color] += kPieceValues[piece]; + evaluation.psqt[color] += kPSQT[color][piece][square]; if (piece != Piece::kPawn) { - evaluation.non_pawn_material += kPieceValues[piece_idx].eval[0]; + evaluation.non_pawn_material += kPieceValues[piece].eval[0]; } if (piece == Piece::kKing) { - king_position[color_idx] = square; - ++king_count[color_idx]; + king_position[color] = square; + ++king_count[color]; } - hash ^= kZobristKeys.psqt_hash[piece_idx][color_idx][square]; + hash ^= kZobristKeys.psqt_hash[piece][color][square]; } - for (std::size_t color = 0; color < kColors; ++color) { + for (const auto color : kPlayers) { hash ^= kZobristKeys.cr_hash[color][0]; hash ^= kZobristKeys .cr_hash[color] [irreversible_data_.castling_rights[color].to_ulong()]; } if (irreversible_data_.en_croissant_square) { - hash ^= - kZobristKeys.en_croissant_hash - [GetCoordinates(*irreversible_data_.en_croissant_square).first]; + hash ^= kZobristKeys.en_croissant_hash + [GetCoordinates(*irreversible_data_.en_croissant_square).first]; } if (pieces_by_type != pieces_by_type_ || pieces_by_color != pieces_by_color_ || - (pieces_by_color[0] | pieces_by_color[1]) != GetAllPieces() || - king_count[0] != 1 || king_count[1] != 1 || + (pieces_by_color[Player::kWhite] | pieces_by_color[Player::kBlack]) != GetAllPieces() || + king_count[Player::kWhite] != 1 || king_count[Player::kBlack] != 1 || king_position != king_position_ || evaluation != evaluation_data_ || hash != hash_) { return false; @@ -215,9 +226,9 @@ void Position::DoMove(const LegalMove &move) { irreversible_data_.en_croissant_square.reset(); } for (const auto color : {Player::kWhite, Player::kBlack}) { - hash_ ^= kZobristKeys.cr_hash[static_cast( - color)][irreversible_data_.castling_rights[static_cast(color)] - .to_ulong()]; + hash_ ^= kZobristKeys + .cr_hash[color] + [irreversible_data_.castling_rights[color].to_ulong()]; } const auto from = move.From(); @@ -255,11 +266,11 @@ void Position::DoMove(const LegalMove &move) { static_cast(square), threats); }; for (const auto color : {Player::kWhite, Player::kBlack}) - dirties.dirtyPawnPairs.before[static_cast(color)] = + dirties.dirtyPawnPairs.before[std::to_underlying(color)] = static_cast(GetPiecesOf(color, Piece::kPawn)); if (move.IsEnPassant()) { - const auto capture_square = Shift(to, kPawnMoveDirection[static_cast(them)]); + const auto capture_square = Shift(to, kPawnMoveDirection[them]); irreversible_data_.captured_piece = Piece::kPawn; // En passant always captures a pawn dirty.remove_pc = sf_piece(Piece::kPawn, them); dirty.remove_sq = static_cast(capture_square); @@ -282,10 +293,10 @@ void Position::DoMove(const LegalMove &move) { PlacePiece(to, promoted_to, us, threats); for (const auto castling_side : {CastlingSide::k00, CastlingSide::k000}) { - const auto their_rook = rook_positions_[static_cast(them)][static_cast(castling_side)]; + const auto their_rook = rook_positions_[them][castling_side]; if (to == their_rook) { - irreversible_data_.castling_rights[static_cast(them)] &= - ~static_cast(kCastlingRightsForSide[static_cast(castling_side)]); + irreversible_data_.castling_rights[them] &= + ~static_cast(kCastlingRightsForSide[castling_side]); } } } else if (move.IsCastling()) { @@ -295,32 +306,30 @@ void Position::DoMove(const LegalMove &move) { const auto king_from = from; // Determine which side based on king destination - const auto color_idx = static_cast(us); CastlingSide side; BitIndex rook_from; - if (king_to == kKingCastlingDestination[color_idx][0]) { + if (king_to == kKingCastlingDestination[us][CastlingSide::k00]) { side = CastlingSide::k00; - rook_from = rook_positions_[color_idx][0]; + rook_from = rook_positions_[us][CastlingSide::k00]; } else { side = CastlingSide::k000; - rook_from = rook_positions_[color_idx][1]; + rook_from = rook_positions_[us][CastlingSide::k000]; } - const auto side_idx = static_cast(side); dirty.remove_pc = dirty.add_pc = sf_piece(Piece::kRook, us); dirty.remove_sq = static_cast(rook_from); dirty.add_sq = static_cast( - kRookCastlingDestination[color_idx][side_idx]); + kRookCastlingDestination[us][side]); RemovePiece(king_from, us, threats); RemovePiece(rook_from, us, threats); - PlacePiece(kKingCastlingDestination[color_idx][side_idx], Piece::kKing, us, + PlacePiece(kKingCastlingDestination[us][side], Piece::kKing, us, threats); - PlacePiece(kRookCastlingDestination[color_idx][side_idx], Piece::kRook, us, + PlacePiece(kRookCastlingDestination[us][side], Piece::kRook, us, threats); - king_position_[color_idx] = kKingCastlingDestination[color_idx][side_idx]; - irreversible_data_.castling_rights[color_idx] = 0; + king_position_[us] = kKingCastlingDestination[us][side]; + irreversible_data_.castling_rights[us] = 0; } else { // Normal move (including pawn pushes and double pushes) const auto piece_to_move = board_[from]; @@ -345,32 +354,32 @@ void Position::DoMove(const LegalMove &move) { } if (piece_to_move == Piece::kKing) { - king_position_[static_cast(us)] = to; - irreversible_data_.castling_rights[static_cast(us)] = 0; + king_position_[us] = to; + irreversible_data_.castling_rights[us] = 0; } for (auto castling_side : {CastlingSide::k00, CastlingSide::k000}) { - const auto our_rook = rook_positions_[static_cast(us)][static_cast(castling_side)]; - const auto their_rook = rook_positions_[static_cast(them)][static_cast(castling_side)]; + const auto our_rook = rook_positions_[us][castling_side]; + const auto their_rook = rook_positions_[them][castling_side]; if (from == our_rook) { - irreversible_data_.castling_rights[static_cast(us)] &= - ~static_cast(kCastlingRightsForSide[static_cast(castling_side)]); + irreversible_data_.castling_rights[us] &= + ~static_cast(kCastlingRightsForSide[castling_side]); } if (to == their_rook) { - irreversible_data_.castling_rights[static_cast(them)] &= - ~static_cast(kCastlingRightsForSide[static_cast(castling_side)]); + irreversible_data_.castling_rights[them] &= + ~static_cast(kCastlingRightsForSide[castling_side]); } } } for (const auto color : {Player::kWhite, Player::kBlack}) - dirties.dirtyPawnPairs.after[static_cast(color)] = + dirties.dirtyPawnPairs.after[std::to_underlying(color)] = static_cast(GetPiecesOf(color, Piece::kPawn)); for (const auto color : {Player::kWhite, Player::kBlack}) { - hash_ ^= kZobristKeys.cr_hash[static_cast( - color)][irreversible_data_.castling_rights[static_cast(color)] - .to_ulong()]; + hash_ ^= kZobristKeys + .cr_hash[color] + [irreversible_data_.castling_rights[color].to_ulong()]; } side_to_move_ = Flip(side_to_move_); hash_ ^= kZobristKeys.stm_hash; @@ -396,8 +405,8 @@ void SimpleChessEngine::Position::DoMove(NullMove) { for (const auto color : {Player::kWhite, Player::kBlack}) { const auto pawns = static_cast(GetPiecesOf(color, Piece::kPawn)); - dirties.dirtyPawnPairs.before[static_cast(color)] = pawns; - dirties.dirtyPawnPairs.after[static_cast(color)] = pawns; + dirties.dirtyPawnPairs.before[std::to_underlying(color)] = pawns; + dirties.dirtyPawnPairs.after[std::to_underlying(color)] = pawns; } history_stack_.Push(hash_, false); @@ -408,9 +417,9 @@ void SimpleChessEngine::Position::DoMove(NullMove) { void Position::UndoMove(const LegalMove &move, const IrreversibleData &data) { const auto &ep_square = irreversible_data_.en_croissant_square; for (const auto color : {Player::kWhite, Player::kBlack}) { - hash_ ^= kZobristKeys.cr_hash[static_cast( - color)][irreversible_data_.castling_rights[static_cast(color)] - .to_ulong()]; + hash_ ^= kZobristKeys + .cr_hash[color] + [irreversible_data_.castling_rights[color].to_ulong()]; } if (ep_square.has_value()) { hash_ ^= @@ -426,9 +435,9 @@ void Position::UndoMove(const LegalMove &move, const IrreversibleData &data) { irreversible_data_ = data; for (const auto color : {Player::kWhite, Player::kBlack}) { - hash_ ^= kZobristKeys.cr_hash[static_cast( - color)][irreversible_data_.castling_rights[static_cast(color)] - .to_ulong()]; + hash_ ^= kZobristKeys + .cr_hash[color] + [irreversible_data_.castling_rights[color].to_ulong()]; } if (irreversible_data_.en_croissant_square.has_value()) { hash_ ^= kZobristKeys.en_croissant_hash @@ -439,7 +448,7 @@ void Position::UndoMove(const LegalMove &move, const IrreversibleData &data) { side_to_move_ = Flip(side_to_move_); if (move.IsEnPassant()) { - const auto capture_square = Shift(to, kPawnMoveDirection[static_cast(them)]); + const auto capture_square = Shift(to, kPawnMoveDirection[them]); MovePiece(to, from, us); PlacePiece(capture_square, Piece::kPawn, them); } else if (move.IsPromotion()) { @@ -447,25 +456,23 @@ void Position::UndoMove(const LegalMove &move, const IrreversibleData &data) { if (!!captured_piece) PlacePiece(to, captured_piece, them); PlacePiece(from, Piece::kPawn, us); } else if (move.IsCastling()) { - const auto color_idx = static_cast(us); CastlingSide side; - if (to == kKingCastlingDestination[color_idx][0]) { + if (to == kKingCastlingDestination[us][CastlingSide::k00]) { side = CastlingSide::k00; } else { side = CastlingSide::k000; } - const auto side_idx = static_cast(side); - const auto rook_from = rook_positions_[color_idx][side_idx]; + const auto rook_from = rook_positions_[us][side]; - RemovePiece(kKingCastlingDestination[color_idx][side_idx], us); - RemovePiece(kRookCastlingDestination[color_idx][side_idx], us); + RemovePiece(kKingCastlingDestination[us][side], us); + RemovePiece(kRookCastlingDestination[us][side], us); PlacePiece(from, Piece::kKing, us); PlacePiece(rook_from, Piece::kRook, us); - king_position_[color_idx] = from; + king_position_[us] = from; } else { // Normal move const auto piece_to_move = board_[to]; @@ -474,7 +481,7 @@ void Position::UndoMove(const LegalMove &move, const IrreversibleData &data) { if (!!captured_piece) PlacePiece(to, captured_piece, them); if (piece_to_move == Piece::kKing) { - king_position_[static_cast(us)] = from; + king_position_[us] = from; } } @@ -500,13 +507,14 @@ void SimpleChessEngine::Position::UndoMove(NullMove, } bool Position::CanPseudoCastle(CastlingSide side) const { - const auto us = static_cast(side_to_move_); - const auto cs = static_cast(side); - if (!irreversible_data_.castling_rights[us].test(cs)) return false; - const auto obstacles = GetAllPieces() & ~SingleSquare(king_position_[us]) & - ~SingleSquare(rook_positions_[us][cs]); - return ((castling_squares_for_king_[us][cs] | - castling_squares_for_rook_[us][cs]) & + if (!irreversible_data_.castling_rights[side_to_move_].test( + std::to_underlying(side))) { + return false; + } + const auto obstacles = GetAllPieces() & ~SingleSquare(king_position_[side_to_move_]) & + ~SingleSquare(rook_positions_[side_to_move_][side]); + return ((castling_squares_for_king_[side_to_move_][side] | + castling_squares_for_rook_[side_to_move_][side]) & obstacles) .None(); } @@ -572,7 +580,7 @@ bool Position::IsPseudoLegal(const Move &move) { bool Position::IsLegal(const Move &move) const { return IsLegal( - move, irreversible_data_.blockers[static_cast(side_to_move_)]); + move, irreversible_data_.blockers[side_to_move_]); } bool Position::IsLegal(const Move &move, Bitboard blockers) const { @@ -582,7 +590,7 @@ bool Position::IsLegal(const Move &move, Bitboard blockers) const { const auto to = move.To(); if (move.IsCastling()) { return !IsUnderCheck() && - CanCastle(to == kKingCastlingDestination[static_cast(us)][0] + CanCastle(to == kKingCastlingDestination[us][CastlingSide::k00] ? CastlingSide::k00 : CastlingSide::k000); } @@ -611,34 +619,33 @@ bool Position::IsLegal(const Move &move, Bitboard blockers) const { [[nodiscard]] bool Position::CanCastle( const CastlingSide castling_side) const { const auto us = side_to_move_; - const auto us_idx = static_cast(us); - const auto cs_idx = static_cast(castling_side); - - if (!irreversible_data_.castling_rights[us_idx].test(cs_idx)) return false; + if (!irreversible_data_.castling_rights[us].test( + std::to_underlying(castling_side))) { + return false; + } - const auto king_position = king_position_[us_idx]; - const auto rook_position = rook_positions_[us_idx][cs_idx]; + const auto king_position = king_position_[us]; + const auto rook_position = rook_positions_[us][castling_side]; const auto obstacles = GetAllPieces() & ~SingleSquare(king_position) & ~SingleSquare(rook_position); - const auto king_path = castling_squares_for_king_[us_idx][cs_idx]; + const auto king_path = castling_squares_for_king_[us][castling_side]; - if (((king_path | castling_squares_for_rook_[us_idx][cs_idx]) & obstacles) + if (((king_path | castling_squares_for_rook_[us][castling_side]) & obstacles) .Any()) return false; for (const auto square : king_path) { - if (IsUnderAttack(square, us)) - return false; + if (IsUnderAttack(square, us)) return false; } return true; } void Position::SetCastlingRights( - const std::array, 2> &castling_rights) { - for (size_t color = 0; color < kColors; ++color) { + const ByPlayer> &castling_rights) { + for (const auto color : kPlayers) { hash_ ^= kZobristKeys .cr_hash[color] [irreversible_data_.castling_rights[color].to_ulong()]; @@ -663,40 +670,40 @@ void Position::SetEnCroissantSquare(std::optional square) { } } -void Position::SetKingPositions(const std::array &king_position) { +void Position::SetKingPositions(const ByPlayer &king_position) { king_position_ = king_position; } void Position::SetRookPositions( - const std::array, kColors> &rook_positions) { + const ByPlayer> &rook_positions) { rook_positions_ = rook_positions; } void Position::SetCastlingSquares( - const std::array, kColors> &cs_king, - const std::array, kColors> &cs_rook) { + const ByPlayer> &cs_king, + const ByPlayer> &cs_rook) { castling_squares_for_king_ = cs_king; castling_squares_for_rook_ = cs_rook; } Bitboard Position::GetAllPieces() const { - return pieces_by_color_[static_cast(Player::kWhite)] | - pieces_by_color_[static_cast(Player::kBlack)]; + return pieces_by_color_[Player::kWhite] | + pieces_by_color_[Player::kBlack]; } bool Position::IsInsufficientMaterial() const { constexpr Bitboard kDarkSquares{0xAA55AA55AA55AA55ULL}; constexpr Bitboard kLightSquares{0x55AA55AA55AA55AAULL}; - if (pieces_by_type_[static_cast(Piece::kPawn)].Any() || - pieces_by_type_[static_cast(Piece::kRook)].Any() || - pieces_by_type_[static_cast(Piece::kQueen)].Any()) { + if (pieces_by_type_[Piece::kPawn].Any() || + pieces_by_type_[Piece::kRook].Any() || + pieces_by_type_[Piece::kQueen].Any()) { return false; } const auto knights = - pieces_by_type_[static_cast(Piece::kKnight)]; - const auto bishops = pieces_by_type_[static_cast(Piece::kBishop)]; + pieces_by_type_[Piece::kKnight]; + const auto bishops = pieces_by_type_[Piece::kBishop]; if (knights.Any()) { return bishops.None() && !knights.MoreThanOne(); @@ -707,20 +714,20 @@ bool Position::IsInsufficientMaterial() const { } const Bitboard &Position::GetPieces(const Player player) const { - return pieces_by_color_[static_cast(player)]; + return pieces_by_color_[player]; } template Bitboard Position::GetPiecesByType(const Player player) const { - return pieces_by_color_[static_cast(player)] & - pieces_by_type_[static_cast(piece)]; + return pieces_by_color_[player] & + pieces_by_type_[piece]; } + Bitboard Position::GetAllPawnAttacks(const Player player) const { - const auto us = static_cast(player); const auto pawns = GetPiecesByType(player); - return Shift(pawns, kPawnAttackDirections[us][0]) | - Shift(pawns, kPawnAttackDirections[us][1]); + return Shift(pawns, kPawnAttackDirections[player][0]) | + Shift(pawns, kPawnAttackDirections[player][1]); } Piece Position::GetPieceAt(const BitIndex index) const { @@ -729,14 +736,15 @@ Piece Position::GetPieceAt(const BitIndex index) const { } BitIndex Position::GetKingSquare(const Player player) const { - return king_position_[static_cast(player)]; + return king_position_[player]; } + bool Position::IsUnderAttack(const BitIndex square, const Player us, const Bitboard transparent) const { assert(IsOk(square)); return (Attackers(square, transparent) & - pieces_by_color_[static_cast(Flip(us))]) + pieces_by_color_[Flip(us)]) .Any(); } @@ -753,8 +761,7 @@ bool Position::HasLegalKings() const { } Eval Position::EstimatePiece(const Piece piece) const { - const auto piece_type_idx = static_cast(piece); - return kPieceValues[piece_type_idx](evaluation_data_.non_pawn_material); + return kPieceValues[piece](evaluation_data_.non_pawn_material); } bool Position::StaticExchangeEvaluation(const Move &move, @@ -799,18 +806,18 @@ bool Position::StaticExchangeEvaluation(const Move &move, Bitboard occupancy = GetAllPieces() ^ SingleSquare(from) ^ SingleSquare(to); [[unlikely]] if (move.IsEnPassant()) { - occupancy ^= Shift(SingleSquare(to), kPawnMoveDirection[static_cast(them)]); + occupancy ^= Shift(SingleSquare(to), kPawnMoveDirection[them]); } Bitboard attackers = Attackers(to, ~occupancy) & occupancy; auto color = them; - auto diagonal_xray = pieces_by_type_[static_cast(Piece::kBishop)] | - pieces_by_type_[static_cast(Piece::kQueen)]; + auto diagonal_xray = pieces_by_type_[Piece::kBishop] | + pieces_by_type_[Piece::kQueen]; - auto straight_xray = pieces_by_type_[static_cast(Piece::kRook)] | - pieces_by_type_[static_cast(Piece::kQueen)]; + auto straight_xray = pieces_by_type_[Piece::kRook] | + pieces_by_type_[Piece::kQueen]; for (;;) { Bitboard our_attackers = attackers & GetPieces(color); @@ -819,9 +826,8 @@ bool Position::StaticExchangeEvaluation(const Move &move, } ComputePins(color); - const auto color_idx = static_cast(color); - if ((irreversible_data_.pinners[color_idx] & occupancy).Any()) { - our_attackers &= ~irreversible_data_.blockers[color_idx]; + if ((irreversible_data_.pinners[color] & occupancy).Any()) { + our_attackers &= ~irreversible_data_.blockers[color]; if (our_attackers.None()) { break; } @@ -831,11 +837,10 @@ bool Position::StaticExchangeEvaluation(const Move &move, next_victim = Piece::kKing; - for (size_t attacker_idx = static_cast(Piece::kPawn); - attacker_idx <= static_cast(Piece::kQueen); ++attacker_idx) { - if (attacker_bitboard = our_attackers & pieces_by_type_[attacker_idx]; + for (const auto attacker : kPiecesByValue) { + if (attacker_bitboard = our_attackers & pieces_by_type_[attacker]; attacker_bitboard.Any()) { - next_victim = static_cast(attacker_idx); + next_victim = attacker; break; } } @@ -875,7 +880,7 @@ const std::optional &Position::GetEnCroissantSquare() const { return irreversible_data_.en_croissant_square; } -const std::array, kColors> &Position::GetCastlingRights() const { +const ByPlayer> &Position::GetCastlingRights() const { return irreversible_data_.castling_rights; } @@ -888,27 +893,26 @@ Bitboard Position::Attackers(const BitIndex square, (GetPawnAttacks(square, Player::kBlack) & GetPiecesByType(Player::kWhite)) | (AttackTable::GetAttackMap(square, occupancy) & - pieces_by_type_[static_cast(Piece::kKnight)]) | + pieces_by_type_[Piece::kKnight]) | (AttackTable::GetAttackMap(square, occupancy) & - pieces_by_type_[static_cast(Piece::kBishop)]) | + pieces_by_type_[Piece::kBishop]) | (AttackTable::GetAttackMap(square, occupancy) & - pieces_by_type_[static_cast(Piece::kRook)]) | + pieces_by_type_[Piece::kRook]) | (AttackTable::GetAttackMap(square, occupancy) & - pieces_by_type_[static_cast(Piece::kQueen)]) | + pieces_by_type_[Piece::kQueen]) | (AttackTable::GetAttackMap(square, occupancy) & - pieces_by_type_[static_cast(Piece::kKing)]); + pieces_by_type_[Piece::kKing]); } void Position::ComputePins(const Player us) const { const Player them = Flip(us); - const auto us_idx = static_cast(us); - if (irreversible_data_.pins_valid[us_idx]) { + if (irreversible_data_.pins_valid[us]) { return; } - irreversible_data_.blockers[us_idx] = kEmptyBoard; - irreversible_data_.pinners[us_idx] = kEmptyBoard; + irreversible_data_.blockers[us] = kEmptyBoard; + irreversible_data_.pinners[us] = kEmptyBoard; const BitIndex king_square = GetKingSquare(us); @@ -924,13 +928,13 @@ void Position::ComputePins(const Player us) const { for (const auto square : snipers) { const Bitboard blockers_between = Between(king_square, square) & occupancy; if (blockers_between.Any() && !blockers_between.MoreThanOne()) { - irreversible_data_.blockers[us_idx] |= blockers_between; + irreversible_data_.blockers[us] |= blockers_between; if ((blockers_between & GetPieces(us)).Any()) { - irreversible_data_.pinners[us_idx] |= SingleSquare(square); + irreversible_data_.pinners[us] |= SingleSquare(square); } } } - irreversible_data_.pins_valid[us_idx] = true; + irreversible_data_.pins_valid[us] = true; } Position::IrreversibleData Position::GetIrreversibleData() const { diff --git a/Chess/Position.h b/Chess/Position.h index b9fc66b..bf5c113 100644 --- a/Chess/Position.h +++ b/Chess/Position.h @@ -41,12 +41,9 @@ class Position { bool operator==(const EvaluationData &) const = default; Eval non_pawn_material{}; //!< Total material value excluding pawns. - std::array - material{}; //!< Material value for each color. - std::array - psqt{}; //!< Piece-square table scores for each color. - std::array, kColors> - piece_counts{}; + ByPlayer material{}; //!< Material value for each color. + ByPlayer psqt{}; //!< Piece-square table scores for each color. + ByPlayer> piece_counts{}; }; /** @@ -59,17 +56,14 @@ class Position { std::optional en_croissant_square{}; //!< Optional square for en passant. - std::array, kColors> - castling_rights{}; //!< Castling rights for each color. + ByPlayer> castling_rights{}; //!< Castling rights for each color. - mutable std::array - pinners{}; //!< Enemy sliders pinning this color's pieces to its king. - mutable std::array - blockers{}; //!< Pieces that are blocking attacks on the king. + mutable ByPlayer pinners{}; //!< Enemy sliders pinning this color's pieces to its king. + mutable ByPlayer blockers{}; //!< Pieces that are blocking attacks on the king. Piece captured_piece{Piece::kNone}; //!< Piece captured by the last move - mutable std::array pins_valid{}; + mutable ByPlayer pins_valid{}; bool operator==(const IrreversibleData &other) const { return std::tie(en_croissant_square, castling_rights, captured_piece) == @@ -194,8 +188,8 @@ class Position { [[nodiscard]] Bitboard GetPiecesOf(const Player player, const Piece piece) const { - return pieces_by_color_[static_cast(player)] & - pieces_by_type_[static_cast(piece)]; + return pieces_by_color_[player] & + pieces_by_type_[piece]; } /** @@ -268,8 +262,7 @@ class Position { [[nodiscard]] const std::optional &GetEnCroissantSquare() const; - [[nodiscard]] const std::array, kColors> &GetCastlingRights() - const; + [[nodiscard]] const ByPlayer> &GetCastlingRights() const; [[nodiscard]] IrreversibleData GetIrreversibleData() const; @@ -336,18 +329,18 @@ class Position { [[nodiscard]] bool VerifyPinCache() const; - void SetCastlingRights(const std::array, 2> &castling_rights); + void SetCastlingRights(const ByPlayer> &castling_rights); void SetEnCroissantSquare(std::optional square); - void SetKingPositions(const std::array &king_position); + void SetKingPositions(const ByPlayer &king_position); void SetRookPositions( - const std::array, kColors> &rook_positions); + const ByPlayer> &rook_positions); void SetCastlingSquares( - const std::array, kColors> &cs_king, - const std::array, kColors> &cs_rook); + const ByPlayer> &cs_king, + const ByPlayer> &cs_rook); [[nodiscard]] Eval EstimatePiece(Piece piece) const; @@ -362,19 +355,17 @@ class Position { Player side_to_move_{}; //!< Whose side to move. - std::array - pieces_by_type_{}; //!< Bitboard of pieces of certain type - std::array - pieces_by_color_{}; //!< Bitboard of pieces for each player + ByPiece pieces_by_type_{}; //!< Bitboard of pieces of certain type + ByPlayer pieces_by_color_{}; //!< Bitboard of pieces for each player std::array board_{}; //!< Current position of pieces - std::array king_position_{}; - std::array, kColors> + ByPlayer king_position_{}; + ByPlayer> rook_positions_{}; // doesn't need to be updated - std::array, kColors> castling_squares_for_king_{}; - std::array, kColors> castling_squares_for_rook_{}; + ByPlayer> castling_squares_for_king_{}; + ByPlayer> castling_squares_for_rook_{}; Hash hash_{}; diff --git a/Chess/PositionFactory.h b/Chess/PositionFactory.h index a909b4e..9e7b386 100644 --- a/Chess/PositionFactory.h +++ b/Chess/PositionFactory.h @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -29,8 +30,8 @@ struct PositionFactory { static constexpr int kMaxPiecesPerSide = 16; static constexpr int kMaxPawnsPerSide = 8; - using CastlingRightsBySide = std::array, kColors>; - using RookSquares = std::array, 2>, kColors>; + using CastlingRightsBySide = ByPlayer>; + using RookSquares = ByPlayer>>; struct Fields { std::string board; @@ -42,8 +43,8 @@ struct PositionFactory { }; struct Placement { - std::array kings{}; - std::array, kColors> back_rank_rooks{}; + ByPlayer kings{}; + ByPlayer> back_rank_rooks{}; }; [[nodiscard]] static constexpr Rank BackRank(Player color) { @@ -90,9 +91,9 @@ inline std::optional PositionFactory::Split( inline std::optional PositionFactory::PlacePieces( std::string_view board, Position &position) { Placement placement; - std::array kings{}; - std::array pawns{}; - std::array pieces{}; + ByPlayer kings{}; + ByPlayer pawns{}; + ByPlayer pieces{}; Rank rank = kRanks - 1; File file = 0; @@ -112,27 +113,26 @@ inline std::optional PositionFactory::PlacePieces( const auto entry = kCharToPiece.find(symbol); if (entry == kCharToPiece.end() || file == kFiles) return std::nullopt; const auto [piece, color] = entry->second; - const auto us = static_cast(color); const auto square = GetSquareIndex(file, rank); - if (++pieces[us] > kMaxPiecesPerSide) return std::nullopt; + if (++pieces[color] > kMaxPiecesPerSide) return std::nullopt; if (piece == Piece::kKing) { - if (++kings[us] > 1) return std::nullopt; - placement.kings[us] = square; + if (++kings[color] > 1) return std::nullopt; + placement.kings[color] = square; } - if (piece == Piece::kPawn && - (rank == 0 || rank == kRanks - 1 || ++pawns[us] > kMaxPawnsPerSide)) { + if (piece == Piece::kPawn && (rank == 0 || rank == kRanks - 1 || + ++pawns[color] > kMaxPawnsPerSide)) { return std::nullopt; } if (piece == Piece::kRook && rank == BackRank(color)) { - placement.back_rank_rooks[us][file] = true; + placement.back_rank_rooks[color][file] = true; } position.PlacePiece(square, piece, color); ++file; } - if (rank != 0 || file != kFiles || kings != std::array{1, 1}) { + if (rank != 0 || file != kFiles || kings != ByPlayer{{1, 1}}) { return std::nullopt; } return placement; @@ -148,20 +148,19 @@ inline std::optional PositionFactory::ParseSideToMove( inline PositionFactory::RookSquares PositionFactory::FindCastlingRooks( const Placement &placement) { RookSquares rooks{}; - for (const auto color : {Player::kWhite, Player::kBlack}) { - const auto us = static_cast(color); - const auto &back_rank_rooks = placement.back_rank_rooks[us]; - const auto king_file = static_cast(placement.kings[us] % kFiles); + for (const auto color : kPlayers) { + const auto &back_rank_rooks = placement.back_rank_rooks[color]; + const auto king_file = static_cast(placement.kings[color] % kFiles); for (File file = 0; file < king_file; ++file) { if (back_rank_rooks[file]) { - rooks[us][static_cast(CastlingSide::k000)] = + rooks[color][CastlingSide::k000] = GetSquareIndex(file, BackRank(color)); break; } } for (File file = kFiles - 1; file > king_file; --file) { if (back_rank_rooks[file]) { - rooks[us][static_cast(CastlingSide::k00)] = + rooks[color][CastlingSide::k00] = GetSquareIndex(file, BackRank(color)); break; } @@ -190,14 +189,13 @@ PositionFactory::ParseCastlingRights(std::string_view text, const auto color = index < 2 ? Player::kWhite : Player::kBlack; const auto side = index % 2 == 0 ? CastlingSide::k00 : CastlingSide::k000; - const auto us = static_cast(color); - const auto bit = static_cast(side); + const auto bit = std::to_underlying(side); const bool king_on_back_rank = - placement.kings[us] / kFiles == BackRank(color); - if (rights[us].test(bit) || !king_on_back_rank || !rooks[us][bit]) { + placement.kings[color] / kFiles == BackRank(color); + if (rights[color].test(bit) || !king_on_back_rank || !rooks[color][side]) { return std::nullopt; } - rights[us].set(bit); + rights[color].set(bit); } return rights; } @@ -267,24 +265,20 @@ inline std::optional PositionFactory::TryParse( if (!halfmove_clock || !fullmove_number) return std::nullopt; const auto &kings = placement->kings; - std::array, kColors> rook_squares{}; - for (size_t us = 0; us < kColors; ++us) { - for (size_t side = 0; side < 2; ++side) { - rook_squares[us][side] = rooks[us][side].value_or(BitIndex{0}); + ByPlayer> rook_squares{}; + ByPlayer> cs_king{}; + ByPlayer> cs_rook{}; + for (const auto color : kPlayers) { + for (const auto side : kCastlingSides) { + rook_squares[color][side] = rooks[color][side].value_or(BitIndex{0}); + cs_king[color][side] = + RookBetween(kings[color], kKingCastlingDestination[color][side]); + cs_rook[color][side] = RookBetween(rook_squares[color][side], + kRookCastlingDestination[color][side]); } } position.SetKingPositions(kings); position.SetRookPositions(rook_squares); - std::array, kColors> cs_king = { - {{RookBetween(kings[0], kKingCastlingDestination[0][0]), - RookBetween(kings[0], kKingCastlingDestination[0][1])}, - {RookBetween(kings[1], kKingCastlingDestination[1][0]), - RookBetween(kings[1], kKingCastlingDestination[1][1])}}}; - std::array, kColors> cs_rook = { - {{RookBetween(rook_squares[0][0], kRookCastlingDestination[0][0]), - RookBetween(rook_squares[0][1], kRookCastlingDestination[0][1])}, - {RookBetween(rook_squares[1][0], kRookCastlingDestination[1][0]), - RookBetween(rook_squares[1][1], kRookCastlingDestination[1][1])}}}; position.SetCastlingSquares(cs_king, cs_rook); position.Init(*halfmove_clock, std::max(*fullmove_number, 1)); @@ -326,25 +320,24 @@ inline std::string SimpleChessEngine::FenFactory::operator()( const auto castling_rights = position.GetCastlingRights(); - if (castling_rights[static_cast(Player::kWhite)].test( - static_cast(CastlingSide::k00))) { + if (castling_rights[Player::kWhite].test( + std::to_underlying(CastlingSide::k00))) { ss << 'K'; } - if (castling_rights[static_cast(Player::kWhite)].test( - static_cast(CastlingSide::k000))) { + if (castling_rights[Player::kWhite].test( + std::to_underlying(CastlingSide::k000))) { ss << 'Q'; } - if (castling_rights[static_cast(Player::kBlack)].test( - static_cast(CastlingSide::k00))) { + if (castling_rights[Player::kBlack].test( + std::to_underlying(CastlingSide::k00))) { ss << 'k'; } - if (castling_rights[static_cast(Player::kBlack)].test( - static_cast(CastlingSide::k000))) { + if (castling_rights[Player::kBlack].test( + std::to_underlying(CastlingSide::k000))) { ss << 'q'; } - if ((castling_rights[static_cast(Player::kWhite)] | - castling_rights[static_cast(Player::kBlack)]) + if ((castling_rights[Player::kWhite] | castling_rights[Player::kBlack]) .none()) { ss << '-'; } diff --git a/Chess/Score.h b/Chess/Score.h index 8f8d4a1..44a0770 100644 --- a/Chess/Score.h +++ b/Chess/Score.h @@ -56,7 +56,7 @@ class SfMargin { public: static constexpr Eval kStockfishPawn = 208; static constexpr Eval kEnginePawn = - kPieceValues[static_cast(Piece::kPawn)] + kPieceValues[Piece::kPawn] .eval[static_cast(GamePhase::kMiddleGame)]; static constexpr double kPerEngineUnit = static_cast(kStockfishPawn) / kEnginePawn; diff --git a/Chess/Searcher.h b/Chess/Searcher.h index 9f3ba37..f97265e 100644 --- a/Chess/Searcher.h +++ b/Chess/Searcher.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -131,7 +132,7 @@ class Searcher { [[nodiscard]] const auto &GetKillers() const { return killers_; } [[nodiscard]] const auto &GetHistory() const { return history_; } [[nodiscard]] const auto &GetContinuationHistory() const { - return continuation_history_; + return *continuation_history_; } [[nodiscard]] std::int64_t GetQuietScore(const Move &move, Depth ply) const; [[nodiscard]] std::uint64_t GetRootEffort(const Move &move) const; @@ -151,10 +152,8 @@ class Searcher { std::shared_ptr best_moves_; //!< Shared transposition table used by Lazy SMP workers. std::shared_ptr tablebase_; - std::array< - std::array, kBoardArea + 1>, - kColors> - history_ = {}; + ByPlayer, kBoardArea + 1>> + history_{}; KillerTable<2> killers_; struct PieceTo { @@ -169,14 +168,15 @@ class Searcher { std::optional parent_eval; }; static constexpr std::int64_t kHistoryMax = 16384; - static constexpr size_t kPieceToSize = kPieceTypes * (kBoardArea + 1); static constexpr std::array kContinuationOffsets = {1, 2}; [[nodiscard]] static std::int64_t HistoryBonus(Depth depth); - [[nodiscard]] static constexpr std::int64_t StaticEvalHistoryBonus( - Eval parent_eval, Eval child_eval); - [[nodiscard]] static size_t ContinuationIndex(PieceTo previous, - PieceTo current); + [[nodiscard]] static constexpr std::int64_t StaticEvalHistoryBonus(Eval parent_eval, + Eval child_eval); + [[nodiscard]] static auto &ContinuationEntry(auto &history, PieceTo previous, + PieceTo current) { + return history[previous.piece][previous.to][current.piece][current.to]; + } [[nodiscard]] PieceTo GetPieceTo(const Move &move) const; void SetPlayedMove(Depth ply, const Move &move, std::optional parent_eval); @@ -186,8 +186,11 @@ class Searcher { void AddRootEffort(const Move &move, std::uint64_t nodes, std::optional score); - std::vector continuation_history_ = - std::vector(kPieceToSize * kPieceToSize); + template + using PieceToHistory = ByPiece>; + using ContinuationHistory = PieceToHistory>; + std::unique_ptr continuation_history_ = + std::make_unique(); std::array move_stack_{}; StaticEvalHistory static_evals_; @@ -242,15 +245,6 @@ inline std::int64_t Searcher::HistoryBonus(const Depth depth) { 50, 1500); } -inline size_t Searcher::ContinuationIndex(const PieceTo previous, - const PieceTo current) { - const auto flatten = [](const PieceTo piece_to) { - return static_cast(piece_to.piece) * (kBoardArea + 1) + - static_cast(piece_to.to); - }; - return flatten(previous) * kPieceToSize + flatten(current); -} - inline Searcher::PieceTo Searcher::GetPieceTo(const Move &move) const { return {current_position_.GetPieceAt(move.From()), move.To()}; } @@ -284,21 +278,21 @@ inline void Searcher::UpdateStaticEvalHistory(const Depth ply, if (!previous.quiet || !previous.parent_eval || !previous.move.IsValid()) return; const auto bonus = StaticEvalHistoryBonus(*previous.parent_eval, child_eval); - auto &entry = history_[static_cast(previous.side)] - [previous.move.From()][previous.move.To()]; + auto &entry = + history_[previous.side][previous.move.From()][previous.move.To()]; entry += bonus - entry * std::abs(bonus) / kHistoryMax; } inline std::int64_t Searcher::GetQuietScore(const Move &move, const Depth ply) const { - const auto side = static_cast(current_position_.GetSideToMove()); + const auto side = current_position_.GetSideToMove(); std::int64_t score = history_[side][move.From()][move.To()]; const auto current = GetPieceTo(move); for (const auto offset : kContinuationOffsets) { if (ply < offset) break; const auto previous = move_stack_[ply - offset].piece_to; if (previous.piece == Piece::kNone) continue; - score += continuation_history_[ContinuationIndex(previous, current)]; + score += ContinuationEntry(*continuation_history_, previous, current); } return score; } @@ -309,14 +303,14 @@ inline void Searcher::UpdateQuietHistory(const Move &move, const Depth ply, entry += static_cast>( bonus - entry * std::abs(bonus) / kHistoryMax); }; - const auto side = static_cast(current_position_.GetSideToMove()); + const auto side = current_position_.GetSideToMove(); apply(history_[side][move.From()][move.To()]); const auto current = GetPieceTo(move); for (const auto offset : kContinuationOffsets) { if (ply < offset) break; const auto previous = move_stack_[ply - offset].piece_to; if (previous.piece == Piece::kNone) continue; - apply(continuation_history_[ContinuationIndex(previous, current)]); + apply(ContinuationEntry(*continuation_history_, previous, current)); } } @@ -360,7 +354,7 @@ inline void Searcher::InitStartOfSearch() { inline void Searcher::ClearHistories() { history_ = {}; - std::ranges::fill(continuation_history_, 0); + *continuation_history_ = {}; } template diff --git a/Chess/Settings.h b/Chess/Settings.h index 2171e7e..c9c4695 100644 --- a/Chess/Settings.h +++ b/Chess/Settings.h @@ -10,16 +10,15 @@ namespace SimpleChessEngine { struct Settings { struct EvaluationParameters { - inline static std::array mobility = [] { - std::array values{}; - values[static_cast(Piece::kKnight)] = TaperedEval{{4, 2}}; - values[static_cast(Piece::kBishop)] = TaperedEval{{7, 3}}; - values[static_cast(Piece::kRook)] = TaperedEval{{2, 4}}; - values[static_cast(Piece::kQueen)] = TaperedEval{{2, 2}}; + inline static ByPiece mobility = [] { + ByPiece values{}; + values[Piece::kKnight] = TaperedEval{{4, 2}}; + values[Piece::kBishop] = TaperedEval{{7, 3}}; + values[Piece::kRook] = TaperedEval{{2, 4}}; + values[Piece::kQueen] = TaperedEval{{2, 2}}; return values; }(); - inline static std::array, 8>, - kPieceTypes> + inline static ByPiece, 8>> psqt_adjustment{}; inline static TaperedEval doubled_pawn{{-15, -15}}; inline static TaperedEval isolated_pawn{{-10, -10}}; @@ -48,11 +47,11 @@ struct Settings { }; return values; }(); - inline static std::array material_value = [] { + inline static ByPiece material_value = [] { auto values = kPieceValues; - values[static_cast(Piece::kKnight)] + values[Piece::kKnight] .eval[static_cast(GamePhase::kEndGame)] = 275; - values[static_cast(Piece::kBishop)] + values[Piece::kBishop] .eval[static_cast(GamePhase::kMiddleGame)] = 375; return values; }(); @@ -62,12 +61,12 @@ struct Settings { inline static Eval king_open_file = -14; inline static Eval king_pawn_storm_near = -12; inline static Eval king_pawn_storm_far = -8; - inline static std::array king_attack = [] { - std::array values{}; - values[static_cast(Piece::kKnight)] = 8; - values[static_cast(Piece::kBishop)] = 10; - values[static_cast(Piece::kRook)] = 18; - values[static_cast(Piece::kQueen)] = 20; + inline static ByPiece king_attack = [] { + ByPiece values{}; + values[Piece::kKnight] = 8; + values[Piece::kBishop] = 10; + values[Piece::kRook] = 18; + values[Piece::kQueen] = 20; return values; }(); inline static bool pawns_enabled = true; @@ -104,13 +103,13 @@ struct Settings { } static void SetMaterialValue(Piece piece, GamePhase phase, Eval value) { - material_value[static_cast(piece)] + material_value[piece] .eval[static_cast(phase)] = value; material_enabled = material_value != kPieceValues; } static void SetMobility(Piece piece, GamePhase phase, Eval value) { - mobility[static_cast(piece)].eval[static_cast(phase)] = + mobility[piece].eval[static_cast(phase)] = value; mobility_enabled = false; for (const auto& weight : mobility) { @@ -121,7 +120,7 @@ struct Settings { static void SetPsqtAdjustment(Piece piece, size_t relative_rank, size_t mirrored_file, GamePhase phase, Eval value) { - psqt_adjustment[static_cast(piece)][relative_rank][mirrored_file] + psqt_adjustment[piece][relative_rank][mirrored_file] .eval[static_cast(phase)] = value; psqt_adjustment_enabled = false; for (const auto& piece_values : psqt_adjustment) { @@ -167,7 +166,7 @@ struct Settings { static void SetKingAttack(Eval value) { static_assert(piece == Piece::kKnight || piece == Piece::kBishop || piece == Piece::kRook || piece == Piece::kQueen); - king_attack[static_cast(piece)] = value; + king_attack[piece] = value; RefreshKingSafetyEnabled(); } diff --git a/Chess/StreamUtility.h b/Chess/StreamUtility.h index af150e5..92ce4d3 100644 --- a/Chess/StreamUtility.h +++ b/Chess/StreamUtility.h @@ -22,10 +22,10 @@ inline static std::unordered_map> kCharToPiece = {'k', {Piece::kKing, Player::kBlack}}, {'K', {Piece::kKing, Player::kWhite}}}; -inline constexpr std::array kPiecesChars = {' ', 'p', 'n', 'b', 'r', 'q', 'k'}; +inline constexpr ByPiece kPiecesChars = {{' ', 'p', 'n', 'b', 'r', 'q', 'k'}}; inline char GetPieceChar(Piece piece, Player color) { - char piece_name = kPiecesChars[static_cast(piece)]; + char piece_name = kPiecesChars[piece]; return color == Player::kWhite ? toupper(piece_name) : piece_name; } @@ -57,7 +57,7 @@ inline std::ostream& operator<<(std::ostream& stream, const Move& move) { PrintCoordinates(to, stream); if (move.IsPromotion()) { - stream << kPiecesChars[static_cast(move.PromotionPiece())]; + stream << kPiecesChars[move.PromotionPiece()]; } return stream; diff --git a/Chess/SyzygyTablebase.cpp b/Chess/SyzygyTablebase.cpp index 7217718..cfd44e2 100644 --- a/Chess/SyzygyTablebase.cpp +++ b/Chess/SyzygyTablebase.cpp @@ -54,8 +54,8 @@ struct FathomPosition { result.rule50 = static_cast(std::min( position.GetHalfMoveClock(), std::numeric_limits::max())); const auto& rights = position.GetCastlingRights(); - result.castling = rights[static_cast(Player::kWhite)].any() || - rights[static_cast(Player::kBlack)].any() + result.castling = rights[Player::kWhite].any() || + rights[Player::kBlack].any() ? 1U : 0U; result.ep = position.GetEnCroissantSquare().has_value() @@ -131,8 +131,8 @@ bool Syzygy::CanProbe(const Position& position) const { if (position.GetAllPieces().Count() > max_pieces_) return false; if (!position.HasLegalKings()) return false; const auto& rights = position.GetCastlingRights(); - return rights[static_cast(Player::kWhite)].none() && - rights[static_cast(Player::kBlack)].none(); + return rights[Player::kWhite].none() && + rights[Player::kBlack].none(); } std::optional Syzygy::Probe(const Position& position) const { diff --git a/Chess/UciCommunicator.h b/Chess/UciCommunicator.h index ceb5626..4e0d073 100644 --- a/Chess/UciCommunicator.h +++ b/Chess/UciCommunicator.h @@ -30,11 +30,9 @@ namespace SimpleChessEngine { struct TournamentTime { - std::array player_time = { - std::chrono::milliseconds{0}, std::chrono::milliseconds{0}}; + ByPlayer player_time{}; - std::array player_inc = { - std::chrono::milliseconds{0}, std::chrono::milliseconds{0}}; + ByPlayer player_inc{}; std::optional moves_to_go; }; @@ -110,11 +108,10 @@ class SearchThread { constexpr double kSingleMoveTime = 500; const auto side = info.position.GetSideToMove(); - const auto side_idx = static_cast(side); const double time = - static_cast(tournament->player_time[side_idx].count()); + static_cast(tournament->player_time[side].count()); const double inc = - static_cast(tournament->player_inc[side_idx].count()); + static_cast(tournament->player_inc[side].count()); const double ply = 2.0 * (static_cast(info.position.GetFullMoveNumber()) - 1.0) + (side == Player::kBlack ? 1.0 : 0.0); @@ -460,21 +457,19 @@ struct EngineOptions { StringOption* tablebase_path_{}; StringOption* eval_file_{}; void AddPsqtAdjustmentOptions() { - constexpr std::array piece_names = {"Knight", "Bishop", "Rook", "Queen", - "King"}; - for (size_t piece_offset = 0; piece_offset < piece_names.size(); - ++piece_offset) { - const auto piece = static_cast( - static_cast(Piece::kKnight) + piece_offset); + constexpr std::array piece_names{ + std::pair{Piece::kKnight, "Knight"}, std::pair{Piece::kBishop, "Bishop"}, + std::pair{Piece::kRook, "Rook"}, std::pair{Piece::kQueen, "Queen"}, + std::pair{Piece::kKing, "King"}}; + for (const auto& [piece, name] : piece_names) { for (size_t rank = 0; rank < 8; ++rank) { for (size_t file = 0; file < 4; ++file) { const std::string square = std::string{static_cast('A' + file)} + std::to_string(rank + 1); - const auto piece_index = static_cast(piece); options.emplace_back(std::make_unique( - std::string{piece_names[piece_offset]} + "PSQT" + square + "MG", - Settings::EvaluationParameters::psqt_adjustment[piece_index][rank] + std::string{name} + "PSQT" + square + "MG", + Settings::EvaluationParameters::psqt_adjustment[piece][rank] [file] .eval[0], -100, 100, [piece, rank, file](const int value) { @@ -482,8 +477,8 @@ struct EngineOptions { piece, rank, file, GamePhase::kMiddleGame, value); })); options.emplace_back(std::make_unique( - std::string{piece_names[piece_offset]} + "PSQT" + square + "EG", - Settings::EvaluationParameters::psqt_adjustment[piece_index][rank] + std::string{name} + "PSQT" + square + "EG", + Settings::EvaluationParameters::psqt_adjustment[piece][rank] [file] .eval[1], -100, 100, [piece, rank, file](const int value) { @@ -505,17 +500,16 @@ struct EngineOptions { template void AddMobilityOptions(const std::string& piece_name, const int minimum, const int maximum) { - constexpr auto piece_index = static_cast(piece); options.emplace_back(std::make_unique( piece_name + "MobilityMG", - Settings::EvaluationParameters::mobility[piece_index].eval[0], minimum, + Settings::EvaluationParameters::mobility[piece].eval[0], minimum, maximum, [](const int value) { Settings::EvaluationParameters::SetMobility( piece, GamePhase::kMiddleGame, value); })); options.emplace_back(std::make_unique( piece_name + "MobilityEG", - Settings::EvaluationParameters::mobility[piece_index].eval[1], minimum, + Settings::EvaluationParameters::mobility[piece].eval[1], minimum, maximum, [](const int value) { Settings::EvaluationParameters::SetMobility( piece, GamePhase::kEndGame, value); @@ -533,10 +527,9 @@ struct EngineOptions { template void AddMaterialValueOptions(const std::string& piece_name, const int minimum, const int maximum) { - constexpr auto piece_index = static_cast(piece); options.emplace_back(std::make_unique( piece_name + "ValueMG", - Settings::EvaluationParameters::material_value[piece_index] + Settings::EvaluationParameters::material_value[piece] .eval[static_cast(GamePhase::kMiddleGame)], minimum, maximum, [](const int value) { Settings::EvaluationParameters::SetMaterialValue( @@ -544,7 +537,7 @@ struct EngineOptions { })); options.emplace_back(std::make_unique( piece_name + "ValueEG", - Settings::EvaluationParameters::material_value[piece_index] + Settings::EvaluationParameters::material_value[piece] .eval[static_cast(GamePhase::kEndGame)], minimum, maximum, [](const int value) { Settings::EvaluationParameters::SetMaterialValue( @@ -669,7 +662,7 @@ struct EngineOptions { void AddKingAttackOption(const std::string& piece_name) { options.emplace_back(std::make_unique( piece_name + "KingAttackMG", - Settings::EvaluationParameters::king_attack[static_cast(piece)], + Settings::EvaluationParameters::king_attack[piece], 0, 50, [](const int value) { Settings::EvaluationParameters::SetKingAttack(value); })); @@ -1075,19 +1068,19 @@ inline void UciChessEngine::ParsePlayersTime(std::stringstream command) { std::size_t time; command >> time; if (token == "wtime") { - tournament_time.player_time[static_cast(kWhite)] = + tournament_time.player_time[kWhite] = std::chrono::milliseconds{time}; } if (token == "btime") { - tournament_time.player_time[static_cast(kBlack)] = + tournament_time.player_time[kBlack] = std::chrono::milliseconds{time}; } if (token == "winc") { - tournament_time.player_inc[static_cast(kWhite)] = + tournament_time.player_inc[kWhite] = std::chrono::milliseconds{time}; } if (token == "binc") { - tournament_time.player_inc[static_cast(kBlack)] = + tournament_time.player_inc[kBlack] = std::chrono::milliseconds{time}; } if (token == "movestogo" && time > 0) { diff --git a/Chess/Utility.h b/Chess/Utility.h index 22b46e9..9328601 100644 --- a/Chess/Utility.h +++ b/Chess/Utility.h @@ -11,6 +11,7 @@ #include #include "BitBoard.h" +#include "Move.h" #include "Piece.h" #include "Player.h" @@ -42,10 +43,10 @@ constexpr std::array kFileBB = {kFileA, kFileA << 1, kFileA << 2, kFileA << 3, kFileA << 4, kFileA << 5, kFileA << 6, kFileA << 7}; -constexpr std::array, kColors> - kKingCastlingDestination = {{{6, 2}, {62, 58}}}; -constexpr std::array, kColors> - kRookCastlingDestination = {{{5, 3}, {61, 59}}}; +constexpr ByPlayer> kKingCastlingDestination = { + {{{{{6, 2}}}, {{{62, 58}}}}}}; +constexpr ByPlayer> kRookCastlingDestination = { + {{{{{5, 3}}}, {{{61, 59}}}}}}; using Rank = std::int8_t; using File = std::int8_t; @@ -80,8 +81,8 @@ enum class CastlingRights : std::uint8_t { kAll = k00 | k000 }; -constexpr std::array kCastlingRightsForSide = {CastlingRights::k00, - CastlingRights::k000}; +constexpr ByCastlingSide kCastlingRightsForSide = { + {CastlingRights::k00, CastlingRights::k000}}; enum class Compass : std::int8_t { kNorth = kLineSize, @@ -127,23 +128,23 @@ constexpr Compass Invert(const Compass direction) { return square + static_cast(direction); } -constexpr std::array kPawnMoveDirection = {Compass::kNorth, Compass::kSouth}; -constexpr std::array, kColors> kPawnAttackDirections = { - {{Compass::kNorthWest, Compass::kNorthEast}, - {Compass::kSouthWest, Compass::kSouthEast}}}; +constexpr ByPlayer kPawnMoveDirection = { + {Compass::kNorth, Compass::kSouth}}; +constexpr ByPlayer> kPawnAttackDirections = { + {{{Compass::kNorthWest, Compass::kNorthEast}, + {Compass::kSouthWest, Compass::kSouthEast}}}}; struct PawnSpanTables { - std::array, kColors> front{}; - std::array, kColors> rear{}; - std::array, kColors> passed{}; + ByPlayer> front{}; + ByPlayer> rear{}; + ByPlayer> passed{}; std::array adjacent_files{}; }; consteval PawnSpanTables MakePawnSpanTables() { PawnSpanTables tables{}; - for (size_t side = 0; side < kColors; ++side) { - const int forward = - side == static_cast(Player::kWhite) ? 1 : -1; + for (const auto side : kPlayers) { + const int forward = side == Player::kWhite ? 1 : -1; for (size_t square = 0; square < kBoardArea; ++square) { const int file = static_cast(square % kLineSize); const int rank = static_cast(square / kLineSize); @@ -174,7 +175,7 @@ consteval PawnSpanTables MakePawnSpanTables() { tables.front[side][square] = Bitboard{front}; tables.rear[side][square] = Bitboard{rear}; tables.passed[side][square] = Bitboard{passed}; - if (side == 0) { + if (side == Player::kWhite) { tables.adjacent_files[square] = Bitboard{adjacent_files}; } } @@ -262,8 +263,8 @@ extern const GeometryTables kGeometry; } consteval auto MakePawnAttacks() { - std::array, kColors> attacks{}; - for (size_t color = 0; color < kColors; ++color) { + ByPlayer> attacks{}; + for (const auto color : kPlayers) { for (BitIndex square = 0; square < static_cast(kBoardArea); ++square) { for (const auto direction : kPawnAttackDirections[color]) { @@ -279,7 +280,7 @@ inline constexpr auto kPawnAttacks = MakePawnAttacks(); [[nodiscard]] constexpr Bitboard GetPawnAttacks(const BitIndex square, const Player side) { - return kPawnAttacks[static_cast(side)][square]; + return kPawnAttacks[side][square]; } [[nodiscard]] inline std::string DrawBitboard(const Bitboard b) { diff --git a/Tests/ConstantTableTests.cpp b/Tests/ConstantTableTests.cpp index d161c9f..0f48042 100644 --- a/Tests/ConstantTableTests.cpp +++ b/Tests/ConstantTableTests.cpp @@ -1,6 +1,8 @@ #include +#include #include +#include #include "Attacks.h" #include "Hasher.h" @@ -9,6 +11,14 @@ using namespace SimpleChessEngine; namespace { +static_assert(std::is_same_v>>); +static_assert(std::is_same_v< + decltype(kPSQT), + const ByPlayer>>>); +static_assert(std::is_same_v>>>); + constexpr std::array kLegacyKing = {770ull, 1797ull, 3594ull, @@ -188,8 +198,7 @@ TEST(ConstantTables, PawnsMatchOriginalGenerator) { for (auto color : {Player::kWhite, Player::kBlack}) { for (BitIndex square = 0; square < 64; ++square) { Bitboard expected{}; - for (const auto direction : - kPawnAttackDirections[static_cast(color)]) { + for (const auto direction : kPawnAttackDirections[color]) { expected |= GetShiftIfValid(square, direction).value_or(Bitboard{}); } EXPECT_EQ(GetPawnAttacks(square, color), expected); @@ -198,11 +207,13 @@ TEST(ConstantTables, PawnsMatchOriginalGenerator) { } TEST(ConstantTables, PsqtMatchesOriginalMirror) { - for (size_t piece = 0; piece < kPieceTypes; ++piece) { + for (const auto piece : + {Piece::kNone, Piece::kPawn, Piece::kKnight, Piece::kBishop, + Piece::kRook, Piece::kQueen, Piece::kKing}) { for (BitIndex square = 0; square < 64; ++square) { const auto [file, rank] = GetCoordinates(square); - EXPECT_EQ(kPSQT[1][piece][GetSquareIndex(file, 7 - rank)], - kPSQT[0][piece][square]); + EXPECT_EQ(kPSQT[Player::kBlack][piece][GetSquareIndex(file, 7 - rank)], + kPSQT[Player::kWhite][piece][square]); } } } diff --git a/Tests/EnumArrayTests.cpp b/Tests/EnumArrayTests.cpp new file mode 100644 index 0000000..c433e90 --- /dev/null +++ b/Tests/EnumArrayTests.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include +#include +#include + +#include "EnumArray.h" +#include "Evaluation.h" +#include "Searcher.h" + +using namespace SimpleChessEngine; + +template +concept IndexedBy = requires(Table table, Key key) { table[key]; }; + +static_assert(IndexedBy, Player>); +static_assert(!IndexedBy, Piece>); +static_assert(!IndexedBy, std::size_t>); +static_assert(IndexedBy, Piece>); +static_assert(!IndexedBy, Player>); +static_assert(!IndexedBy, std::size_t>); +static_assert(sizeof(ByPlayer) == sizeof(std::array)); +static_assert(sizeof(ByPiece) == sizeof(std::array)); +using ContinuationHistory = std::remove_cvref_t< + decltype(std::declval().GetContinuationHistory())>; +static_assert(std::is_trivially_copyable_v); +static_assert(IndexedBy); +static_assert(!IndexedBy); +static_assert(sizeof(ContinuationHistory) == + sizeof(std::int32_t) * kPieceTypes * kPieceTypes * + (kBoardArea + 1) * (kBoardArea + 1)); +static_assert([] { + ByPlayer> table{}; + table[Player::kWhite][Piece::kPawn] = 7; + table[Player::kBlack][Piece::kQueen] = -3; + return table[Player::kWhite][Piece::kPawn] == 7 && + table[Player::kBlack][Piece::kQueen] == -3 && + table[Player::kWhite][Piece::kQueen] == 0; +}()); + +TEST(EnumArray, FillPreservesPlayerAndPieceMapping) { + ByPlayer> table{}; + table[Player::kWhite].fill(11); + table[Player::kBlack].fill(-5); + EXPECT_EQ(table[Player::kWhite][Piece::kKnight], 11); + EXPECT_EQ(table[Player::kBlack][Piece::kKnight], -5); +} diff --git a/Tests/EvaluationTests.cpp b/Tests/EvaluationTests.cpp index dc1788b..62c1d56 100644 --- a/Tests/EvaluationTests.cpp +++ b/Tests/EvaluationTests.cpp @@ -10,13 +10,13 @@ using namespace SimpleChessEngine; namespace EvaluationTests { TEST(PawnSpans, FrontAndRearAreColorRelative) { const auto d4 = GetSquareIndex(3, 3); - EXPECT_EQ(kPawnSpans.front[static_cast(Player::kWhite)][d4], + EXPECT_EQ(kPawnSpans.front[Player::kWhite][d4], kFileBB[3] & (kRankBB[4] | kRankBB[5] | kRankBB[6] | kRankBB[7])); - EXPECT_EQ(kPawnSpans.rear[static_cast(Player::kWhite)][d4], + EXPECT_EQ(kPawnSpans.rear[Player::kWhite][d4], kFileBB[3] & (kRankBB[0] | kRankBB[1] | kRankBB[2])); - EXPECT_EQ(kPawnSpans.front[static_cast(Player::kBlack)][d4], + EXPECT_EQ(kPawnSpans.front[Player::kBlack][d4], kFileBB[3] & (kRankBB[0] | kRankBB[1] | kRankBB[2])); - EXPECT_EQ(kPawnSpans.rear[static_cast(Player::kBlack)][d4], + EXPECT_EQ(kPawnSpans.rear[Player::kBlack][d4], kFileBB[3] & (kRankBB[4] | kRankBB[5] | kRankBB[6] | kRankBB[7])); } @@ -51,11 +51,11 @@ TEST(PawnSpans, EveryPrecompiledSpanMatchesReference) { } } - EXPECT_EQ(kPawnSpans.front[side_index][square], expected_front) + EXPECT_EQ(kPawnSpans.front[side][square], expected_front) << "side=" << side_index << " square=" << static_cast(square); - EXPECT_EQ(kPawnSpans.rear[side_index][square], expected_rear) + EXPECT_EQ(kPawnSpans.rear[side][square], expected_rear) << "side=" << side_index << " square=" << static_cast(square); - EXPECT_EQ(kPawnSpans.passed[side_index][square], expected_passed) + EXPECT_EQ(kPawnSpans.passed[side][square], expected_passed) << "side=" << side_index << " square=" << static_cast(square); EXPECT_EQ(kPawnSpans.adjacent_files[square], expected_adjacent_files) << "side=" << side_index << " square=" << static_cast(square); @@ -149,8 +149,7 @@ TEST(Material, RawPawnEndgameValue) { const auto position = PositionFactory{}("7k/8/8/3P4/8/8/8/K7 w - - 0 1"); const Eval baseline = position.Evaluate(); const Eval original = - Settings::EvaluationParameters::material_value[static_cast( - Piece::kPawn)] + Settings::EvaluationParameters::material_value[Piece::kPawn] .eval[1]; Settings::EvaluationParameters::SetMaterialValue( @@ -162,7 +161,7 @@ TEST(Material, RawPawnEndgameValue) { TEST(Mobility, KnightExcludesSquaresAttackedByEnemyPawns) { const auto position = PositionFactory{}("7k/8/4p3/8/3N4/8/8/K7 w - - 0 1"); - const auto piece = static_cast(Piece::kKnight); + const auto piece = Piece::kKnight; const TaperedEval original = Settings::EvaluationParameters::mobility[piece]; const Eval baseline = position.Evaluate(); @@ -179,7 +178,7 @@ TEST(Mobility, KnightExcludesSquaresAttackedByEnemyPawns) { TEST(Mobility, BishopExcludesSquaresAttackedByEnemyPawns) { const auto position = PositionFactory{}("k7/8/1p6/8/3B4/8/8/7K w - - 0 1"); - const auto piece = static_cast(Piece::kBishop); + const auto piece = Piece::kBishop; const TaperedEval original = Settings::EvaluationParameters::mobility[piece]; const Eval baseline = position.Evaluate(); @@ -196,7 +195,7 @@ TEST(Mobility, BishopExcludesSquaresAttackedByEnemyPawns) { TEST(Mobility, RookKeepsSquaresAttackedByEnemyPawns) { const auto position = PositionFactory{}("7k/8/4p3/8/3R4/8/8/K7 w - - 0 1"); - const auto piece = static_cast(Piece::kRook); + const auto piece = Piece::kRook; const TaperedEval original = Settings::EvaluationParameters::mobility[piece]; const Eval baseline = position.Evaluate(); @@ -213,7 +212,7 @@ TEST(Mobility, RookKeepsSquaresAttackedByEnemyPawns) { TEST(Mobility, QueenKeepsSquaresAttackedByEnemyPawns) { const auto position = PositionFactory{}("7k/8/4p3/8/3Q4/8/8/K7 w - - 0 1"); - const auto piece = static_cast(Piece::kQueen); + const auto piece = Piece::kQueen; const TaperedEval original = Settings::EvaluationParameters::mobility[piece]; const Eval baseline = position.Evaluate(); @@ -266,8 +265,7 @@ TEST(KingSafety, MultipleZoneAttackersUsePieceWeights) { "rnbq2kr/pppp1ppp/5n2/7Q/2B5/8/PPPPPPPP/RNB1K1NR w KQ - 0 1"); const Eval baseline = position.Evaluate(); const Eval original = - Settings::EvaluationParameters::king_attack[static_cast( - Piece::kQueen)]; + Settings::EvaluationParameters::king_attack[Piece::kQueen]; Settings::EvaluationParameters::SetKingAttack(original + 10); EXPECT_GT(position.Evaluate(), baseline); diff --git a/Tests/HistoryPersistenceTests.cpp b/Tests/HistoryPersistenceTests.cpp index c1da97f..700f59a 100644 --- a/Tests/HistoryPersistenceTests.cpp +++ b/Tests/HistoryPersistenceTests.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -12,6 +13,11 @@ using namespace SimpleChessEngine; namespace { +auto ContinuationEntries(const Searcher& searcher) { + return searcher.GetContinuationHistory() | std::views::join | + std::views::join | std::views::join; +} + std::uint64_t TotalNodes(const std::string& output) { std::istringstream lines(output); std::string line; @@ -38,8 +44,8 @@ TEST(HistoryPersistence, SecondGoDecaysButterflyAndPreservesContinuation) { const auto& searcher = engine.GetSearcher(); auto expected = searcher.GetHistory(); const auto continuation = searcher.GetContinuationHistory(); - EXPECT_TRUE( - std::ranges::any_of(continuation, [](auto entry) { return entry != 0; })); + EXPECT_TRUE(std::ranges::any_of(ContinuationEntries(searcher), + [](auto entry) { return entry != 0; })); bool positive = false; bool negative = false; @@ -73,9 +79,10 @@ TEST(HistoryPersistence, SecondGoDecaysButterflyAndPreservesContinuation) { EXPECT_EQ(searcher.GetKillers().AvailableKillerCount(ply), 0u); } auto position = searcher.GetPosition(); - const auto side = static_cast(position.GetSideToMove()); + const auto side = position.GetSideToMove(); for (const auto move : - MoveGenerator{}.GenerateLegalMoves(position)) { + MoveGenerator{}.GenerateLegalMoves( + position)) { EXPECT_EQ(searcher.GetQuietScore(move, 2), expected[side][move.From()][move.To()]); } @@ -88,7 +95,7 @@ TEST(HistoryPersistence, NewGameClearsBothTables) { DepthCondition condition{5}; engine.ComputeBestMove(condition); const auto& searcher = engine.GetSearcher(); - EXPECT_TRUE(std::ranges::any_of(searcher.GetContinuationHistory(), + EXPECT_TRUE(std::ranges::any_of(ContinuationEntries(searcher), [](auto entry) { return entry != 0; })); engine.NewGame(); @@ -98,7 +105,7 @@ TEST(HistoryPersistence, NewGameClearsBothTables) { std::ranges::all_of(from, [](auto entry) { return entry == 0; })); } } - EXPECT_TRUE(std::ranges::all_of(searcher.GetContinuationHistory(), + EXPECT_TRUE(std::ranges::all_of(ContinuationEntries(searcher), [](auto entry) { return entry == 0; })); } diff --git a/Tests/PositionStateTests.cpp b/Tests/PositionStateTests.cpp index 0a2c472..b9a57b0 100644 --- a/Tests/PositionStateTests.cpp +++ b/Tests/PositionStateTests.cpp @@ -10,7 +10,7 @@ struct PositionStateTestAccess { } static void ClearBlackPins(Position& position) { - const auto side = static_cast(Player::kBlack); + const auto side = Player::kBlack; position.irreversible_data_.blockers[side] = kEmptyBoard; position.irreversible_data_.pinners[side] = kEmptyBoard; } @@ -53,7 +53,7 @@ TEST(PositionState, DetectsCorruptValidPinCacheWithoutRepairingIt) { PositionStateTestAccess::ClearBlackPins(position); EXPECT_FALSE(PositionStateTestAccess::VerifyPinCache(position)); const auto after = position.GetIrreversibleData(); - const auto black = static_cast(Player::kBlack); + const auto black = Player::kBlack; EXPECT_TRUE(after.pins_valid[black]); EXPECT_EQ(after.blockers[black], kEmptyBoard); EXPECT_EQ(after.pinners[black], kEmptyBoard); diff --git a/Tests/SearchCorrectnessTests.cpp b/Tests/SearchCorrectnessTests.cpp index 894e68a..84c4ac0 100644 --- a/Tests/SearchCorrectnessTests.cpp +++ b/Tests/SearchCorrectnessTests.cpp @@ -425,8 +425,8 @@ TEST(ProbCut, TtVetoRespectsDepthThresholdScoreAndDecisiveBand) { TEST(ProbCut, SeeBoundaryUsesImprovingMarginInLocalUnits) { const auto position = PositionFactory{}(kProbCutFen); const auto move = MoveFactory{}(position, "d4d5"); - const auto pawn = kPieceValues[static_cast(Piece::kPawn)]; - const auto rook = kPieceValues[static_cast(Piece::kRook)]; + const auto pawn = kPieceValues[Piece::kPawn]; + const auto rook = kPieceValues[Piece::kRook]; const Eval gain = pawn(rook.eval[0]); ASSERT_TRUE(position.StaticExchangeEvaluation(move, gain)); ASSERT_FALSE(position.StaticExchangeEvaluation(move, gain + 1)); diff --git a/Tests/SearchEvaluationTests.cpp b/Tests/SearchEvaluationTests.cpp index 7d43d24..c317125 100644 --- a/Tests/SearchEvaluationTests.cpp +++ b/Tests/SearchEvaluationTests.cpp @@ -164,11 +164,12 @@ struct SearchEvaluationTestAccess { searcher.UpdateStaticEvalHistory(ply, eval); } static auto &Entry(Searcher &searcher, Player side, const Move &move) { - return searcher.history_[static_cast(side)][move.From()][move.To()]; + return searcher.history_[side][move.From()][move.To()]; } static bool ContinuationsEmpty(const Searcher &searcher) { - return std::ranges::all_of(searcher.continuation_history_, - [](auto entry) { return entry == 0; }); + const auto entries = searcher.GetContinuationHistory() | std::views::join | + std::views::join | std::views::join; + return std::ranges::all_of(entries, [](auto entry) { return entry == 0; }); } static const auto &Context(const Searcher &searcher, Depth ply) { return searcher.move_stack_[ply]; diff --git a/Tests/StaticExchangeEvaluationTests.cpp b/Tests/StaticExchangeEvaluationTests.cpp index 38fa29d..7f43622 100644 --- a/Tests/StaticExchangeEvaluationTests.cpp +++ b/Tests/StaticExchangeEvaluationTests.cpp @@ -78,7 +78,7 @@ TEST(StaticExchangeEvaluation, TracksMultiplePinnersOnKingRay) { PositionFactory{}("4k3/4n3/8/3p4/8/8/4R3/3QR1K1 w - - 0 1"); ExpectSeeValue(position, "d1d5", 89); const auto pins = position.GetIrreversibleData(); - const auto black = static_cast(Player::kBlack); + const auto black = Player::kBlack; EXPECT_EQ(pins.pinners[black], SingleSquare(GetSquareIndex(4, 0)) | SingleSquare(GetSquareIndex(4, 1))); diff --git a/Tests/TypedMoveTests.cpp b/Tests/TypedMoveTests.cpp index 5105033..05644e2 100644 --- a/Tests/TypedMoveTests.cpp +++ b/Tests/TypedMoveTests.cpp @@ -79,7 +79,7 @@ TEST(TypedMoves, RejectsExposingKing) { const auto pseudo = position.TryPseudoLegal(MoveFactory{}(position, "e2f2")); ASSERT_TRUE(pseudo); EXPECT_FALSE(position.TryLegal(*pseudo)); - EXPECT_FALSE(position.TryLegal(*pseudo, position.GetIrreversibleData().blockers[0])); + EXPECT_FALSE(position.TryLegal(*pseudo, position.GetIrreversibleData().blockers[Player::kWhite])); } TEST(TypedMoves, AcceptsEveryGeneratedLegalMove) { @@ -106,7 +106,7 @@ TEST(TypedMoves, AcceptsEveryGeneratedLegalMove) { ASSERT_TRUE(legal); EXPECT_EQ(*legal, move); const auto explicit_blockers = position.TryLegal( - *pseudo, position.GetIrreversibleData().blockers[static_cast(position.GetSideToMove())]); + *pseudo, position.GetIrreversibleData().blockers[position.GetSideToMove()]); ASSERT_TRUE(explicit_blockers); EXPECT_EQ(*explicit_blockers, move); }