X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.h;h=d0a5a97e08a42dced2b9a29a7e081d9a9d657b0a;hp=011299ac6493c012f353102b1e34c0301c666308;hb=d39bc2efa197ba2fd55b68eced1c60bcfe2facc1;hpb=d3c4618b3ac0e444ce3b9dd894b87f86a50863c5 diff --git a/src/endgame.h b/src/endgame.h index 011299ac..d0a5a97e 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -1,7 +1,8 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2009 Marco Costalba + Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,111 +18,109 @@ along with this program. If not, see . */ - -#if !defined(ENDGAME_H_INCLUDED) +#ifndef ENDGAME_H_INCLUDED #define ENDGAME_H_INCLUDED -//// -//// Includes -//// +#include +#include +#include +#include +#include #include "position.h" -#include "scale.h" -#include "value.h" - - -//// -//// Types -//// - -enum EndgameType { - - // Evaluation functions - KXK, // Generic "mate lone king" eval - KBNK, // KBN vs K - KPK, // KP vs K - KRKP, // KR vs KP - KRKB, // KR vs KB - KRKN, // KR vs KN - KQKR, // KQ vs KR - KBBKN, // KBB vs KN - KmmKm, // K and two minors vs K and one or two minors - - // Scaling functions - KBPK, // KBP vs K - KQKRP, // KQ vs KRP - KRPKR, // KRP vs KR - KRPPKRP, // KRPP vs KRP - KPsK, // King and pawns vs king - KBPKB, // KBP vs KB - KBPPKB, // KBPP vs KB - KBPKN, // KBP vs KN - KNPK, // KNP vs K - KPKP // KP vs KP +#include "types.h" + + +/// EndgameCode lists all supported endgame functions by corresponding codes + +enum EndgameCode { + + EVALUATION_FUNCTIONS, + KNNK, // KNN vs K + KNNKP, // KNN vs KP + KXK, // Generic "mate lone king" eval + KBNK, // KBN vs K + KPK, // KP vs K + KRKP, // KR vs KP + KRKB, // KR vs KB + KRKN, // KR vs KN + KQKP, // KQ vs KP + KQKR, // KQ vs KR + + SCALING_FUNCTIONS, + KBPsK, // KB and pawns vs K + KQKRPs, // KQ vs KR and pawns + KRPKR, // KRP vs KR + KRPKB, // KRP vs KB + KRPPKRP, // KRPP vs KRP + KPsK, // K and pawns vs K + KBPKB, // KBP vs KB + KBPPKB, // KBPP vs KB + KBPKN, // KBP vs KN + KNPK, // KNP vs K + KNPKB, // KNP vs KB + KPKP // KP vs KP }; -/// Template abstract base class for all special endgame functions -template -class EndgameFunctionBase { -public: - EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {} - virtual ~EndgameFunctionBase() {} - virtual T apply(const Position&) = 0; - -protected: - Color strongerSide, weakerSide; -}; +/// Endgame functions can be of two types depending on whether they return a +/// Value or a ScaleFactor. -typedef EndgameFunctionBase EndgameEvaluationFunctionBase; -typedef EndgameFunctionBase EndgameScalingFunctionBase; +template using +eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type; -/// Templates subclass for various concrete endgames +/// Base and derived functors for endgame evaluation and scaling functions + +template +struct EndgameBase { + + explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {} + virtual ~EndgameBase() = default; + virtual T operator()(const Position&) const = 0; -template -struct EvaluationFunction : public EndgameEvaluationFunctionBase { - explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {} - Value apply(const Position&); + const Color strongSide, weakSide; }; -template -struct ScalingFunction : public EndgameScalingFunctionBase { - explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {} - ScaleFactor apply(const Position&); + +template> +struct Endgame : public EndgameBase { + + explicit Endgame(Color c) : EndgameBase(c) {} + T operator()(const Position&) const override; }; -//// -//// Constants and variables -//// +/// The Endgames namespace handles the pointers to endgame evaluation and scaling +/// base objects in two std::map. We use polymorphism to invoke the actual +/// endgame function by calling its virtual operator(). + +namespace Endgames { + + template using Ptr = std::unique_ptr>; + template using Map = std::map>; + + extern std::pair, Map> maps; -extern EvaluationFunction EvaluateKXK, EvaluateKKX; // Generic "mate lone king" eval -extern EvaluationFunction EvaluateKBNK, EvaluateKKBN; // KBN vs K -extern EvaluationFunction EvaluateKPK, EvaluateKKP; // KP vs K -extern EvaluationFunction EvaluateKRKP, EvaluateKPKR; // KR vs KP -extern EvaluationFunction EvaluateKRKB, EvaluateKBKR; // KR vs KB -extern EvaluationFunction EvaluateKRKN, EvaluateKNKR; // KR vs KN -extern EvaluationFunction EvaluateKQKR, EvaluateKRKQ; // KQ vs KR -extern EvaluationFunction EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN -extern EvaluationFunction EvaluateKmmKm; // K and two minors vs K and one or two minors: + void init(); -extern ScalingFunction ScaleKBPK, ScaleKKBP; // KBP vs K -extern ScalingFunction ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP -extern ScalingFunction ScaleKRPKR, ScaleKRKRP; // KRP vs KR -extern ScalingFunction ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP -extern ScalingFunction ScaleKPsK, ScaleKKPs; // King and pawns vs king -extern ScalingFunction ScaleKBPKB, ScaleKBKBP; // KBP vs KB -extern ScalingFunction ScaleKBPPKB, ScaleKBKBPP; // KBPP vs KB -extern ScalingFunction ScaleKBPKN, ScaleKNKBP; // KBP vs KN -extern ScalingFunction ScaleKNPK, ScaleKKNP; // KNP vs K -extern ScalingFunction ScaleKPKPw, ScaleKPKPb; // KP vs KP + template + Map& map() { + return std::get::value>(maps); + } -//// -//// Prototypes -//// + template> + void add(const std::string& code) { -extern void init_bitbases(); + StateInfo st; + map()[Position().set(code, WHITE, &st).material_key()] = Ptr(new Endgame(WHITE)); + map()[Position().set(code, BLACK, &st).material_key()] = Ptr(new Endgame(BLACK)); + } + template + const EndgameBase* probe(Key key) { + return map().count(key) ? map()[key].get() : nullptr; + } +} -#endif // !defined(ENDGAME_H_INCLUDED) +#endif // #ifndef ENDGAME_H_INCLUDED