X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.h;h=e40b4050756fee4b2fb8489b1a599ae6004aba43;hp=21e8ab6d6e5b6d249a765f0c4381c9cf7465f93a;hb=b5d5646c840d63710552fdaf2521a054dd3b8a18;hpb=039badfda8fa05bc466612bce996837c7d69f22b;ds=sidebyside diff --git a/src/endgame.h b/src/endgame.h index 21e8ab6d..e40b4050 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-2010 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,185 +17,93 @@ 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" - - -//// -//// Types -//// +#include "types.h" -/// Abstract base class for all special endgame evaluation functions -class EndgameEvaluationFunction { -public: - EndgameEvaluationFunction(Color c); - virtual ~EndgameEvaluationFunction() { } +/// EndgameType lists all supported endgames - virtual Value apply(const Position &pos) = 0; +enum EndgameType { -protected: - Color strongerSide, weakerSide; + // 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 + KNNK, // KNN vs K + KmmKm, // K and two minors vs K and one or two minors + + // Scaling functions + 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 }; -/// Template subclass for various concrete endgames +/// Base and derived template class for endgame evaluation and scaling functions -enum EndgameType { - 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 -}; +template +struct EndgameBase { -template -class EvaluationFunction : public EndgameEvaluationFunction { -public: - explicit EvaluationFunction(Color c): EndgameEvaluationFunction(c) {} - Value apply(const Position& pos); -}; + typedef EndgameBase Base; -/// Abstract base class for all evaluation scaling functions: - -class ScalingFunction { -public: - ScalingFunction(Color c); - virtual ~ScalingFunction() { } - - virtual ScaleFactor apply(const Position &pos) =0; + EndgameBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {} + virtual ~EndgameBase() {} + virtual T apply(const Position&) const = 0; + Color color() const { return strongerSide; } protected: Color strongerSide, weakerSide; }; -/// Subclasses for various concrete endgames: +template +struct Endgame : public EndgameBase { -// KBP vs K: -class KBPKScalingFunction : public ScalingFunction { -public: - KBPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); + explicit Endgame(Color c): EndgameBase(c) {} + T apply(const Position&) const; }; -// 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); -}; +/// 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. -// KRPP vs KRP: -class KRPPKRPScalingFunction : public ScalingFunction { -public: - KRPPKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; +class Endgames { -// King and pawns vs king: -class KPsKScalingFunction : public ScalingFunction { -public: - KPsKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + typedef std::map*> EFMap; + typedef std::map*> SFMap; -// KBP vs KB: -class KBPKBScalingFunction : public ScalingFunction { public: - KBPKBScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + Endgames(); + ~Endgames(); + template T* get(Key key) const; -// KBP vs KN: -class KBPKNScalingFunction : public ScalingFunction { -public: - KBPKNScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; +private: + template void add(const std::string& keyCode); -// KNP vs K: -class KNPKScalingFunction : public ScalingFunction { -public: - KNPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; + // Here we store two maps, for evaluate and scaling functions... + std::pair maps; -// KP vs KP: -class KPKPScalingFunction : public ScalingFunction { -public: - KPKPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); + // ...and here is the accessing template function + template const std::map& get() const; }; - -//// -//// Constants and variables -//// - -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: - -// 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)