X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.h;h=5ea40bbf91b995070a7bf804b52ecc8c0fec548e;hp=cb087b4b4cfe0e3686081f2543c3a31c5c4d2d3d;hb=45b0aea875860e9f0fe2d0435ee6163906639194;hpb=67375f4693c97fb1321864bb4d143812cd824f9b diff --git a/src/endgame.h b/src/endgame.h index cb087b4b..5ea40bbf 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008 Marco Costalba + Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, 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,109 +17,106 @@ along with this program. If not, see . */ - -#if !defined(ENDGAME_H_INCLUDED) +#ifndef 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 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 - KBPKN, // KBP vs KN - KNPK, // KNP vs K - KPKP // KP vs KP + // Evaluation functions + + KNNK, // KNN vs K + 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 + KBBKN, // KBB vs KN + KmmKm, // K and one or two minors vs K and zero or one minor + + + // Scaling functions + SCALE_FUNS, + + 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 + KNPKB, // KNP vs KB + KPKP // KP vs KP }; -/// Template abstract base class for all special endgame functions + +/// Endgame functions can be of two types according if return a Value or a +/// ScaleFactor. Type eg_fun::type equals to either ScaleFactor or Value +/// depending if the template parameter is 0 or 1. + +template struct eg_fun { typedef Value type; }; +template<> struct eg_fun<1> { typedef ScaleFactor type; }; + + +/// Base and derived templates for endgame evaluation and scaling functions template -class EndgameFunctionBase { -public: - EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); } - virtual ~EndgameFunctionBase() {} - virtual T apply(const Position&) = 0; +struct EndgameBase { -protected: - Color strongerSide, weakerSide; + virtual ~EndgameBase() {} + virtual Color color() const = 0; + virtual T operator()(const Position&) const = 0; }; -typedef EndgameFunctionBase EndgameEvaluationFunctionBase; -typedef EndgameFunctionBase EndgameScalingFunctionBase; +template SCALE_FUNS)>::type> +struct Endgame : public EndgameBase { -/// Templates subclass for various concrete endgames + explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {} + Color color() const { return strongerSide; } + T operator()(const Position&) const; -template -struct EvaluationFunction : public EndgameEvaluationFunctionBase { - explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {} - Value apply(const Position&); +private: + Color strongerSide, weakerSide; }; -template -struct ScalingFunction : public EndgameScalingFunctionBase { - explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {} - ScaleFactor apply(const Position&); -}; +/// 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 operator() that is virtual. -//// -//// Constants and variables -//// +class Endgames { -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: + typedef std::map::type>*> M1; + typedef std::map::type>*> M2; -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 ScaleKBPKN, ScaleKNKBP; // KBP vs KN -extern ScalingFunction ScaleKNPK, ScaleKKNP; // KNP vs K -extern ScalingFunction ScaleKPKPw, ScaleKPKPb; // KP vs KP + M1 m1; + M2 m2; -//// -//// Prototypes -//// + M1& map(M1::mapped_type) { return m1; } + M2& map(M2::mapped_type) { return m2; } -extern void init_bitbases(); + template void add(const std::string& code); +public: + Endgames(); + ~Endgames(); + + template T probe(Key key, T& eg) + { return eg = map(eg).count(key) ? map(eg)[key] : NULL; } +}; -#endif // !defined(ENDGAME_H_INCLUDED) +#endif // #ifndef ENDGAME_H_INCLUDED