/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
70, 50, 30, 20, 20, 30, 50, 70,
80, 60, 40, 30, 30, 40, 60, 80,
90, 70, 60, 50, 50, 60, 70, 90,
70, 50, 30, 20, 20, 30, 50, 70,
80, 60, 40, 30, 30, 40, 60, 80,
90, 70, 60, 50, 50, 60, 70, 90,
- 100, 90, 80, 70, 70, 80, 90, 100,
+ 100, 90, 80, 70, 70, 80, 90, 100
const int PushClose[8] = { 0, 0, 100, 80, 60, 40, 20, 10 };
const int PushAway [8] = { 0, 5, 20, 40, 60, 80, 90, 100 };
const int PushClose[8] = { 0, 0, 100, 80, 60, 40, 20, 10 };
const int PushAway [8] = { 0, 5, 20, 40, 60, 80, 90, 100 };
+ // Pawn Rank based scaling factors used in KRPPKRP endgame
+ const int KRPPKRPScaleFactors[RANK_NB] = { 0, 9, 10, 14, 21, 44, 0, 0 };
+
- bool verify_material(const Position& pos, Color c, Value npm, int num_pawns) {
- return pos.non_pawn_material(c) == npm && pos.count<PAWN>(c) == num_pawns;
+ bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) {
+ return pos.non_pawn_material(c) == npm && pos.count<PAWN>(c) == pawnsCnt;
// Get the material key of Position out of the given endgame key code
// like "KBPKN". The trick here is to first forge an ad-hoc FEN string
// Get the material key of Position out of the given endgame key code
// like "KBPKN". The trick here is to first forge an ad-hoc FEN string
Key key(const string& code, Color c) {
assert(code.length() > 0 && code.length() < 8);
Key key(const string& code, Color c) {
assert(code.length() > 0 && code.length() < 8);
std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);
- string fen = sides[0] + char('0' + int(8 - code.length()))
- + sides[1] + "/8/8/8/8/8/8/8 w - - 0 10";
+ string fen = sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/"
+ + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10";
- for_each(m1.begin(), m1.end(), delete_endgame<M1>);
- for_each(m2.begin(), m2.end(), delete_endgame<M2>);
-}
-
-template<EndgameType E>
+template<EndgameType E, typename T>
-
- map((Endgame<E>*)0)[key(code, WHITE)] = new Endgame<E>(WHITE);
- map((Endgame<E>*)0)[key(code, BLACK)] = new Endgame<E>(BLACK);
+ map<T>()[key(code, WHITE)] = std::unique_ptr<EndgameBase<T>>(new Endgame<E>(WHITE));
+ map<T>()[key(code, BLACK)] = std::unique_ptr<EndgameBase<T>>(new Endgame<E>(BLACK));
- || pos.bishop_pair(strongSide))
- result += VALUE_KNOWN_WIN;
+ ||(pos.count<BISHOP>(strongSide) && pos.count<KNIGHT>(strongSide))
+ ||(pos.count<BISHOP>(strongSide) > 1 && opposite_colors(pos.squares<BISHOP>(strongSide)[0],
+ pos.squares<BISHOP>(strongSide)[1])))
+ result = std::min(result + VALUE_KNOWN_WIN, VALUE_MATE_IN_MAX_PLY - 1);
assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
- Square winnerKSq = pos.king_square(strongSide);
- Square loserKSq = pos.king_square(weakSide);
- Square bishopSq = pos.list<BISHOP>(strongSide)[0];
+ Square winnerKSq = pos.square<KING>(strongSide);
+ Square loserKSq = pos.square<KING>(weakSide);
+ Square bishopSq = pos.square<BISHOP>(strongSide);
// kbnk_mate_table() tries to drive toward corners A1 or H8. If we have a
// bishop that cannot reach the above squares, we flip the kings in order
// kbnk_mate_table() tries to drive toward corners A1 or H8. If we have a
// bishop that cannot reach the above squares, we flip the kings in order
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
// Assume strongSide is white and the pawn is on files A-D
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
// Assume strongSide is white and the pawn is on files A-D
- Square wksq = normalize(pos, strongSide, pos.king_square(strongSide));
- Square bksq = normalize(pos, strongSide, pos.king_square(weakSide));
- Square psq = normalize(pos, strongSide, pos.list<PAWN>(strongSide)[0]);
+ Square wksq = normalize(pos, strongSide, pos.square<KING>(strongSide));
+ Square bksq = normalize(pos, strongSide, pos.square<KING>(weakSide));
+ Square psq = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
- if (!Bitbases::probe_kpk(wksq, psq, bksq, us))
+ if (!Bitbases::probe(wksq, psq, bksq, us))
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
- Square wksq = relative_square(strongSide, pos.king_square(strongSide));
- Square bksq = relative_square(strongSide, pos.king_square(weakSide));
- Square rsq = relative_square(strongSide, pos.list<ROOK>(strongSide)[0]);
- Square psq = relative_square(strongSide, pos.list<PAWN>(weakSide)[0]);
+ Square wksq = relative_square(strongSide, pos.square<KING>(strongSide));
+ Square bksq = relative_square(strongSide, pos.square<KING>(weakSide));
+ Square rsq = relative_square(strongSide, pos.square<ROOK>(strongSide));
+ Square psq = relative_square(strongSide, pos.square<PAWN>(weakSide));
Value result;
// If the stronger side's king is in front of the pawn, it's a win
if (wksq < psq && file_of(wksq) == file_of(psq))
Value result;
// If the stronger side's king is in front of the pawn, it's a win
if (wksq < psq && file_of(wksq) == file_of(psq))
- else if ( square_distance(bksq, psq) >= 3 + (pos.side_to_move() == weakSide)
- && square_distance(bksq, rsq) >= 3)
- result = RookValueEg - Value(square_distance(wksq, psq));
+ else if ( distance(bksq, psq) >= 3 + (pos.side_to_move() == weakSide)
+ && distance(bksq, rsq) >= 3)
+ result = RookValueEg - distance(wksq, psq);
// If the pawn is far advanced and supported by the defending king,
// the position is drawish
else if ( rank_of(bksq) <= RANK_3
// If the pawn is far advanced and supported by the defending king,
// the position is drawish
else if ( rank_of(bksq) <= RANK_3
- && square_distance(wksq, psq) > 2 + (pos.side_to_move() == strongSide))
- result = Value(80 - square_distance(wksq, psq) * 8);
+ && distance(wksq, psq) > 2 + (pos.side_to_move() == strongSide))
+ result = Value(80) - 8 * distance(wksq, psq);
- result = Value(200)
- - Value(square_distance(wksq, psq + DELTA_S) * 8)
- + Value(square_distance(bksq, psq + DELTA_S) * 8)
- + Value(square_distance(psq, queeningSq) * 8);
+ result = Value(200) - 8 * ( distance(wksq, psq + DELTA_S)
+ - distance(bksq, psq + DELTA_S)
+ - distance(psq, queeningSq));
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, KnightValueMg, 0));
assert(verify_material(pos, strongSide, RookValueMg, 0));
assert(verify_material(pos, weakSide, KnightValueMg, 0));
- Square bksq = pos.king_square(weakSide);
- Square bnsq = pos.list<KNIGHT>(weakSide)[0];
- Value result = Value(PushToEdges[bksq] + PushAway[square_distance(bksq, bnsq)]);
+ Square bksq = pos.square<KING>(weakSide);
+ Square bnsq = pos.square<KNIGHT>(weakSide);
+ Value result = Value(PushToEdges[bksq] + PushAway[distance(bksq, bnsq)]);
assert(verify_material(pos, strongSide, QueenValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
assert(verify_material(pos, strongSide, QueenValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
- Square winnerKSq = pos.king_square(strongSide);
- Square loserKSq = pos.king_square(weakSide);
- Square pawnSq = pos.list<PAWN>(weakSide)[0];
+ Square winnerKSq = pos.square<KING>(strongSide);
+ Square loserKSq = pos.square<KING>(weakSide);
+ Square pawnSq = pos.square<PAWN>(weakSide);
assert(verify_material(pos, strongSide, QueenValueMg, 0));
assert(verify_material(pos, weakSide, RookValueMg, 0));
assert(verify_material(pos, strongSide, QueenValueMg, 0));
assert(verify_material(pos, weakSide, RookValueMg, 0));
// be detected even when the weaker side has some pawns.
Bitboard pawns = pos.pieces(strongSide, PAWN);
// be detected even when the weaker side has some pawns.
Bitboard pawns = pos.pieces(strongSide, PAWN);
- // All pawns are on a single rook file ?
- if ( (pawnFile == FILE_A || pawnFile == FILE_H)
- && !(pawns & ~file_bb(pawnFile)))
+ // All pawns are on a single rook file?
+ if ( (pawnsFile == FILE_A || pawnsFile == FILE_H)
+ && !(pawns & ~file_bb(pawnsFile)))
- Square bishopSq = pos.list<BISHOP>(strongSide)[0];
- Square queeningSq = relative_square(strongSide, pawnFile | RANK_8);
- Square kingSq = pos.king_square(weakSide);
+ Square bishopSq = pos.square<BISHOP>(strongSide);
+ Square queeningSq = relative_square(strongSide, make_square(pawnsFile, RANK_8));
+ Square kingSq = pos.square<KING>(weakSide);
return SCALE_FACTOR_DRAW;
}
// If all the pawns are on the same B or G file, then it's potentially a draw
return SCALE_FACTOR_DRAW;
}
// If all the pawns are on the same B or G file, then it's potentially a draw
&& pos.non_pawn_material(weakSide) == 0
&& pos.count<PAWN>(weakSide) >= 1)
{
// Get weakSide pawn that is closest to the home rank
Square weakPawnSq = backmost_sq(weakSide, pos.pieces(weakSide, PAWN));
&& pos.non_pawn_material(weakSide) == 0
&& pos.count<PAWN>(weakSide) >= 1)
{
// Get weakSide pawn that is closest to the home rank
Square weakPawnSq = backmost_sq(weakSide, pos.pieces(weakSide, PAWN));
- Square strongKingSq = pos.king_square(strongSide);
- Square weakKingSq = pos.king_square(weakSide);
- Square bishopSq = pos.list<BISHOP>(strongSide)[0];
+ Square strongKingSq = pos.square<KING>(strongSide);
+ Square weakKingSq = pos.square<KING>(weakSide);
+ Square bishopSq = pos.square<BISHOP>(strongSide);
// There's potential for a draw if our pawn is blocked on the 7th rank,
// the bishop cannot attack it or they only have one pawn left
// There's potential for a draw if our pawn is blocked on the 7th rank,
// the bishop cannot attack it or they only have one pawn left
&& (pos.pieces(strongSide, PAWN) & (weakPawnSq + pawn_push(weakSide)))
&& (opposite_colors(bishopSq, weakPawnSq) || pos.count<PAWN>(strongSide) == 1))
{
&& (pos.pieces(strongSide, PAWN) & (weakPawnSq + pawn_push(weakSide)))
&& (opposite_colors(bishopSq, weakPawnSq) || pos.count<PAWN>(strongSide) == 1))
{
- int strongKingDist = square_distance(weakPawnSq, strongKingSq);
- int weakKingDist = square_distance(weakPawnSq, weakKingSq);
+ int strongKingDist = distance(weakPawnSq, strongKingSq);
+ int weakKingDist = distance(weakPawnSq, weakKingSq);
// It's a draw if the weak king is on its back two ranks, within 2
// squares of the blocking pawn and the strong king is not
// It's a draw if the weak king is on its back two ranks, within 2
// squares of the blocking pawn and the strong king is not
&& relative_rank(weakSide, rsq) == RANK_3
&& ( pos.pieces(weakSide, PAWN)
& pos.attacks_from<KING>(kingSq)
&& relative_rank(weakSide, rsq) == RANK_3
&& ( pos.pieces(weakSide, PAWN)
& pos.attacks_from<KING>(kingSq)
assert(verify_material(pos, weakSide, RookValueMg, 0));
// Assume strongSide is white and the pawn is on files A-D
assert(verify_material(pos, weakSide, RookValueMg, 0));
// Assume strongSide is white and the pawn is on files A-D
- Square wksq = normalize(pos, strongSide, pos.king_square(strongSide));
- Square bksq = normalize(pos, strongSide, pos.king_square(weakSide));
- Square wrsq = normalize(pos, strongSide, pos.list<ROOK>(strongSide)[0]);
- Square wpsq = normalize(pos, strongSide, pos.list<PAWN>(strongSide)[0]);
- Square brsq = normalize(pos, strongSide, pos.list<ROOK>(weakSide)[0]);
+ Square wksq = normalize(pos, strongSide, pos.square<KING>(strongSide));
+ Square bksq = normalize(pos, strongSide, pos.square<KING>(weakSide));
+ Square wrsq = normalize(pos, strongSide, pos.square<ROOK>(strongSide));
+ Square wpsq = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
+ Square brsq = normalize(pos, strongSide, pos.square<ROOK>(weakSide));
int tempo = (pos.side_to_move() == strongSide);
// If the pawn is not too far advanced and the defending king defends the
// queening square, use the third-rank defence.
if ( r <= RANK_5
int tempo = (pos.side_to_move() == strongSide);
// If the pawn is not too far advanced and the defending king defends the
// queening square, use the third-rank defence.
if ( r <= RANK_5
// The defending side saves a draw by checking from behind in case the pawn
// has advanced to the 6th rank with the king behind.
if ( r == RANK_6
// The defending side saves a draw by checking from behind in case the pawn
// has advanced to the 6th rank with the king behind.
if ( r == RANK_6
return SCALE_FACTOR_DRAW;
// White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
return SCALE_FACTOR_DRAW;
// White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
- && square_distance(wksq, wpsq) - tempo >= 2
- && square_distance(wksq, brsq) - tempo >= 2)
+ && distance(wksq, wpsq) - tempo >= 2
+ && distance(wksq, brsq) - tempo >= 2)
return SCALE_FACTOR_DRAW;
// Pawn on the 7th rank supported by the rook from behind usually wins if the
return SCALE_FACTOR_DRAW;
// Pawn on the 7th rank supported by the rook from behind usually wins if the
- && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
- && (square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo))
- return ScaleFactor(SCALE_FACTOR_MAX - 2 * square_distance(wksq, queeningSq));
+ && (distance(wksq, queeningSq) < distance(bksq, queeningSq) - 2 + tempo)
+ && (distance(wksq, queeningSq) < distance(bksq, wrsq) + tempo))
+ return ScaleFactor(SCALE_FACTOR_MAX - 2 * distance(wksq, queeningSq));
- && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
- && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wpsq + DELTA_N) - 2 + tempo)
- && ( square_distance(bksq, wrsq) + tempo >= 3
- || ( square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo
- && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wrsq) + tempo))))
+ && (distance(wksq, queeningSq) < distance(bksq, queeningSq) - 2 + tempo)
+ && (distance(wksq, wpsq + DELTA_N) < distance(bksq, wpsq + DELTA_N) - 2 + tempo)
+ && ( distance(bksq, wrsq) + tempo >= 3
+ || ( distance(wksq, queeningSq) < distance(bksq, wrsq) + tempo
+ && (distance(wksq, wpsq + DELTA_N) < distance(bksq, wrsq) + tempo))))
- - 8 * square_distance(wpsq, queeningSq)
- - 2 * square_distance(wksq, queeningSq));
+ - 8 * distance(wpsq, queeningSq)
+ - 2 * 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 the pawn is not far advanced and the defending king is somewhere in
// the pawn's path, it's probably a draw.
- if ( abs(file_of(bksq) - file_of(wpsq)) == 1
- && square_distance(wksq, bksq) > 2)
- return ScaleFactor(24 - 2 * square_distance(wksq, bksq));
+ if ( distance<File>(bksq, wpsq) == 1
+ && distance(wksq, bksq) > 2)
+ return ScaleFactor(24 - 2 * distance(wksq, bksq));
- Square ksq = pos.king_square(weakSide);
- Square bsq = pos.list<BISHOP>(weakSide)[0];
- Square psq = pos.list<PAWN>(strongSide)[0];
+ Square ksq = pos.square<KING>(weakSide);
+ Square bsq = pos.square<BISHOP>(weakSide);
+ Square psq = pos.square<PAWN>(strongSide);
Rank rk = relative_rank(strongSide, psq);
Square push = pawn_push(strongSide);
Rank rk = relative_rank(strongSide, psq);
Square push = pawn_push(strongSide);
// corner but not trapped there.
if (rk == RANK_5 && !opposite_colors(bsq, psq))
{
// corner but not trapped there.
if (rk == RANK_5 && !opposite_colors(bsq, psq))
{
assert(verify_material(pos, strongSide, RookValueMg, 2));
assert(verify_material(pos, weakSide, RookValueMg, 1));
assert(verify_material(pos, strongSide, RookValueMg, 2));
assert(verify_material(pos, weakSide, RookValueMg, 1));
- Square wpsq1 = pos.list<PAWN>(strongSide)[0];
- Square wpsq2 = pos.list<PAWN>(strongSide)[1];
- Square bksq = pos.king_square(weakSide);
+ Square wpsq1 = pos.squares<PAWN>(strongSide)[0];
+ Square wpsq2 = pos.squares<PAWN>(strongSide)[1];
+ Square bksq = pos.square<KING>(weakSide);
// Does the stronger side have a passed pawn?
if (pos.pawn_passed(strongSide, wpsq1) || pos.pawn_passed(strongSide, wpsq2))
// Does the stronger side have a passed pawn?
if (pos.pawn_passed(strongSide, wpsq1) || pos.pawn_passed(strongSide, wpsq2))
Rank r = std::max(relative_rank(strongSide, wpsq1), relative_rank(strongSide, wpsq2));
Rank r = std::max(relative_rank(strongSide, wpsq1), relative_rank(strongSide, wpsq2));
- if ( file_distance(bksq, wpsq1) <= 1
- && file_distance(bksq, wpsq2) <= 1
+ if ( distance<File>(bksq, wpsq1) <= 1
+ && distance<File>(bksq, wpsq2) <= 1
- switch (r) {
- case RANK_2: return ScaleFactor(10);
- case RANK_3: return ScaleFactor(10);
- case RANK_4: return ScaleFactor(15);
- case RANK_5: return ScaleFactor(20);
- case RANK_6: return ScaleFactor(40);
- default: assert(false);
- }
+ assert(r > RANK_1 && r < RANK_7);
+ return ScaleFactor(KRPPKRPScaleFactors[r]);
assert(pos.count<PAWN>(strongSide) >= 2);
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
assert(pos.count<PAWN>(strongSide) >= 2);
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
// If all pawns are ahead of the king, on a single rook file and
// the king is within one file of the pawns, it's a draw.
if ( !(pawns & ~in_front_bb(weakSide, rank_of(ksq)))
&& !((pawns & ~FileABB) && (pawns & ~FileHBB))
// If all pawns are ahead of the king, on a single rook file and
// the king is within one file of the pawns, it's a draw.
if ( !(pawns & ~in_front_bb(weakSide, rank_of(ksq)))
&& !((pawns & ~FileABB) && (pawns & ~FileHBB))
assert(verify_material(pos, strongSide, BishopValueMg, 1));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
assert(verify_material(pos, strongSide, BishopValueMg, 1));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
- Square pawnSq = pos.list<PAWN>(strongSide)[0];
- Square strongBishopSq = pos.list<BISHOP>(strongSide)[0];
- Square weakBishopSq = pos.list<BISHOP>(weakSide)[0];
- Square weakKingSq = pos.king_square(weakSide);
+ Square pawnSq = pos.square<PAWN>(strongSide);
+ Square strongBishopSq = pos.square<BISHOP>(strongSide);
+ Square weakBishopSq = pos.square<BISHOP>(weakSide);
+ Square weakKingSq = pos.square<KING>(weakSide);
// Case 1: Defending king blocks the pawn, and cannot be driven away
if ( file_of(weakKingSq) == file_of(pawnSq)
// Case 1: Defending king blocks the pawn, and cannot be driven away
if ( file_of(weakKingSq) == file_of(pawnSq)
assert(verify_material(pos, strongSide, BishopValueMg, 2));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
assert(verify_material(pos, strongSide, BishopValueMg, 2));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
if (!opposite_colors(wbsq, bbsq))
return SCALE_FACTOR_NONE;
if (!opposite_colors(wbsq, bbsq))
return SCALE_FACTOR_NONE;
- Square ksq = pos.king_square(weakSide);
- Square psq1 = pos.list<PAWN>(strongSide)[0];
- Square psq2 = pos.list<PAWN>(strongSide)[1];
+ Square ksq = pos.square<KING>(weakSide);
+ Square psq1 = pos.squares<PAWN>(strongSide)[0];
+ Square psq2 = pos.squares<PAWN>(strongSide)[1];
if (relative_rank(strongSide, psq1) > relative_rank(strongSide, psq2))
{
blockSq1 = psq1 + pawn_push(strongSide);
if (relative_rank(strongSide, psq1) > relative_rank(strongSide, psq2))
{
blockSq1 = psq1 + pawn_push(strongSide);
&& opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq2
|| (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(weakSide, BISHOP))
&& opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq2
|| (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(weakSide, BISHOP))
assert(verify_material(pos, strongSide, BishopValueMg, 1));
assert(verify_material(pos, weakSide, KnightValueMg, 0));
assert(verify_material(pos, strongSide, BishopValueMg, 1));
assert(verify_material(pos, weakSide, KnightValueMg, 0));
- Square pawnSq = pos.list<PAWN>(strongSide)[0];
- Square strongBishopSq = pos.list<BISHOP>(strongSide)[0];
- Square weakKingSq = pos.king_square(weakSide);
+ Square pawnSq = pos.square<PAWN>(strongSide);
+ Square strongBishopSq = pos.square<BISHOP>(strongSide);
+ Square weakKingSq = pos.square<KING>(weakSide);
if ( file_of(weakKingSq) == file_of(pawnSq)
&& relative_rank(strongSide, pawnSq) < relative_rank(strongSide, weakKingSq)
if ( file_of(weakKingSq) == file_of(pawnSq)
&& relative_rank(strongSide, pawnSq) < relative_rank(strongSide, weakKingSq)
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
// Assume strongSide is white and the pawn is on files A-D
assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
// Assume strongSide is white and the pawn is on files A-D
- Square pawnSq = normalize(pos, strongSide, pos.list<PAWN>(strongSide)[0]);
- Square weakKingSq = normalize(pos, strongSide, pos.king_square(weakSide));
+ Square pawnSq = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
+ Square weakKingSq = normalize(pos, strongSide, pos.square<KING>(weakSide));
- Square pawnSq = pos.list<PAWN>(strongSide)[0];
- Square bishopSq = pos.list<BISHOP>(weakSide)[0];
- Square weakKingSq = pos.king_square(weakSide);
+ Square pawnSq = pos.square<PAWN>(strongSide);
+ Square bishopSq = pos.square<BISHOP>(weakSide);
+ Square weakKingSq = pos.square<KING>(weakSide);
// King needs to get close to promoting pawn to prevent knight from blocking.
// Rules for this are very tricky, so just approximate.
if (forward_bb(strongSide, pawnSq) & pos.attacks_from<BISHOP>(bishopSq))
// King needs to get close to promoting pawn to prevent knight from blocking.
// Rules for this are very tricky, so just approximate.
if (forward_bb(strongSide, pawnSq) & pos.attacks_from<BISHOP>(bishopSq))
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
// Assume strongSide is white and the pawn is on files A-D
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
// Assume strongSide is white and the pawn is on files A-D
- Square wksq = normalize(pos, strongSide, pos.king_square(strongSide));
- Square bksq = normalize(pos, strongSide, pos.king_square(weakSide));
- Square psq = normalize(pos, strongSide, pos.list<PAWN>(strongSide)[0]);
+ Square wksq = normalize(pos, strongSide, pos.square<KING>(strongSide));
+ Square bksq = normalize(pos, strongSide, pos.square<KING>(weakSide));
+ Square psq = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
// 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.
// 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 Bitbases::probe_kpk(wksq, psq, bksq, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+ return Bitbases::probe(wksq, psq, bksq, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;