X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.cpp;h=44a34d607fb69676fd12b662f2b56f2c18e26003;hp=bb756f3b20cd558922c4fc6c416b055e962c3b6d;hb=b5d5646c840d63710552fdaf2521a054dd3b8a18;hpb=469e7c5143af0785d6ba41cdef731ac1f403141c diff --git a/src/endgame.cpp b/src/endgame.cpp index bb756f3b..44a34d60 100644 --- a/src/endgame.cpp +++ b/src/endgame.cpp @@ -17,20 +17,15 @@ along with this program. If not, see . */ - -//// -//// Includes -//// - #include #include "bitcount.h" #include "endgame.h" +#include "pawns.h" +using std::string; -//// -//// Local definitions -//// +extern uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm); namespace { @@ -68,9 +63,6 @@ namespace { // and knight in KR vs KN endgames. const int KRKNKingKnightDistancePenalty[8] = { 0, 0, 4, 10, 20, 32, 48, 70 }; - // Bitbase for KP vs K - uint8_t KPKBitbase[24576]; - // Various inline functions for accessing the above arrays inline Value mate_table(Square s) { return Value(MateTable[s]); @@ -88,32 +80,102 @@ namespace { return Value(KRKNKingKnightDistancePenalty[d]); } - // Function for probing the KP vs K bitbase - int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm); + // 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() { -//// -//// Functions -//// + for (EFMap::const_iterator it = get().begin(); it != get().end(); ++it) + delete it->second; -/// init_bitbases() is called during program initialization, and simply loads -/// bitbases from disk into memory. At the moment, there is only the bitbase -/// for KP vs K, but we may decide to add other bitbases later. -extern void generate_kpk_bitbase(uint8_t bitbase[]); + 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; -void init_bitbases() { - generate_kpk_bitbase(KPKBitbase); + 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); @@ -139,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); @@ -155,7 +217,7 @@ Value EvaluationFunction::apply(const Position& pos) const { // kbnk_mate_table() tries to drive toward corners A1 or H8, // if we have a bishop that cannot reach the above squares we // mirror the kings so to drive enemy toward corners A8 or H1. - if (!same_color_squares(bishopSquare, SQ_A1)) + if (opposite_color_squares(bishopSquare, SQ_A1)) { winnerKSq = flop_square(winnerKSq); loserKSq = flop_square(loserKSq); @@ -171,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); @@ -203,7 +265,7 @@ Value EvaluationFunction::apply(const Position& pos) const { wpsq = flop_square(wpsq); } - if (!probe_kpk(wksq, wpsq, bksq, stm)) + if (!probe_kpk_bitbase(wksq, wpsq, bksq, stm)) return VALUE_DRAW; Value result = VALUE_KNOWN_WIN @@ -219,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); @@ -276,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); @@ -292,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); @@ -318,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); @@ -337,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); @@ -366,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; } @@ -381,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); @@ -401,8 +463,8 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8)); Square kingSq = pos.king_square(weakerSide); - if ( !same_color_squares(queeningSq, bishopSq) - && file_distance(square_file(kingSq), pawnFile) <= 1) + if ( opposite_color_squares(queeningSq, bishopSq) + && abs(square_file(kingSq) - pawnFile) <= 1) { // The bishop has the wrong color, and the defending king is on the // file of the pawn(s) or the neighboring file. Find the rank of the @@ -435,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); @@ -446,8 +508,8 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { Square kingSq = pos.king_square(weakerSide); if ( relative_rank(weakerSide, kingSq) <= RANK_2 && relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4 - && (pos.pieces(ROOK, weakerSide) & relative_rank_bb(weakerSide, RANK_3)) - && (pos.pieces(PAWN, weakerSide) & relative_rank_bb(weakerSide, RANK_2)) + && (pos.pieces(ROOK, weakerSide) & rank_bb(relative_rank(weakerSide, RANK_3))) + && (pos.pieces(PAWN, weakerSide) & rank_bb(relative_rank(weakerSide, RANK_2))) && (pos.attacks_from(kingSq) & pos.pieces(PAWN, weakerSide))) { Square rsq = pos.piece_list(weakerSide, ROOK, 0); @@ -466,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); @@ -584,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); @@ -623,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); @@ -661,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); @@ -678,12 +740,12 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { // Case 1: Defending king blocks the pawn, and cannot be driven away if ( square_file(weakerKingSq) == square_file(pawnSq) && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) - && ( !same_color_squares(weakerKingSq, strongerBishopSq) + && ( opposite_color_squares(weakerKingSq, strongerBishopSq) || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return SCALE_FACTOR_ZERO; // Case 2: Opposite colored bishops - if (!same_color_squares(strongerBishopSq, weakerBishopSq)) + if (opposite_color_squares(strongerBishopSq, weakerBishopSq)) { // We assume that the position is drawn in the following three situations: // @@ -699,11 +761,12 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { return SCALE_FACTOR_ZERO; else { - Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S); - if (ray & pos.pieces(KING, weakerSide)) + Bitboard path = squares_in_front_of(strongerSide, pawnSq); + + if (path & pos.pieces(KING, weakerSide)) return SCALE_FACTOR_ZERO; - if ( (pos.attacks_from(weakerBishopSq) & ray) + if ( (pos.attacks_from(weakerBishopSq) & path) && square_distance(weakerBishopSq, pawnSq) >= 3) return SCALE_FACTOR_ZERO; } @@ -715,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); @@ -727,8 +790,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { Square wbsq = pos.piece_list(strongerSide, BISHOP, 0); Square bbsq = pos.piece_list(weakerSide, BISHOP, 0); - if (same_color_squares(wbsq, bbsq)) - // Not opposite-colored bishops, no scaling + if (!opposite_color_squares(wbsq, bbsq)) return SCALE_FACTOR_NONE; Square ksq = pos.king_square(weakerSide); @@ -756,7 +818,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { // some square in the frontmost pawn's path. if ( square_file(ksq) == square_file(blockSq1) && relative_rank(strongerSide, ksq) >= relative_rank(strongerSide, blockSq1) - && !same_color_squares(ksq, wbsq)) + && opposite_color_squares(ksq, wbsq)) return SCALE_FACTOR_ZERO; else return SCALE_FACTOR_NONE; @@ -766,14 +828,14 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { // in front of the frontmost pawn's path, and the square diagonally behind // this square on the file of the other pawn. if ( ksq == blockSq1 - && !same_color_squares(ksq, wbsq) + && opposite_color_squares(ksq, wbsq) && ( bbsq == blockSq2 || (pos.attacks_from(blockSq2) & pos.pieces(BISHOP, weakerSide)) - || rank_distance(r1, r2) >= 2)) + || abs(r1 - r2) >= 2)) return SCALE_FACTOR_ZERO; else if ( ksq == blockSq2 - && !same_color_squares(ksq, wbsq) + && opposite_color_squares(ksq, wbsq) && ( bbsq == blockSq1 || (pos.attacks_from(blockSq1) & pos.pieces(BISHOP, weakerSide)))) return SCALE_FACTOR_ZERO; @@ -792,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); @@ -807,7 +869,7 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { if ( square_file(weakerKingSq) == square_file(pawnSq) && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) - && ( !same_color_squares(weakerKingSq, strongerBishopSq) + && ( opposite_color_squares(weakerKingSq, strongerBishopSq) || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return SCALE_FACTOR_ZERO; @@ -819,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); @@ -849,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); @@ -889,21 +951,5 @@ ScaleFactor ScalingFunction::apply(const Position& pos) const { // Probe the KPK bitbase with the weakest side's pawn removed. If it's a // draw, it's probably at least a draw even with the pawn. - return probe_kpk(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_ZERO; -} - - -namespace { - - // Probe the KP vs K bitbase - - int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm) { - - int wp = square_file(wpsq) + 4 * (square_rank(wpsq) - 1); - int index = int(stm) + 2 * bksq + 128 * wksq + 8192 * wp; - - assert(index >= 0 && index < 24576 * 8); - - return KPKBitbase[index / 8] & (1 << (index & 7)); - } + return probe_kpk_bitbase(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_ZERO; }