X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.h;h=ca29c0b9d5cf46e2ea9c039675da665498bef849;hp=ae3526fedaeae8777416c5fa7263ced01c7a618f;hb=98352a5e84096c906d5ecc1aeb2fca8745e173c2;hpb=bb751d6c890f5c50c642366d601740366cfae8d0 diff --git a/src/endgame.h b/src/endgame.h index ae3526fe..ca29c0b9 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -1,242 +1,125 @@ /* - Glaurung, a UCI chess playing engine. - Copyright (C) 2004-2008 Tord Romstad + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - Glaurung is free software: you can redistribute it and/or modify + Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - - Glaurung is distributed in the hope that it will be useful, + + Stockfish is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program. If not, see . */ - #if !defined(ENDGAME_H_INCLUDED) #define ENDGAME_H_INCLUDED -//// -//// Includes -//// +#include +#include #include "position.h" -#include "scale.h" -#include "value.h" +#include "types.h" -//// -//// Types -//// +/// EndgameType lists all supported endgames -/// Abstract base class for all special endgame evaluation functions: +enum EndgameType { -class EndgameEvaluationFunction { -public: - EndgameEvaluationFunction(Color c); - virtual ~EndgameEvaluationFunction() { } + // Evaluation functions - virtual Value apply(const Position &pos) =0; - -protected: - Color strongerSide, weakerSide; -}; + 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 + KNNK, // KNN vs K + KmmKm, // K and two minors vs K and one or two minors -/// Subclasses for various concrete endgames: + // Scaling functions + SCALE_FUNS, -// Generic "mate lone king" eval: -class KXKEvaluationFunction : public EndgameEvaluationFunction { -public: - KXKEvaluationFunction(Color c); - Value apply(const Position &pos); + KBPsK, // KB+pawns vs K + KQKRPs, // KQ vs KR+pawns + 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 }; -// KBN vs K: -class KBNKEvaluationFunction : public EndgameEvaluationFunction { -public: - KBNKEvaluationFunction(Color c); - Value apply(const Position &pos); -}; -// KP vs K: -class KPKEvaluationFunction : public EndgameEvaluationFunction { -public: - KPKEvaluationFunction(Color c); - Value apply(const Position &pos); -}; +/// Some magic to detect family type of endgame from its enum value -// KR vs KP: -class KRKPEvaluationFunction : public EndgameEvaluationFunction { -public: - KRKPEvaluationFunction(Color c); - Value apply(const Position &pos); -}; +template struct bool_to_type { typedef Value type; }; +template<> struct bool_to_type { typedef ScaleFactor type; }; +template struct eg_family : public bool_to_type<(E > SCALE_FUNS)> {}; -// KR vs KB: -class KRKBEvaluationFunction : public EndgameEvaluationFunction { -public: - KRKBEvaluationFunction(Color c); - Value apply(const Position &pos); -}; -// KR vs KN: -class KRKNEvaluationFunction : public EndgameEvaluationFunction { -public: - KRKNEvaluationFunction(Color c); - Value apply(const Position &pos); -}; +/// Base and derived templates for endgame evaluation and scaling functions -// KQ vs KR: -class KQKREvaluationFunction : public EndgameEvaluationFunction { -public: - KQKREvaluationFunction(Color c); - Value apply(const Position &pos); -}; +template +struct EndgameBase { + virtual ~EndgameBase() {} + virtual Color color() const = 0; + virtual T operator()(const Position&) const = 0; +}; -/// Abstract base class for all evaluation scaling functions: -class ScalingFunction { -public: - ScalingFunction(Color c); - virtual ~ScalingFunction() { } +template::type> +struct Endgame : public EndgameBase { - virtual ScaleFactor apply(const Position &pos) =0; + explicit Endgame(Color c) : strongerSide(c), weakerSide(flip(c)) {} + Color color() const { return strongerSide; } + T operator()(const Position&) const; -protected: +private: Color strongerSide, weakerSide; }; -/// Subclasses for various concrete endgames: +/// Endgames class stores in two std::map the pointers to endgame evaluation +/// and scaling base objects. Then we use polymorphism to invoke the actual +/// endgame function calling its apply() method that is virtual. -// KBP vs K: -class KBPKScalingFunction : public ScalingFunction { -public: - KBPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; +struct Endgames { -// KQ vs KRP: -class KQKRPScalingFunction: public ScalingFunction { -public: - KQKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + template + struct Map { typedef std::map*> type; }; -// KRP vs KR: -class KRPKRScalingFunction : public ScalingFunction { -public: - KRPKRScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + typedef Map::type M1; + typedef Map::type M2; -// KRPP vs KRP: -class KRPPKRPScalingFunction : public ScalingFunction { -public: - KRPPKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + Endgames(); + ~Endgames(); -// King and pawns vs king: -class KPsKScalingFunction : public ScalingFunction { -public: - KPsKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + template + EndgameBase* get(Key key) const { -// KBP vs KB: -class KBPKBScalingFunction : public ScalingFunction { -public: - KBPKBScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + typedef typename Map::type M; + typename M::const_iterator it = map().find(key); + return it != map().end() ? it->second : NULL; + } -// KBP vs KN: -class KBPKNScalingFunction : public ScalingFunction { -public: - KBPKNScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KNP vs K: -class KNPKScalingFunction : public ScalingFunction { -public: - KNPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; +private: + template void add(const std::string& keyCode); + template const M& map() const; -// KP vs KP: -class KPKPScalingFunction : public ScalingFunction { -public: - KPKPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); + M1 m1; + M2 m2; }; - -//// -//// Constants and variables -//// - -// Generic "mate lone king" eval: -extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX; - -// KBN vs K: -extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN; - -// KP vs K: -extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP; - -// KR vs KP: -extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR; - -// KR vs KB: -extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR; - -// KR vs KN: -extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR; - -// KQ vs KR: -extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ; - -// KBP vs K: -extern KBPKScalingFunction ScaleKBPK, ScaleKKBP; - -// KQ vs KRP: -extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ; - -// KRP vs KR: -extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP; - -// KRPP vs KRP: -extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP; - -// King and pawns vs king: -extern KPsKScalingFunction ScaleKPsK, ScaleKKPs; - -// KBP vs KB: -extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP; - -// KBP vs KN: -extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP; - -// KNP vs K: -extern KNPKScalingFunction ScaleKNPK, ScaleKKNP; - -// KP vs KP: -extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb; - - -//// -//// Prototypes -//// - -extern void init_bitbases(); - - #endif // !defined(ENDGAME_H_INCLUDED)