*/
#include <cassert>
+#include <algorithm>
#include "bitcount.h"
#include "endgame.h"
return Position(fen, false, 0).get_material_key();
}
- typedef EndgameBase<Value> EF;
- typedef EndgameBase<ScaleFactor> SF;
-
} // namespace
/// Endgames member definitions
-template<> const Endgames::EFMap& Endgames::map<EF>() const { return maps.first; }
-template<> const Endgames::SFMap& Endgames::map<SF>() const { return maps.second; }
+template<> const Endgames::M1& Endgames::map<Endgames::M1>() const { return m1; }
+template<> const Endgames::M2& Endgames::map<Endgames::M2>() const { return m2; }
Endgames::Endgames() {
- add<Value, KPK>("KPK");
- add<Value, KNNK>("KNNK");
- add<Value, KBNK>("KBNK");
- add<Value, KRKP>("KRKP");
- add<Value, KRKB>("KRKB");
- add<Value, KRKN>("KRKN");
- add<Value, KQKR>("KQKR");
- add<Value, KBBKN>("KBBKN");
-
- add<ScaleFactor, KNPK>("KNPK");
- add<ScaleFactor, KRPKR>("KRPKR");
- add<ScaleFactor, KBPKB>("KBPKB");
- add<ScaleFactor, KBPKN>("KBPKN");
- add<ScaleFactor, KBPPKB>("KBPPKB");
- add<ScaleFactor, KRPPKRP>("KRPPKRP");
+ add<KPK>("KPK");
+ add<KNNK>("KNNK");
+ add<KBNK>("KBNK");
+ add<KRKP>("KRKP");
+ add<KRKB>("KRKB");
+ add<KRKN>("KRKN");
+ add<KQKR>("KQKR");
+ add<KBBKN>("KBBKN");
+
+ add<KNPK>("KNPK");
+ add<KRPKR>("KRPKR");
+ add<KBPKB>("KBPKB");
+ add<KBPKN>("KBPKN");
+ add<KBPPKB>("KBPPKB");
+ add<KRPPKRP>("KRPPKRP");
}
Endgames::~Endgames() {
- for (EFMap::const_iterator it = map<EF>().begin(); it != map<EF>().end(); ++it)
+ for (M1::const_iterator it = m1.begin(); it != m1.end(); ++it)
delete it->second;
- for (SFMap::const_iterator it = map<SF>().begin(); it != map<SF>().end(); ++it)
+ for (M2::const_iterator it = m2.begin(); it != m2.end(); ++it)
delete it->second;
}
-template<typename T, EndgameType E>
+template<EndgameType E>
void Endgames::add(const string& keyCode) {
- typedef Endgame<T, E> EG;
- typedef typename EG::Base B;
- typedef std::map<Key, B*> M;
+ typedef typename eg_family<E>::type T;
+ typedef typename Map<T>::type M;
- const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(keyCode), new EG(WHITE)));
- const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(swap_colors(keyCode)), new EG(BLACK)));
+ const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(keyCode), new Endgame<E>(WHITE)));
+ const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(swap_colors(keyCode)), new Endgame<E>(BLACK)));
}
-template<typename T>
-EndgameBase<T>* Endgames::get(Key key) const {
-
- typedef EndgameBase<T> E;
- typename std::map<Key, E*>::const_iterator it = map<E>().find(key);
- return it != map<E>().end() ? it->second : NULL;
-}
-
-// Explicit template instantiations
-template EF* Endgames::get<Value>(Key key) const;
-template SF* Endgames::get<ScaleFactor>(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 Endgame<Value, KXK>::apply(const Position& pos) const {
+Value Endgame<KXK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
/// 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 Endgame<Value, KBNK>::apply(const Position& pos) const {
+Value Endgame<KBNK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
// 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 (opposite_color_squares(bishopSquare, SQ_A1))
+ if (opposite_colors(bishopSquare, SQ_A1))
{
- winnerKSq = flop_square(winnerKSq);
- loserKSq = flop_square(loserKSq);
+ winnerKSq = mirror(winnerKSq);
+ loserKSq = mirror(loserKSq);
}
Value result = VALUE_KNOWN_WIN
/// KP vs K. This endgame is evaluated with the help of a bitbase.
template<>
-Value Endgame<Value, KPK>::apply(const Position& pos) const {
+Value Endgame<KPK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
}
else
{
- wksq = flip_square(pos.king_square(BLACK));
- bksq = flip_square(pos.king_square(WHITE));
- wpsq = flip_square(pos.piece_list(BLACK, PAWN)[0]);
- stm = opposite_color(pos.side_to_move());
+ wksq = flip(pos.king_square(BLACK));
+ bksq = flip(pos.king_square(WHITE));
+ wpsq = flip(pos.piece_list(BLACK, PAWN)[0]);
+ stm = flip(pos.side_to_move());
}
- if (square_file(wpsq) >= FILE_E)
+ if (file_of(wpsq) >= FILE_E)
{
- wksq = flop_square(wksq);
- bksq = flop_square(bksq);
- wpsq = flop_square(wpsq);
+ wksq = mirror(wksq);
+ bksq = mirror(bksq);
+ wpsq = mirror(wpsq);
}
if (!probe_kpk_bitbase(wksq, wpsq, bksq, stm))
Value result = VALUE_KNOWN_WIN
+ PawnValueEndgame
- + Value(square_rank(wpsq));
+ + Value(rank_of(wpsq));
return strongerSide == pos.side_to_move() ? result : -result;
}
/// far advanced with support of the king, while the attacking king is far
/// away.
template<>
-Value Endgame<Value, KRKP>::apply(const Position& pos) const {
+Value Endgame<KRKP>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
if (strongerSide == BLACK)
{
- wksq = flip_square(wksq);
- wrsq = flip_square(wrsq);
- bksq = flip_square(bksq);
- bpsq = flip_square(bpsq);
+ wksq = flip(wksq);
+ wrsq = flip(wrsq);
+ bksq = flip(bksq);
+ bpsq = flip(bpsq);
}
- Square queeningSq = make_square(square_file(bpsq), RANK_1);
+ Square queeningSq = make_square(file_of(bpsq), RANK_1);
Value result;
// If the stronger side's king is in front of the pawn, it's a win
- if (wksq < bpsq && square_file(wksq) == square_file(bpsq))
+ if (wksq < bpsq && file_of(wksq) == file_of(bpsq))
result = RookValueEndgame - Value(square_distance(wksq, bpsq));
// If the weaker side's king is too far from the pawn and the rook,
// If the pawn is far advanced and supported by the defending king,
// the position is drawish
- else if ( square_rank(bksq) <= RANK_3
+ else if ( rank_of(bksq) <= RANK_3
&& square_distance(bksq, bpsq) == 1
- && square_rank(wksq) >= RANK_4
+ && rank_of(wksq) >= RANK_4
&& square_distance(wksq, bpsq) - tempo > 2)
result = Value(80 - square_distance(wksq, bpsq) * 8);
/// 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 Endgame<Value, KRKB>::apply(const Position& pos) const {
+Value Endgame<KRKB>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
/// 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 Endgame<Value, KRKN>::apply(const Position& pos) const {
+Value Endgame<KRKN>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
/// for the defending side in the search, this is usually sufficient to be
/// able to win KQ vs KR.
template<>
-Value Endgame<Value, KQKR>::apply(const Position& pos) const {
+Value Endgame<KQKR>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 0);
}
template<>
-Value Endgame<Value, KBBKN>::apply(const Position& pos) const {
+Value Endgame<KBBKN>::operator()(const Position& pos) const {
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.pieces(PAWN) == EmptyBoardBB);
+ assert(!pos.pieces(PAWN));
Value result = BishopValueEndgame;
Square wksq = pos.king_square(strongerSide);
/// K and two minors vs K and one or two minors or K and two knights against
/// king alone are always draw.
template<>
-Value Endgame<Value, KmmKm>::apply(const Position&) const {
+Value Endgame<KmmKm>::operator()(const Position&) const {
return VALUE_DRAW;
}
template<>
-Value Endgame<Value, KNNK>::apply(const Position&) const {
+Value Endgame<KNNK>::operator()(const Position&) const {
return VALUE_DRAW;
}
/// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
/// will be used.
template<>
-ScaleFactor Endgame<ScaleFactor, KBPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
// be detected even when the weaker side has some pawns.
Bitboard pawns = pos.pieces(PAWN, strongerSide);
- File pawnFile = square_file(pos.piece_list(strongerSide, PAWN)[0]);
+ File pawnFile = file_of(pos.piece_list(strongerSide, PAWN)[0]);
// All pawns are on a single rook file ?
if ( (pawnFile == FILE_A || pawnFile == FILE_H)
- && (pawns & ~file_bb(pawnFile)) == EmptyBoardBB)
+ && !(pawns & ~file_bb(pawnFile)))
{
Square bishopSq = pos.piece_list(strongerSide, BISHOP)[0];
Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8));
Square kingSq = pos.king_square(weakerSide);
- if ( opposite_color_squares(queeningSq, bishopSq)
- && abs(square_file(kingSq) - pawnFile) <= 1)
+ if ( opposite_colors(queeningSq, bishopSq)
+ && abs(file_of(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
Rank rank;
if (strongerSide == WHITE)
{
- for (rank = RANK_7; (rank_bb(rank) & pawns) == EmptyBoardBB; rank--) {}
+ for (rank = RANK_7; !(rank_bb(rank) & pawns); rank--) {}
assert(rank >= RANK_2 && rank <= RANK_7);
}
else
{
- for (rank = RANK_2; (rank_bb(rank) & pawns) == EmptyBoardBB; rank++) {}
+ for (rank = RANK_2; !(rank_bb(rank) & pawns); rank++) {}
rank = Rank(rank ^ 7); // HACK to get the relative rank
assert(rank >= RANK_2 && rank <= RANK_7);
}
/// It tests for fortress draws with a rook on the third rank defended by
/// a pawn.
template<>
-ScaleFactor Endgame<ScaleFactor, KQKRPs>::apply(const Position& pos) const {
+ScaleFactor Endgame<KQKRPs>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
assert(pos.piece_count(strongerSide, QUEEN) == 1);
/// 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 Endgame<ScaleFactor, KRPKR>::apply(const Position& pos) const {
+ScaleFactor Endgame<KRPKR>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 1);
// pawn is on the left half of the board.
if (strongerSide == BLACK)
{
- wksq = flip_square(wksq);
- wrsq = flip_square(wrsq);
- wpsq = flip_square(wpsq);
- bksq = flip_square(bksq);
- brsq = flip_square(brsq);
+ wksq = flip(wksq);
+ wrsq = flip(wrsq);
+ wpsq = flip(wpsq);
+ bksq = flip(bksq);
+ brsq = flip(brsq);
}
- if (square_file(wpsq) > FILE_D)
+ if (file_of(wpsq) > FILE_D)
{
- wksq = flop_square(wksq);
- wrsq = flop_square(wrsq);
- wpsq = flop_square(wpsq);
- bksq = flop_square(bksq);
- brsq = flop_square(brsq);
+ wksq = mirror(wksq);
+ wrsq = mirror(wrsq);
+ wpsq = mirror(wpsq);
+ bksq = mirror(bksq);
+ brsq = mirror(brsq);
}
- File f = square_file(wpsq);
- Rank r = square_rank(wpsq);
+ File f = file_of(wpsq);
+ Rank r = rank_of(wpsq);
Square queeningSq = make_square(f, RANK_8);
int tempo = (pos.side_to_move() == strongerSide);
if ( r <= RANK_5
&& square_distance(bksq, queeningSq) <= 1
&& wksq <= SQ_H5
- && (square_rank(brsq) == RANK_6 || (r <= RANK_3 && square_rank(wrsq) != RANK_6)))
+ && (rank_of(brsq) == RANK_6 || (r <= RANK_3 && rank_of(wrsq) != RANK_6)))
return SCALE_FACTOR_ZERO;
// 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
&& square_distance(bksq, queeningSq) <= 1
- && square_rank(wksq) + tempo <= RANK_6
- && (square_rank(brsq) == RANK_1 || (!tempo && abs(square_file(brsq) - f) >= 3)))
+ && rank_of(wksq) + tempo <= RANK_6
+ && (rank_of(brsq) == RANK_1 || (!tempo && abs(file_of(brsq) - f) >= 3)))
return SCALE_FACTOR_ZERO;
if ( r >= RANK_6
&& bksq == queeningSq
- && square_rank(brsq) == RANK_1
+ && rank_of(brsq) == RANK_1
&& (!tempo || square_distance(wksq, wpsq) >= 2))
return SCALE_FACTOR_ZERO;
if ( wpsq == SQ_A7
&& wrsq == SQ_A8
&& (bksq == SQ_H7 || bksq == SQ_G7)
- && square_file(brsq) == FILE_A
- && (square_rank(brsq) <= RANK_3 || square_file(wksq) >= FILE_D || square_rank(wksq) <= RANK_5))
+ && file_of(brsq) == FILE_A
+ && (rank_of(brsq) <= RANK_3 || file_of(wksq) >= FILE_D || rank_of(wksq) <= RANK_5))
return SCALE_FACTOR_ZERO;
// If the defending king blocks the pawn and the attacking king is too far
// and the defending king cannot gain tempi by threatening the attacking rook.
if ( r == RANK_7
&& f != FILE_A
- && square_file(wrsq) == f
+ && file_of(wrsq) == f
&& wrsq != queeningSq
&& (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
&& (square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo))
// Similar to the above, but with the pawn further back
if ( f != FILE_A
- && square_file(wrsq) == f
+ && file_of(wrsq) == f
&& wrsq < wpsq
&& (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo)
&& (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wpsq + DELTA_N) - 2 + tempo)
// the pawn's path, it's probably a draw.
if (r <= RANK_4 && bksq > wpsq)
{
- if (square_file(bksq) == square_file(wpsq))
+ if (file_of(bksq) == file_of(wpsq))
return ScaleFactor(10);
- if ( abs(square_file(bksq) - square_file(wpsq)) == 1
+ if ( abs(file_of(bksq) - file_of(wpsq)) == 1
&& square_distance(wksq, bksq) > 2)
return ScaleFactor(24 - 2 * square_distance(wksq, bksq));
}
/// single pattern: If the stronger side has no pawns and the defending king
/// is actively placed, the position is drawish.
template<>
-ScaleFactor Endgame<ScaleFactor, KRPPKRP>::apply(const Position& pos) const {
+ScaleFactor Endgame<KRPPKRP>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
assert(pos.piece_count(strongerSide, PAWN) == 2);
|| pos.pawn_is_passed(strongerSide, wpsq2))
return SCALE_FACTOR_NONE;
- Rank r = Max(relative_rank(strongerSide, wpsq1), relative_rank(strongerSide, wpsq2));
+ Rank r = std::max(relative_rank(strongerSide, wpsq1), relative_rank(strongerSide, wpsq2));
if ( file_distance(bksq, wpsq1) <= 1
&& file_distance(bksq, wpsq2) <= 1
/// 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 Endgame<ScaleFactor, KPsK>::apply(const Position& pos) const {
+ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.piece_count(strongerSide, PAWN) >= 2);
Bitboard pawns = pos.pieces(PAWN, strongerSide);
// Are all pawns on the 'a' file?
- if ((pawns & ~FileABB) == EmptyBoardBB)
+ if (!(pawns & ~FileABB))
{
// Does the defending king block the pawns?
if ( square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
- || ( square_file(ksq) == FILE_A
- && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB))
+ || ( file_of(ksq) == FILE_A
+ && !in_front_bb(strongerSide, ksq) & pawns))
return SCALE_FACTOR_ZERO;
}
// Are all pawns on the 'h' file?
- else if ((pawns & ~FileHBB) == EmptyBoardBB)
+ else if (!(pawns & ~FileHBB))
{
// Does the defending king block the pawns?
if ( square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
- || ( square_file(ksq) == FILE_H
- && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB))
+ || ( file_of(ksq) == FILE_H
+ && !in_front_bb(strongerSide, ksq) & pawns))
return SCALE_FACTOR_ZERO;
}
return SCALE_FACTOR_NONE;
/// it's a draw. If the two bishops have opposite color, it's almost always
/// a draw.
template<>
-ScaleFactor Endgame<ScaleFactor, KBPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<KBPKB>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
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)
+ if ( file_of(weakerKingSq) == file_of(pawnSq)
&& relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
- && ( opposite_color_squares(weakerKingSq, strongerBishopSq)
+ && ( opposite_colors(weakerKingSq, strongerBishopSq)
|| relative_rank(strongerSide, weakerKingSq) <= RANK_6))
return SCALE_FACTOR_ZERO;
// Case 2: Opposite colored bishops
- if (opposite_color_squares(strongerBishopSq, weakerBishopSq))
+ if (opposite_colors(strongerBishopSq, weakerBishopSq))
{
// We assume that the position is drawn in the following three situations:
//
/// KBPPKBScalingFunction scales KBPP vs KB endgames. It detects a few basic
/// draws with opposite-colored bishops.
template<>
-ScaleFactor Endgame<ScaleFactor, KBPPKB>::apply(const Position& pos) const {
+ScaleFactor Endgame<KBPPKB>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
Square wbsq = pos.piece_list(strongerSide, BISHOP)[0];
Square bbsq = pos.piece_list(weakerSide, BISHOP)[0];
- if (!opposite_color_squares(wbsq, bbsq))
+ if (!opposite_colors(wbsq, bbsq))
return SCALE_FACTOR_NONE;
Square ksq = pos.king_square(weakerSide);
Square psq1 = pos.piece_list(strongerSide, PAWN)[0];
Square psq2 = pos.piece_list(strongerSide, PAWN)[1];
- Rank r1 = square_rank(psq1);
- Rank r2 = square_rank(psq2);
+ Rank r1 = rank_of(psq1);
+ Rank r2 = rank_of(psq2);
Square blockSq1, blockSq2;
if (relative_rank(strongerSide, psq1) > relative_rank(strongerSide, psq2))
{
blockSq1 = psq1 + pawn_push(strongerSide);
- blockSq2 = make_square(square_file(psq2), square_rank(psq1));
+ blockSq2 = make_square(file_of(psq2), rank_of(psq1));
}
else
{
blockSq1 = psq2 + pawn_push(strongerSide);
- blockSq2 = make_square(square_file(psq1), square_rank(psq2));
+ blockSq2 = make_square(file_of(psq1), rank_of(psq2));
}
switch (file_distance(psq1, psq2))
case 0:
// Both pawns are on the same file. Easy draw if defender firmly controls
// some square in the frontmost pawn's path.
- if ( square_file(ksq) == square_file(blockSq1)
+ if ( file_of(ksq) == file_of(blockSq1)
&& relative_rank(strongerSide, ksq) >= relative_rank(strongerSide, blockSq1)
- && opposite_color_squares(ksq, wbsq))
+ && opposite_colors(ksq, wbsq))
return SCALE_FACTOR_ZERO;
else
return SCALE_FACTOR_NONE;
// 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
- && opposite_color_squares(ksq, wbsq)
+ && opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq2
|| (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
|| abs(r1 - r2) >= 2))
return SCALE_FACTOR_ZERO;
else if ( ksq == blockSq2
- && opposite_color_squares(ksq, wbsq)
+ && opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq1
|| (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
return SCALE_FACTOR_ZERO;
/// square of the king is not of the same color as the stronger side's bishop,
/// it's a draw.
template<>
-ScaleFactor Endgame<ScaleFactor, KBPKN>::apply(const Position& pos) const {
+ScaleFactor Endgame<KBPKN>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
assert(pos.piece_count(strongerSide, BISHOP) == 1);
Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP)[0];
Square weakerKingSq = pos.king_square(weakerSide);
- if ( square_file(weakerKingSq) == square_file(pawnSq)
+ if ( file_of(weakerKingSq) == file_of(pawnSq)
&& relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
- && ( opposite_color_squares(weakerKingSq, strongerBishopSq)
+ && ( opposite_colors(weakerKingSq, strongerBishopSq)
|| relative_rank(strongerSide, weakerKingSq) <= RANK_6))
return SCALE_FACTOR_ZERO;
/// 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 Endgame<ScaleFactor, KNPK>::apply(const Position& pos) const {
+ScaleFactor Endgame<KNPK>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
assert(pos.piece_count(strongerSide, KNIGHT) == 1);
/// 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 Endgame<ScaleFactor, KPKP>::apply(const Position& pos) const {
+ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {
assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
}
else
{
- wksq = flip_square(pos.king_square(BLACK));
- bksq = flip_square(pos.king_square(WHITE));
- wpsq = flip_square(pos.piece_list(BLACK, PAWN)[0]);
- stm = opposite_color(pos.side_to_move());
+ wksq = flip(pos.king_square(BLACK));
+ bksq = flip(pos.king_square(WHITE));
+ wpsq = flip(pos.piece_list(BLACK, PAWN)[0]);
+ stm = flip(pos.side_to_move());
}
- if (square_file(wpsq) >= FILE_E)
+ if (file_of(wpsq) >= FILE_E)
{
- wksq = flop_square(wksq);
- bksq = flop_square(bksq);
- wpsq = flop_square(wpsq);
+ wksq = mirror(wksq);
+ bksq = mirror(bksq);
+ wpsq = mirror(wpsq);
}
// If the pawn has advanced to the fifth rank or further, and is not a
// rook pawn, it's too dangerous to assume that it's at least a draw.
- if ( square_rank(wpsq) >= RANK_5
- && square_file(wpsq) != FILE_A)
+ if ( rank_of(wpsq) >= RANK_5
+ && file_of(wpsq) != FILE_A)
return SCALE_FACTOR_NONE;
// Probe the KPK bitbase with the weakest side's pawn removed. If it's a
projects / stockfish / blobdiff