X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fendgame.cpp;h=4d93811e7c5d15fa2fc47d1ab16e97377a448d29;hp=c320ba309dd120010dbd808bd6345e2d9935fa01;hb=f178f0a2912082e2e9d07d9b0926031322d78f67;hpb=bb751d6c890f5c50c642366d601740366cfae8d0 diff --git a/src/endgame.cpp b/src/endgame.cpp index c320ba30..4d93811e 100644 --- a/src/endgame.cpp +++ b/src/endgame.cpp @@ -1,13 +1,14 @@ /* - Glaurung, a UCI chess playing engine. - Copyright (C) 2004-2008 Tord Romstad + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008 Marco Costalba - Glaurung is free software: you can redistribute it and/or modify + Stockfish is free software: you can redistribute it and/or modify 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. - Glaurung is distributed in the hope that it will be useful, + 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. @@ -61,6 +62,13 @@ KRKNEvaluationFunction EvaluateKNKR = KRKNEvaluationFunction(BLACK); KQKREvaluationFunction EvaluateKQKR = KQKREvaluationFunction(WHITE); KQKREvaluationFunction EvaluateKRKQ = KQKREvaluationFunction(BLACK); +// KBB vs KN: +KBBKNEvaluationFunction EvaluateKBBKN = KBBKNEvaluationFunction(WHITE); +KBBKNEvaluationFunction EvaluateKNKBB = KBBKNEvaluationFunction(BLACK); + +// K and two minors vs K and one or two minors: +KmmKmEvaluationFunction EvaluateKmmKm = KmmKmEvaluationFunction(WHITE); + /// Scaling functions @@ -186,6 +194,8 @@ KRKPEvaluationFunction::KRKPEvaluationFunction(Color c) : EndgameEvaluationFunct KRKBEvaluationFunction::KRKBEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { } KRKNEvaluationFunction::KRKNEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { } KQKREvaluationFunction::KQKREvaluationFunction(Color c) : EndgameEvaluationFunction(c) { } +KBBKNEvaluationFunction::KBBKNEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { } +KmmKmEvaluationFunction::KmmKmEvaluationFunction(Color c) : EndgameEvaluationFunction(c) { } ScalingFunction::ScalingFunction(Color c) { @@ -212,19 +222,19 @@ KPKPScalingFunction::KPKPScalingFunction(Color c) : ScalingFunction(c) { } Value KXKEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(weakerSide) == Value(0)); + assert(pos.piece_count(weakerSide, PAWN) == Value(0)); Square winnerKSq = pos.king_square(strongerSide); Square loserKSq = pos.king_square(weakerSide); Value result = pos.non_pawn_material(strongerSide) + - pos.pawn_count(strongerSide) * PawnValueEndgame + + pos.piece_count(strongerSide, PAWN) * PawnValueEndgame + mate_table(loserKSq) + distance_bonus(square_distance(winnerKSq, loserKSq)); - if(pos.queen_count(strongerSide) > 0 || pos.rook_count(strongerSide) > 0 || - pos.bishop_count(strongerSide) > 1) + if(pos.piece_count(strongerSide, QUEEN) > 0 || pos.piece_count(strongerSide, ROOK) > 0 || + pos.piece_count(strongerSide, BISHOP) > 1) // TODO: check for two equal-colored bishops! result += VALUE_KNOWN_WIN; @@ -238,16 +248,16 @@ Value KXKEvaluationFunction::apply(const Position &pos) { Value KBNKEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(weakerSide) == Value(0)); + assert(pos.piece_count(weakerSide, PAWN) == Value(0)); assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame + BishopValueMidgame); - assert(pos.bishop_count(strongerSide) == 1); - assert(pos.knight_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) == 0); + assert(pos.piece_count(strongerSide, BISHOP) == 1); + assert(pos.piece_count(strongerSide, KNIGHT) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 0); Square winnerKSq = pos.king_square(strongerSide); Square loserKSq = pos.king_square(weakerSide); - Square bishopSquare = pos.bishop_list(strongerSide, 0); + Square bishopSquare = pos.piece_list(strongerSide, BISHOP, 0); if(square_color(bishopSquare) == BLACK) { winnerKSq = flop_square(winnerKSq); @@ -268,8 +278,8 @@ Value KPKEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(strongerSide) == 1); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(strongerSide, PAWN) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 0); Square wksq, bksq, wpsq; Color stm; @@ -277,13 +287,13 @@ Value KPKEvaluationFunction::apply(const Position &pos) { if(strongerSide == WHITE) { wksq = pos.king_square(WHITE); bksq = pos.king_square(BLACK); - wpsq = pos.pawn_list(WHITE, 0); + wpsq = pos.piece_list(WHITE, PAWN, 0); stm = pos.side_to_move(); } else { wksq = flip_square(pos.king_square(BLACK)); bksq = flip_square(pos.king_square(WHITE)); - wpsq = flip_square(pos.pawn_list(BLACK, 0)); + wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0)); stm = opposite_color(pos.side_to_move()); } @@ -311,17 +321,17 @@ Value KPKEvaluationFunction::apply(const Position &pos) { Value KRKPEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); - assert(pos.pawn_count(strongerSide) == 0); + assert(pos.piece_count(strongerSide, PAWN) == 0); assert(pos.non_pawn_material(weakerSide) == 0); - assert(pos.pawn_count(weakerSide) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 1); Square wksq, wrsq, bksq, bpsq; int tempo = (pos.side_to_move() == strongerSide); wksq = pos.king_square(strongerSide); - wrsq = pos.rook_list(strongerSide, 0); + wrsq = pos.piece_list(strongerSide, ROOK, 0); bksq = pos.king_square(weakerSide); - bpsq = pos.pawn_list(weakerSide, 0); + bpsq = pos.piece_list(weakerSide, PAWN, 0); if(strongerSide == BLACK) { wksq = flip_square(wksq); @@ -366,10 +376,10 @@ Value KRKPEvaluationFunction::apply(const Position &pos) { Value KRKBEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); - assert(pos.pawn_count(strongerSide) == 0); + assert(pos.piece_count(strongerSide, PAWN) == 0); assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame); - assert(pos.pawn_count(weakerSide) == 0); - assert(pos.bishop_count(weakerSide) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 0); + assert(pos.piece_count(weakerSide, BISHOP) == 1); Value result = mate_table(pos.king_square(weakerSide)); return (pos.side_to_move() == strongerSide)? result : -result; @@ -382,13 +392,13 @@ Value KRKBEvaluationFunction::apply(const Position &pos) { Value KRKNEvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); - assert(pos.pawn_count(strongerSide) == 0); + assert(pos.piece_count(strongerSide, PAWN) == 0); assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame); - assert(pos.pawn_count(weakerSide) == 0); - assert(pos.knight_count(weakerSide) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 0); + assert(pos.piece_count(weakerSide, KNIGHT) == 1); Square defendingKSq = pos.king_square(weakerSide); - Square nSq = pos.knight_list(weakerSide, 0); + Square nSq = pos.piece_list(weakerSide, KNIGHT, 0); Value result = Value(10) + mate_table(defendingKSq) + krkn_king_knight_distance_penalty(square_distance(defendingKSq, nSq)); @@ -405,9 +415,9 @@ Value KRKNEvaluationFunction::apply(const Position &pos) { Value KQKREvaluationFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); - assert(pos.pawn_count(strongerSide) == 0); + assert(pos.piece_count(strongerSide, PAWN) == 0); assert(pos.non_pawn_material(weakerSide) == RookValueMidgame); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, PAWN) == 0); Square winnerKSq = pos.king_square(strongerSide); Square loserKSq = pos.king_square(weakerSide); @@ -419,6 +429,36 @@ Value KQKREvaluationFunction::apply(const Position &pos) { } +Value KBBKNEvaluationFunction::apply(const Position &pos) { + assert(pos.piece_count(strongerSide, BISHOP) == 2); + assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame); + assert(pos.piece_count(weakerSide, KNIGHT) == 1); + assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame); + assert(pos.pawns() == EmptyBoardBB); + + Value result = BishopValueEndgame; + Square wksq = pos.king_square(strongerSide); + Square bksq = pos.king_square(weakerSide); + Square nsq = pos.piece_list(weakerSide, KNIGHT, 0); + + // Bonus for attacking king close to defending king + result += distance_bonus(square_distance(wksq, bksq)); + + // Bonus for driving the defending king and knight apart + result += Value(square_distance(bksq, nsq) * 32); + + // Bonus for restricting the knight's mobility + result += Value((8 - count_1s_max_15(pos.piece_attacks(nsq))) * 8); + + return (strongerSide == pos.side_to_move())? result : -result; +} + + +Value KmmKmEvaluationFunction::apply(const Position &pos) { + return Value(0); +} + + /// KBPKScalingFunction scales endgames where the stronger side has king, /// bishop and one or more pawns. It checks for draws with rook pawns and a /// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is @@ -427,20 +467,20 @@ Value KQKREvaluationFunction::apply(const Position &pos) { ScaleFactor KBPKScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); - assert(pos.bishop_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) >= 1); + assert(pos.piece_count(strongerSide, BISHOP) == 1); + assert(pos.piece_count(strongerSide, PAWN) >= 1); // No assertions about the material of weakerSide, because we want draws to // be detected even when the weaker side has some pawns. Bitboard pawns = pos.pawns(strongerSide); - File pawnFile = square_file(pos.pawn_list(strongerSide, 0)); + File pawnFile = square_file(pos.piece_list(strongerSide, PAWN, 0)); if((pawnFile == FILE_A || pawnFile == FILE_H) && (pawns & ~file_bb(pawnFile)) == EmptyBoardBB) { // All pawns are on a single rook file. - Square bishopSq = pos.bishop_list(strongerSide, 0); + Square bishopSq = pos.piece_list(strongerSide, BISHOP, 0); Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8)); Square kingSq = pos.king_square(weakerSide); @@ -464,7 +504,7 @@ ScaleFactor KBPKScalingFunction::apply(const Position &pos) { // If the defending king has distance 1 to the promotion square or // is placed somewhere in front of the pawn, it's a draw. if(square_distance(kingSq, queeningSq) <= 1 || - pawn_rank(strongerSide, kingSq) >= rank) + relative_rank(strongerSide, kingSq) >= rank) return ScaleFactor(0); } } @@ -479,18 +519,18 @@ ScaleFactor KBPKScalingFunction::apply(const Position &pos) { ScaleFactor KQKRPScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); - assert(pos.queen_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) == 0); - assert(pos.rook_count(weakerSide) == 1); - assert(pos.pawn_count(weakerSide) >= 1); + assert(pos.piece_count(strongerSide, QUEEN) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 0); + assert(pos.piece_count(weakerSide, ROOK) == 1); + assert(pos.piece_count(weakerSide, PAWN) >= 1); Square kingSq = pos.king_square(weakerSide); - if(pawn_rank(weakerSide, kingSq) <= RANK_2 && - pawn_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4 && + if(relative_rank(weakerSide, kingSq) <= RANK_2 && + relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4 && (pos.rooks(weakerSide) & relative_rank_bb(weakerSide, RANK_3)) && (pos.pawns(weakerSide) & relative_rank_bb(weakerSide, RANK_2)) && - (pos.king_attacks(kingSq) & pos.pawns(weakerSide))) { - Square rsq = pos.rook_list(weakerSide, 0); + (pos.piece_attacks(kingSq) & pos.pawns(weakerSide))) { + Square rsq = pos.piece_list(weakerSide, ROOK, 0); if(pos.pawn_attacks(strongerSide, rsq) & pos.pawns(weakerSide)) return ScaleFactor(0); } @@ -508,15 +548,15 @@ ScaleFactor KQKRPScalingFunction::apply(const Position &pos) { ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); - assert(pos.pawn_count(strongerSide) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == RookValueMidgame); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, PAWN) == 0); Square wksq = pos.king_square(strongerSide); - Square wrsq = pos.rook_list(strongerSide, 0); - Square wpsq = pos.pawn_list(strongerSide, 0); + Square wrsq = pos.piece_list(strongerSide, ROOK, 0); + Square wpsq = pos.piece_list(strongerSide, PAWN, 0); Square bksq = pos.king_square(weakerSide); - Square brsq = pos.rook_list(weakerSide, 0); + Square brsq = pos.piece_list(weakerSide, ROOK, 0); // Orient the board in such a way that the stronger side is white, and the // pawn is on the left half of the board: @@ -603,6 +643,16 @@ ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { - (8 * square_distance(wpsq, queeningSq) + 2 * square_distance(wksq, queeningSq))); + // If the pawn is not far advanced, and the defending king is somewhere in + // the pawn's path, it's probably a draw: + if(r <= RANK_4 && bksq > wpsq) { + if(square_file(bksq) == square_file(wpsq)) + return ScaleFactor(10); + if(abs(square_file(bksq) - square_file(wpsq)) == 1 + && square_distance(wksq, bksq) > 2) + return ScaleFactor(24 - 2 * square_distance(wksq, bksq)); + } + return SCALE_FACTOR_NONE; } @@ -613,12 +663,12 @@ ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); - assert(pos.pawn_count(strongerSide) == 2); + assert(pos.piece_count(strongerSide, PAWN) == 2); assert(pos.non_pawn_material(weakerSide) == RookValueMidgame); - assert(pos.pawn_count(weakerSide) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 1); - Square wpsq1 = pos.pawn_list(strongerSide, 0); - Square wpsq2 = pos.pawn_list(strongerSide, 1); + Square wpsq1 = pos.piece_list(strongerSide, PAWN, 0); + Square wpsq2 = pos.piece_list(strongerSide, PAWN, 1); Square bksq = pos.king_square(weakerSide); // Does the stronger side have a passed pawn? @@ -626,10 +676,10 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { pos.pawn_is_passed(strongerSide, wpsq2)) return SCALE_FACTOR_NONE; - Rank r = Max(pawn_rank(strongerSide, wpsq1), pawn_rank(strongerSide, wpsq2)); + Rank r = Max(relative_rank(strongerSide, wpsq1), relative_rank(strongerSide, wpsq2)); if(file_distance(bksq, wpsq1) <= 1 && file_distance(bksq, wpsq2) <= 1 - && pawn_rank(strongerSide, bksq) > r) { + && relative_rank(strongerSide, bksq) > r) { switch(r) { case RANK_2: return ScaleFactor(10); @@ -651,9 +701,9 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { ScaleFactor KPsKScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == Value(0)); - assert(pos.pawn_count(strongerSide) >= 2); + assert(pos.piece_count(strongerSide, PAWN) >= 2); assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, PAWN) == 0); Bitboard pawns = pos.pawns(strongerSide); @@ -694,22 +744,22 @@ ScaleFactor KPsKScalingFunction::apply(const Position &pos) { ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); - assert(pos.bishop_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) == 1); + assert(pos.piece_count(strongerSide, BISHOP) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame); - assert(pos.bishop_count(weakerSide) == 1); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, BISHOP) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 0); - Square pawnSq = pos.pawn_list(strongerSide, 0); - Square strongerBishopSq = pos.bishop_list(strongerSide, 0); - Square weakerBishopSq = pos.bishop_list(weakerSide, 0); + Square pawnSq = pos.piece_list(strongerSide, PAWN, 0); + Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0); + Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP, 0); Square weakerKingSq = pos.king_square(weakerSide); // Case 1: Defending king blocks the pawn, and cannot be driven away. if(square_file(weakerKingSq) == square_file(pawnSq) - && pawn_rank(strongerSide, pawnSq) < pawn_rank(strongerSide, weakerKingSq) + && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) && (square_color(weakerKingSq) != square_color(strongerBishopSq) - || pawn_rank(strongerSide, weakerKingSq) <= RANK_6)) + || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return ScaleFactor(0); // Case 2: Opposite colored bishops. @@ -725,14 +775,14 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { // These rules are probably not perfect, but in practice they work // reasonably well. - if(pawn_rank(strongerSide, pawnSq) <= RANK_5) + if(relative_rank(strongerSide, pawnSq) <= RANK_5) return ScaleFactor(0); else { Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S); if(ray & pos.kings(weakerSide)) return ScaleFactor(0); - if((pos.bishop_attacks(weakerBishopSq) & ray) + if((pos.piece_attacks(weakerBishopSq) & ray) && square_distance(weakerBishopSq, pawnSq) >= 3) return ScaleFactor(0); } @@ -748,20 +798,20 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { ScaleFactor KBPKNScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); - assert(pos.bishop_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) == 1); + assert(pos.piece_count(strongerSide, BISHOP) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame); - assert(pos.knight_count(weakerSide) == 1); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, KNIGHT) == 1); + assert(pos.piece_count(weakerSide, PAWN) == 0); - Square pawnSq = pos.pawn_list(strongerSide, 0); - Square strongerBishopSq = pos.bishop_list(strongerSide, 0); + Square pawnSq = pos.piece_list(strongerSide, PAWN, 0); + Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0); Square weakerKingSq = pos.king_square(weakerSide); if(square_file(weakerKingSq) == square_file(pawnSq) - && pawn_rank(strongerSide, pawnSq) < pawn_rank(strongerSide, weakerKingSq) + && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) && (square_color(weakerKingSq) != square_color(strongerBishopSq) - || pawn_rank(strongerSide, weakerKingSq) <= RANK_6)) + || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return ScaleFactor(0); return SCALE_FACTOR_NONE; @@ -774,12 +824,12 @@ ScaleFactor KBPKNScalingFunction::apply(const Position &pos) { ScaleFactor KNPKScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame); - assert(pos.knight_count(strongerSide) == 1); - assert(pos.pawn_count(strongerSide) == 1); + assert(pos.piece_count(strongerSide, KNIGHT) == 1); + assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(weakerSide) == 0); + assert(pos.piece_count(weakerSide, PAWN) == 0); - Square pawnSq = pos.pawn_list(strongerSide, 0); + Square pawnSq = pos.piece_list(strongerSide, PAWN, 0); Square weakerKingSq = pos.king_square(weakerSide); if(pawnSq == relative_square(strongerSide, SQ_A7) && @@ -804,8 +854,8 @@ ScaleFactor KNPKScalingFunction::apply(const Position &pos) { ScaleFactor KPKPScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.non_pawn_material(weakerSide) == Value(0)); - assert(pos.pawn_count(WHITE) == 1); - assert(pos.pawn_count(BLACK) == 1); + assert(pos.piece_count(WHITE, PAWN) == 1); + assert(pos.piece_count(BLACK, PAWN) == 1); Square wksq, bksq, wpsq; Color stm; @@ -813,13 +863,13 @@ ScaleFactor KPKPScalingFunction::apply(const Position &pos) { if(strongerSide == WHITE) { wksq = pos.king_square(WHITE); bksq = pos.king_square(BLACK); - wpsq = pos.pawn_list(WHITE, 0); + wpsq = pos.piece_list(WHITE, PAWN, 0); stm = pos.side_to_move(); } else { wksq = flip_square(pos.king_square(BLACK)); bksq = flip_square(pos.king_square(WHITE)); - wpsq = flip_square(pos.pawn_list(BLACK, 0)); + wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0)); stm = opposite_color(pos.side_to_move()); }