X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fendgame.cpp;h=7f26dbf5053c856c9bcc7aab448a9f62fae77290;hb=c97104e8540b72ee2c6c9c13d3773d2c0f9ec32f;hp=366a02d1137458b80085034af0577b4a82903e18;hpb=f036239521fe4f6afb7e8cbc51d860ffa476f6bd;p=stockfish
diff --git a/src/endgame.cpp b/src/endgame.cpp
index 366a02d1..7f26dbf5 100644
--- a/src/endgame.cpp
+++ b/src/endgame.cpp
@@ -1,17 +1,18 @@
/*
- 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.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
@@ -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
@@ -145,7 +153,7 @@ namespace {
const int KRKNKingKnightDistancePenalty[8] = { 0, 0, 4, 10, 20, 32, 48, 70 };
// Various inline functions for accessing the above arrays:
-
+
inline Value mate_table(Square s) {
return Value(MateTable[s]);
}
@@ -166,7 +174,7 @@ namespace {
int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm);
}
-
+
////
//// 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;
@@ -234,20 +244,20 @@ Value KXKEvaluationFunction::apply(const Position &pos) {
/// 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.
-
+
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,22 +278,22 @@ 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;
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,13 +415,13 @@ 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);
-
+
Value result = QueenValueEndgame - RookValueEndgame +
mate_table(loserKSq) + distance_bonus(square_distance(winnerKSq, loserKSq));
@@ -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);
@@ -479,10 +519,10 @@ 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(relative_rank(weakerSide, kingSq) <= RANK_2 &&
@@ -490,7 +530,7 @@ ScaleFactor KQKRPScalingFunction::apply(const Position &pos) {
(pos.rooks(weakerSide) & relative_rank_bb(weakerSide, RANK_3)) &&
(pos.pawns(weakerSide) & relative_rank_bb(weakerSide, RANK_2)) &&
(pos.piece_attacks(kingSq) & pos.pawns(weakerSide))) {
- Square rsq = pos.rook_list(weakerSide, 0);
+ 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?
@@ -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,15 +744,15 @@ 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.
@@ -714,9 +764,9 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
// Case 2: Opposite colored bishops.
if(square_color(strongerBishopSq) != square_color(weakerBishopSq)) {
-
+
// We assume that the position is drawn in the following three situations:
- //
+ //
// a. The pawn is on rank 5 or further back.
// b. The defending king is somewhere in the pawn's path.
// c. The defending bishop attacks some square along the pawn's path,
@@ -724,7 +774,7 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
//
// These rules are probably not perfect, but in practice they work
// reasonably well.
-
+
if(relative_rank(strongerSide, pawnSq) <= RANK_5)
return ScaleFactor(0);
else {
@@ -748,16 +798,16 @@ 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)
&& relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
&& (square_color(weakerKingSq) != square_color(strongerBishopSq)
@@ -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());
}
@@ -859,9 +909,9 @@ namespace {
int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm) {
int wp = int(square_file(wpsq)) + (int(square_rank(wpsq)) - 1) * 4;
int index = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*wp;
-
+
assert(index >= 0 && index < 24576*8);
return KPKBitbase[index/8] & (1 << (index&7));
}
-
+
}