Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 50 additions & 0 deletions Chess/EnumArray.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
#pragma once

#include <array>
#include <cstddef>
#include <type_traits>
#include <utility>

namespace SimpleChessEngine {

template <class Key>
inline constexpr std::size_t kEnumSize = 0;

template <class Key>
concept IndexEnum = std::is_enum_v<Key> && (kEnumSize<Key> > 0);

template <IndexEnum Key, class Value>
struct EnumArray {
using value_type = Value;
using iterator = typename std::array<Value, kEnumSize<Key>>::iterator;
using const_iterator =
typename std::array<Value, kEnumSize<Key>>::const_iterator;

std::array<Value, kEnumSize<Key>> 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<Key>;
}

[[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
47 changes: 21 additions & 26 deletions Chess/Evaluation.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ struct KingPawnHashEntry {
Bitboard black_pawns{};
BitIndex white_king{-1};
BitIndex black_king{-1};
std::array<Eval, kColors> king_score{};
ByPlayer<Eval> king_score{};
};

struct KingPawnHashTable {
Expand All @@ -44,10 +44,10 @@ thread_local KingPawnHashTable king_pawn_hash_table;

struct PawnEvaluation {
TaperedEval score{};
std::array<Eval, kColors> king_score{};
ByPlayer<Eval> king_score{};
};

[[nodiscard]] const std::array<Eval, kColors>& EvaluateKingPawns(
[[nodiscard]] const ByPlayer<Eval>& EvaluateKingPawns(
const Position& position, Bitboard white_pawns, Bitboard black_pawns,
size_t pawn_hash_index);

Expand All @@ -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<size_t>(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<size_t>(file_coordinate);
const auto rank = static_cast<size_t>(rank_coordinate);
const auto relative_rank =
side == Player::kWhite ? rank : static_cast<size_t>(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];
Expand Down Expand Up @@ -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<size_t>(piece)];
Settings::EvaluationParameters::mobility[piece];
if (weight == TaperedEval{}) return;

Bitboard pieces = position.GetPiecesByType<piece>(side);
Expand Down Expand Up @@ -172,8 +170,8 @@ void AddPsqtAdjustment(const Position& position, const Player side,
side == Player::kWhite ? rank : static_cast<size_t>(7 - rank);
const size_t mirrored_file = std::min(file, static_cast<size_t>(7 - file));
result +=
Settings::EvaluationParameters::psqt_adjustment[static_cast<size_t>(
piece)][relative_rank][mirrored_file];
Settings::EvaluationParameters::psqt_adjustment[
piece][relative_rank][mirrored_file];
}
}

Expand Down Expand Up @@ -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<size_t>(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()) {
Expand All @@ -240,7 +238,7 @@ void AddPsqtAdjustment(const Position& position, const Player side,
return result;
}

[[nodiscard]] const std::array<Eval, kColors>& EvaluateKingPawns(
[[nodiscard]] const ByPlayer<Eval>& 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);
Expand Down Expand Up @@ -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<Eval>(tropism) *
Settings::EvaluationParameters::king_attack[static_cast<size_t>(piece)];
Settings::EvaluationParameters::king_attack[piece];
}

[[nodiscard]] Eval EvaluateKingAttack(const Position& position,
Expand Down Expand Up @@ -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<size_t>(GamePhase::kMiddleGame)];
kPhaseValueLimits[GamePhase::kMiddleGame];
const auto eg_limit =
kPhaseValueLimits[static_cast<size_t>(GamePhase::kEndGame)];
kPhaseValueLimits[GamePhase::kEndGame];
pv = std::clamp(pv, eg_limit, mg_limit);
return (eval[static_cast<size_t>(GamePhase::kMiddleGame)] * (pv - eg_limit) +
eval[static_cast<size_t>(GamePhase::kEndGame)] * (mg_limit - pv)) /
Expand All @@ -381,26 +379,23 @@ 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<size_t>(us);
const auto them_idx = static_cast<size_t>(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<size_t>(Piece::kPawn);
piece <= static_cast<size_t>(Piece::kQueen); ++piece) {
for (const auto piece : kPiecesByValue) {
const int count_difference =
static_cast<int>(evaluation_data_.piece_counts[us_idx][piece]) -
static_cast<int>(evaluation_data_.piece_counts[them_idx][piece]);
static_cast<int>(evaluation_data_.piece_counts[us][piece]) -
static_cast<int>(evaluation_data_.piece_counts[them][piece]);
const TaperedEval correction =
Settings::EvaluationParameters::material_value[piece] -
kPieceValues[piece];
result.eval[0] += count_difference * correction.eval[0];
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<Piece::kQueen>(Player::kWhite) |
Expand Down Expand Up @@ -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);
Expand Down
33 changes: 20 additions & 13 deletions Chess/Evaluation.h
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,12 @@ using SearchResult = std::optional<Eval>;

enum class GamePhase : std::uint8_t { kMiddleGame, kEndGame };

template <>
inline constexpr std::size_t kEnumSize<GamePhase> = 2;

template <class Value>
using ByGamePhase = EnumArray<GamePhase, Value>;

constexpr size_t kGamePhases = 2;

using PhaseValue = int;
Expand Down Expand Up @@ -46,32 +52,33 @@ struct TaperedEval {
return copy;
}

constexpr std::array<TaperedEval, kPieceTypes> kPieceValues = {{{0, 0},
{82, 94},
{337, 281},
{365, 297},
{477, 512},
{1025, 936},
{0, 0}}};
inline constexpr ByPiece<TaperedEval> kPieceValues = {{{{0, 0},
{82, 94},
{337, 281},
{365, 297},
{477, 512},
{1025, 936},
{0, 0}}}};

constexpr Eval kFullNonPawnMaterial =
kPieceValues[static_cast<size_t>(Piece::kKnight)]
kPieceValues[Piece::kKnight]
.eval[static_cast<size_t>(GamePhase::kMiddleGame)] *
4 +
kPieceValues[static_cast<size_t>(Piece::kBishop)]
kPieceValues[Piece::kBishop]
.eval[static_cast<size_t>(GamePhase::kMiddleGame)] *
4 +
kPieceValues[static_cast<size_t>(Piece::kRook)]
kPieceValues[Piece::kRook]
.eval[static_cast<size_t>(GamePhase::kMiddleGame)] *
4 +
kPieceValues[static_cast<size_t>(Piece::kQueen)]
kPieceValues[Piece::kQueen]
.eval[static_cast<size_t>(GamePhase::kMiddleGame)] *
2;

constexpr std::array kPhaseValueLimits = {kFullNonPawnMaterial, 0};
constexpr ByGamePhase<PhaseValue> kPhaseValueLimits = {{kFullNonPawnMaterial, 0}};

constexpr PhaseValue kLimitsDifference =
kPhaseValueLimits[0] - kPhaseValueLimits[1];
kPhaseValueLimits[GamePhase::kMiddleGame] -
kPhaseValueLimits[GamePhase::kEndGame];

constexpr Eval kTempoBonus = 20;

Expand Down
4 changes: 2 additions & 2 deletions Chess/Hasher.h
Original file line number Diff line number Diff line change
Expand Up @@ -66,10 +66,10 @@ struct Hasher {

constexpr bool operator==(const Hasher&) const = default;

std::array<std::array<std::array<Hash, kBoardArea>, kColors>, kPieceTypes>
ByPiece<ByPlayer<std::array<Hash, kBoardArea>>>
psqt_hash{};
std::array<Hash, kLineSize> en_croissant_hash{};
std::array<std::array<Hash, 4>, kColors> cr_hash{};
ByPlayer<std::array<Hash, 4>> cr_hash{};
Hash stm_hash;
};
extern const Hasher kZobristKeys;
Expand Down
11 changes: 11 additions & 0 deletions Chess/Move.h
Original file line number Diff line number Diff line change
@@ -1,8 +1,11 @@
#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
#include <cassert>
#include <tuple>
#include "BitBoard.h"
#include "EnumArray.h"
#include "Piece.h"

namespace SimpleChessEngine {
Expand Down Expand Up @@ -93,6 +96,14 @@ class Move {

enum class CastlingSide : std::uint8_t { k00, k000 };

template <>
inline constexpr std::size_t kEnumSize<CastlingSide> = 2;

inline constexpr std::array kCastlingSides{CastlingSide::k00, CastlingSide::k000};

template <class Value>
using ByCastlingSide = EnumArray<CastlingSide, Value>;

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>, "Move must be trivially copyable");
Expand Down
10 changes: 3 additions & 7 deletions Chess/MoveGenerator.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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<size_t>(side_to_move);

for (const auto castling_side : {CastlingSide::k00, CastlingSide::k000}) {
if (position.CanPseudoCastle(castling_side)) {
const auto side_idx = static_cast<size_t>(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<MoveType::kCastling>(king_square, king_to)));
Expand All @@ -56,14 +54,12 @@ template <>
void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
PseudoLegalMoves& moves, Position& position, const Bitboard target) const {
const auto us = position.GetSideToMove();
const auto us_idx = static_cast<size_t>(us);
const auto them = Flip(us);
const auto them_idx = static_cast<size_t>(them);

const auto pawns = position.GetPiecesByType<Piece::kPawn>(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;

Expand Down
2 changes: 1 addition & 1 deletion Chess/MovePicker.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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<size_t>(position.GetSideToMove())];
.blockers[position.GetSideToMove()];
excluded_move_ = excluded_move;
tt_move_ = position.IsPseudoLegal(tt_move) ? tt_move : Move::None();
stage_ = Stage::kTT;
Expand Down
16 changes: 7 additions & 9 deletions Chess/PSQT.h
Original file line number Diff line number Diff line change
Expand Up @@ -5,11 +5,10 @@
namespace SimpleChessEngine {
// clang-format off
consteval auto MakePSQT() {
std::array<std::array<std::array<TaperedEval, kBoardArea>, kPieceTypes>,
kColors>
table = { {
ByPlayer<ByPiece<std::array<TaperedEval, kBoardArea>>>
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
Expand Down Expand Up @@ -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,
Expand All @@ -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<size_t>(Player::kBlack)][static_cast<size_t>(piece)]
[new_square] = table[static_cast<size_t>(Player::kWhite)]
[static_cast<size_t>(piece)][square];
table[Player::kBlack][piece][new_square] =
table[Player::kWhite][piece][square];
}
}
return table;
Expand Down
Loading
Loading