X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.h;h=e4ee9bc8472b13120c7b60bb26b8b9d5ace3bfc1;hp=dabf233e7058f2f367f429badf25bcd00f4fd40e;hb=72c7595f8ac72c7831ee319b8b0bc46404c5fc27;hpb=5dc23121215039938a9ef4e59ae934312774571c diff --git a/src/endgame.h b/src/endgame.h index dabf233e..e4ee9bc8 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -7,12 +7,12 @@ 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. - + 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 . */ @@ -34,149 +34,61 @@ //// Types //// -/// Abstract base class for all special endgame evaluation functions: - -class EndgameEvaluationFunction { -public: - EndgameEvaluationFunction(Color c); - virtual ~EndgameEvaluationFunction() { } - - virtual Value apply(const Position &pos) =0; +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 +}; + +/// Template abstract base class for all special endgame functions + +template +class EndgameFunctionBase { +public: + EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); } + virtual ~EndgameFunctionBase() {} + virtual T apply(const Position&) = 0; protected: Color strongerSide, weakerSide; }; - -/// Subclasses for various concrete endgames: - -// Generic "mate lone king" eval: -class KXKEvaluationFunction : public EndgameEvaluationFunction { -public: - KXKEvaluationFunction(Color c); - Value apply(const Position &pos); -}; - -// 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); -}; - -// KR vs KP: -class KRKPEvaluationFunction : public EndgameEvaluationFunction { -public: - KRKPEvaluationFunction(Color c); - Value apply(const Position &pos); -}; - -// 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); -}; - -// KQ vs KR: -class KQKREvaluationFunction : public EndgameEvaluationFunction { -public: - KQKREvaluationFunction(Color c); - Value apply(const Position &pos); -}; +typedef EndgameFunctionBase EndgameEvaluationFunctionBase; +typedef EndgameFunctionBase EndgameScalingFunctionBase; -/// Abstract base class for all evaluation scaling functions: - -class ScalingFunction { -public: - ScalingFunction(Color c); - virtual ~ScalingFunction() { } +/// Templates subclass for various concrete endgames - virtual ScaleFactor apply(const Position &pos) =0; - -protected: - Color strongerSide, weakerSide; +template +struct EvaluationFunction : public EndgameEvaluationFunctionBase { + explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {} + Value apply(const Position&); }; - -/// Subclasses for various concrete endgames: - -// KBP vs K: -class KBPKScalingFunction : public ScalingFunction { -public: - KBPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KQ vs KRP: -class KQKRPScalingFunction: public ScalingFunction { -public: - KQKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KRP vs KR: -class KRPKRScalingFunction : public ScalingFunction { -public: - KRPKRScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KRPP vs KRP: -class KRPPKRPScalingFunction : public ScalingFunction { -public: - KRPPKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// King and pawns vs king: -class KPsKScalingFunction : public ScalingFunction { -public: - KPsKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KBP vs KB: -class KBPKBScalingFunction : public ScalingFunction { -public: - KBPKBScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// 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); -}; - -// KP vs KP: -class KPKPScalingFunction : public ScalingFunction { -public: - KPKPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); +template +struct ScalingFunction : public EndgameScalingFunctionBase { + explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {} + ScaleFactor apply(const Position&); }; @@ -184,54 +96,26 @@ public: //// 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; - +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: + +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 //// //// Prototypes