X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.cpp;h=44a34d607fb69676fd12b662f2b56f2c18e26003;hp=754e40317b96b07b27281dd203e7e6303433d0d3;hb=b5d5646c840d63710552fdaf2521a054dd3b8a18;hpb=c1c09844525c764f869b29360519808aab5a7069 diff --git a/src/endgame.cpp b/src/endgame.cpp index 754e4031..44a34d60 100644 --- a/src/endgame.cpp +++ b/src/endgame.cpp @@ -23,7 +23,9 @@ #include "endgame.h" #include "pawns.h" -extern int probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm); +using std::string; + +extern uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm); namespace { @@ -78,15 +80,102 @@ namespace { return Value(KRKNKingKnightDistancePenalty[d]); } + // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP" + const string swapColors(const string& keyCode) { + + size_t idx = keyCode.find('K', 1); + return keyCode.substr(idx) + keyCode.substr(0, idx); + } + + // Build up a fen string with the given pieces, note that the fen string + // could be of an illegal position. + Key buildKey(const string& keyCode) { + + assert(keyCode.length() > 0 && keyCode.length() < 8); + assert(keyCode[0] == 'K'); + + string fen; + bool upcase = false; + + for (size_t i = 0; i < keyCode.length(); i++) + { + if (keyCode[i] == 'K') + upcase = !upcase; + + fen += char(upcase ? toupper(keyCode[i]) : tolower(keyCode[i])); + } + fen += char(8 - keyCode.length() + '0'); + fen += "/8/8/8/8/8/8/8 w - -"; + return Position(fen, false, 0).get_material_key(); + } + + typedef EndgameBase EF; + typedef EndgameBase SF; + +} // namespace + + +/// Endgames member definitions + +template<> const Endgames::EFMap& Endgames::get() const { return maps.first; } +template<> const Endgames::SFMap& Endgames::get() const { return maps.second; } + +Endgames::Endgames() { + + add >("KNNK"); + add >("KPK"); + add >("KBNK"); + add >("KRKP"); + add >("KRKB"); + add >("KRKN"); + add >("KQKR"); + add >("KBBKN"); + + add >("KNPK"); + add >("KRPKR"); + add >("KBPKB"); + add >("KBPPKB"); + add >("KBPKN"); + add >("KRPPKRP"); +} + +Endgames::~Endgames() { + + for (EFMap::const_iterator it = get().begin(); it != get().end(); ++it) + delete it->second; + + for (SFMap::const_iterator it = get().begin(); it != get().end(); ++it) + delete it->second; +} + +template +void Endgames::add(const string& keyCode) { + + typedef typename T::Base F; + typedef std::map M; + + const_cast(get()).insert(std::pair(buildKey(keyCode), new T(WHITE))); + const_cast(get()).insert(std::pair(buildKey(swapColors(keyCode)), new T(BLACK))); } +template +T* Endgames::get(Key key) const { + + typename std::map::const_iterator it = get().find(key); + return it != get().end() ? it->second : NULL; +} + +// Explicit template instantiations +template EF* Endgames::get(Key key) const; +template SF* Endgames::get(Key key) const; + /// Mate with KX vs K. This function is used to evaluate positions with /// King and plenty of material vs a lone king. It simply gives the /// attacking side a bonus for driving the defending king towards the edge /// of the board, and for keeping the distance between the two kings small. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO); @@ -112,7 +201,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the /// defending king towards a corner square of the right color. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO); @@ -144,7 +233,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// KP vs K. This endgame is evaluated with the help of a bitbase. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); @@ -192,7 +281,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// far advanced with support of the king, while the attacking king is far /// away. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 0); @@ -249,7 +338,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// KR vs KB. This is very simple, and always returns drawish scores. The /// score is slightly bigger when the defending king is close to the edge. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 0); @@ -265,7 +354,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// KR vs KN. The attacking side has slightly better winning chances than /// in KR vs KB, particularly if the king and the knight are far apart. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 0); @@ -291,7 +380,7 @@ Value EvaluationFunction::apply(const Position& pos) const { /// for the defending side in the search, this is usually sufficient to be /// able to win KQ vs KR. template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 0); @@ -310,7 +399,7 @@ Value EvaluationFunction::apply(const Position& pos) const { } template<> -Value EvaluationFunction::apply(const Position& pos) const { +Value Endgame::apply(const Position& pos) const { assert(pos.piece_count(strongerSide, BISHOP) == 2); assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame); @@ -339,12 +428,12 @@ Value EvaluationFunction::apply(const Position& pos) const { /// K and two minors vs K and one or two minors or K and two knights against /// king alone are always draw. template<> -Value EvaluationFunction::apply(const Position&) const { +Value Endgame::apply(const Position&) const { return VALUE_DRAW; } template<> -Value EvaluationFunction::apply(const Position&) const { +Value Endgame::apply(const Position&) const { return VALUE_DRAW; } @@ -354,7 +443,7 @@ Value EvaluationFunction::apply(const Position&) const { /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling /// will be used. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -408,7 +497,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// It tests for fortress draws with a rook on the third rank defended by /// a pawn. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); assert(pos.piece_count(strongerSide, QUEEN) == 1); @@ -439,7 +528,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// It would also be nice to rewrite the actual code for this function, /// which is mostly copied from Glaurung 1.x, and not very pretty. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 1); @@ -557,7 +646,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// single pattern: If the stronger side has no pawns and the defending king /// is actively placed, the position is drawish. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 2); @@ -596,7 +685,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// against king. There is just a single rule here: If all pawns are on /// the same rook file and are blocked by the defending king, it's a draw. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.piece_count(strongerSide, PAWN) >= 2); @@ -634,7 +723,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// it's a draw. If the two bishops have opposite color, it's almost always /// a draw. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -689,7 +778,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// KBPPKBScalingFunction scales KBPP vs KB endgames. It detects a few basic /// draws with opposite-colored bishops. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -765,7 +854,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// square of the king is not of the same color as the stronger side's bishop, /// it's a draw. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -792,7 +881,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// If the pawn is a rook pawn on the 7th rank and the defending king prevents /// the pawn from advancing, the position is drawn. template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame); assert(pos.piece_count(strongerSide, KNIGHT) == 1); @@ -822,7 +911,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { /// advanced and not on a rook file; in this case it is often possible to win /// (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1). template<> -ScaleFactor ScalingFunction::apply(const Position& pos) const { +ScaleFactor Endgame::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);