Score.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */

 
#pragma once
 
#include <cassert>
#include <cmath>   // IWYU pragma: keep - for std::abs()
#include <cstddef> // IWYU pragma: keep - for size_t
#include <cstdint> // IWYU pragma: keep - for std::int16_t
#include <format>
#include <libchess/uci/Printing.hpp>
#include <limits>
#include <utility>
 
namespace ben_bot::eval {
 
using std::size_t;

using Value = std::int16_t;

inline constexpr Value MAX { std::numeric_limits<Value>::max() - UINT16_C(5) };

inline constexpr Value MATE { MAX / UINT16_C(2) };

inline constexpr Value DRAW { UINT16_C(0) };

struct Score final {
    Value value { UINT16_C(0) };

    constexpr operator Value() const noexcept { return value; }

    [[nodiscard]] constexpr auto operator-() const noexcept -> Score { return { static_cast<Value>(-value) }; }


    [[nodiscard]] auto is_mate() const noexcept -> bool { return std::cmp_greater_equal(std::abs(value), MATE); }

    [[nodiscard]] constexpr auto is_winning_mate() const noexcept -> bool { return std::cmp_greater_equal(value, MATE); }

    [[nodiscard]] constexpr auto is_losing_mate() const noexcept -> bool { return std::cmp_less_equal(value, -MATE); }

    [[nodiscard]] auto ply_to_mate() const noexcept -> size_t
    {
        assert(is_mate());
 
        return static_cast<size_t>(MAX - std::abs(value));
    }


    [[nodiscard]] constexpr auto to_tt() const noexcept -> Value;

    using LibchessScore = chess::uci::printing::SearchInfo::Score;

    [[nodiscard]] auto to_libchess() const noexcept -> LibchessScore;

    [[nodiscard, gnu::const]] static constexpr auto mate(const size_t plyFromRoot) noexcept -> Score
    {
        // multiply by -1 here because this score is relative to the player who got mated
        return { static_cast<Value>(
            (MAX - static_cast<Value>(plyFromRoot)) * -1) };
    }

    [[nodiscard, gnu::const]] static constexpr auto from_tt(
        Value eval, size_t plyFromRoot) noexcept
        -> Score;
};
 
/*
                         ___                           ,--,
      ,---,            ,--.'|_                ,--,   ,--.'|
    ,---.'|            |  | :,'             ,--.'|   |  | :
    |   | :            :  : ' :             |  |,    :  : '    .--.--.
    |   | |   ,---.  .;__,'  /    ,--.--.   `--'_    |  ' |   /  /    '
  ,--.__| |  /     \ |  |   |    /       \  ,' ,'|   '  | |  |  :  /`./
 /   ,'   | /    /  |:__,'| :   .--.  .-. | '  | |   |  | :  |  :  ;_
.   '  /  |.    ' / |  '  : |__  \__\/: . . |  | :   '  : |__ \  \    `.
'   ; |:  |'   ;   /|  |  | '.'| ," .--.; | '  : |__ |  | '.'| `----.   \
|   | '/  ''   |  / |  ;  :    ;/  /  ,.  | |  | '.'|;  :    ;/  /`--'  /__  ___  ___
|   :    :||   :    |  |  ,   /;  :   .'   \;  :    ;|  ,   /'--'.     /  .\/  .\/  .\
 \   \  /   \   \  /    ---`-' |  ,     .-./|  ,   /  ---`-'   `--'---'\  ; \  ; \  ; |
  `----'     `----'             `--`---'     ---`-'                     `--" `--" `--"
 
 */
 
constexpr auto Score::to_tt() const noexcept -> Value
{
    if (is_losing_mate())
        return -MATE;
 
    if (is_winning_mate())
        return MATE;
 
    return value;
}
 
constexpr auto Score::from_tt(
    const Value eval, const size_t plyFromRoot) noexcept
    -> Score
{
    if (std::cmp_less_equal(eval, -MATE))
        return mate(plyFromRoot);
 
    if (std::cmp_greater_equal(eval, MATE))
        return -mate(plyFromRoot);
 
    return { eval };
}
 
inline auto Score::to_libchess() const noexcept -> LibchessScore
{
    LibchessScore res;
 
    if (is_mate()) {
        auto ply = static_cast<int>(ply_to_mate());
 
        if (is_losing_mate())
            ply *= -1;
 
        res.value = LibchessScore::MateIn { .plies = ply };
    } else {
        res.value = LibchessScore::Centipawns { .value = value };
    }
 
    return res;
}
 
} // namespace ben_bot::eval

template <>
struct std::formatter<ben_bot::eval::Score> final {
    template <typename ParseContext>
    constexpr auto parse(ParseContext& ctx) -> typename ParseContext::iterator
    {
        return ctx.begin();
    }
 
    template <typename FormatContext>
    auto format(
        const ben_bot::eval::Score& score, FormatContext& ctx) const
        -> typename FormatContext::iterator
    {
        return std::format_to(ctx.out(), "{}", score.value);
    }
};