#include <algorithm>
#include <cassert>
+#include "bitboard.h"
#include "bitcount.h"
#include "endgame.h"
+#include "movegen.h"
using std::string;
-extern uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm);
-
namespace {
// Table used to drive the defending king towards the edge of the board
string sides[] = { code.substr(code.find('K', 1)), // Weaker
code.substr(0, code.find('K', 1)) }; // Stronger
- 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";
- return Position(fen, false, 0).material_key();
+ return Position(fen, false, NULL).material_key();
}
template<typename M>
template<EndgameType E>
void Endgames::add(const string& code) {
- typedef typename eg_family<E>::type T;
-
- map((T*)0)[key(code, WHITE)] = new Endgame<E>(WHITE);
- map((T*)0)[key(code, BLACK)] = new Endgame<E>(BLACK);
+ map((Endgame<E>*)0)[key(code, WHITE)] = new Endgame<E>(WHITE);
+ map((Endgame<E>*)0)[key(code, BLACK)] = new Endgame<E>(BLACK);
}
assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
+ // Stalemate detection with lone king
+ if ( pos.side_to_move() == weakerSide
+ && !pos.in_check()
+ && !MoveList<LEGAL>(pos).size()) {
+ return VALUE_DRAW;
+ }
+
Square winnerKSq = pos.king_square(strongerSide);
Square loserKSq = pos.king_square(weakerSide);
if ( pos.piece_count(strongerSide, QUEEN)
|| pos.piece_count(strongerSide, ROOK)
- || pos.piece_count(strongerSide, BISHOP) > 1)
- // TODO: check for two equal-colored bishops!
- result += VALUE_KNOWN_WIN;
+ || pos.bishop_pair(strongerSide)) {
+ result += VALUE_KNOWN_WIN;
+ }
return strongerSide == pos.side_to_move() ? result : -result;
}
wpsq = mirror(wpsq);
}
- if (!probe_kpk_bitbase(wksq, wpsq, bksq, stm))
+ if (!Bitbases::probe_kpk(wksq, wpsq, bksq, stm))
return VALUE_DRAW;
Value result = VALUE_KNOWN_WIN
bpsq = ~bpsq;
}
- Square queeningSq = make_square(file_of(bpsq), RANK_1);
+ Square queeningSq = file_of(bpsq) | RANK_1;
Value result;
// If the stronger side's king is in front of the pawn, it's a win
// 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.pieces(PAWN, strongerSide);
+ Bitboard pawns = pos.pieces(strongerSide, PAWN);
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)
+ if ( (pawnFile == FILE_A || pawnFile == FILE_H)
&& !(pawns & ~file_bb(pawnFile)))
{
Square bishopSq = pos.piece_list(strongerSide, BISHOP)[0];
- Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8));
+ Square queeningSq = relative_square(strongerSide, pawnFile | RANK_8);
Square kingSq = pos.king_square(weakerSide);
if ( opposite_colors(queeningSq, bishopSq)
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) & rank_bb(relative_rank(weakerSide, RANK_3)))
- && (pos.pieces(PAWN, weakerSide) & rank_bb(relative_rank(weakerSide, RANK_2)))
- && (pos.attacks_from<KING>(kingSq) & pos.pieces(PAWN, weakerSide)))
+ && (pos.pieces(weakerSide, ROOK) & rank_bb(relative_rank(weakerSide, RANK_3)))
+ && (pos.pieces(weakerSide, PAWN) & rank_bb(relative_rank(weakerSide, RANK_2)))
+ && (pos.attacks_from<KING>(kingSq) & pos.pieces(weakerSide, PAWN)))
{
Square rsq = pos.piece_list(weakerSide, ROOK)[0];
- if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
+ if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(weakerSide, PAWN))
return SCALE_FACTOR_DRAW;
}
return SCALE_FACTOR_NONE;
File f = file_of(wpsq);
Rank r = rank_of(wpsq);
- Square queeningSq = make_square(f, RANK_8);
+ Square queeningSq = f | RANK_8;
int tempo = (pos.side_to_move() == strongerSide);
// If the pawn is not too far advanced and the defending king defends the
assert(pos.piece_count(weakerSide, PAWN) == 0);
Square ksq = pos.king_square(weakerSide);
- Bitboard pawns = pos.pieces(PAWN, strongerSide);
+ Bitboard pawns = pos.pieces(strongerSide, PAWN);
// Are all pawns on the 'a' file?
if (!(pawns & ~FileABB))
{
// Does the defending king block the pawns?
if ( square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
- || ( file_of(ksq) == FILE_A
+ || ( file_of(ksq) == FILE_A
&& !in_front_bb(strongerSide, ksq) & pawns))
return SCALE_FACTOR_DRAW;
}
{
// Does the defending king block the pawns?
if ( square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
- || ( file_of(ksq) == FILE_H
+ || ( file_of(ksq) == FILE_H
&& !in_front_bb(strongerSide, ksq) & pawns))
return SCALE_FACTOR_DRAW;
}
return SCALE_FACTOR_DRAW;
else
{
- Bitboard path = squares_in_front_of(strongerSide, pawnSq);
+ Bitboard path = forward_bb(strongerSide, pawnSq);
- if (path & pos.pieces(KING, weakerSide))
+ if (path & pos.pieces(weakerSide, KING))
return SCALE_FACTOR_DRAW;
if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & path)
if (relative_rank(strongerSide, psq1) > relative_rank(strongerSide, psq2))
{
blockSq1 = psq1 + pawn_push(strongerSide);
- blockSq2 = make_square(file_of(psq2), rank_of(psq1));
+ blockSq2 = file_of(psq2) | rank_of(psq1);
}
else
{
blockSq1 = psq2 + pawn_push(strongerSide);
- blockSq2 = make_square(file_of(psq1), rank_of(psq2));
+ blockSq2 = file_of(psq1) | rank_of(psq2);
}
switch (file_distance(psq1, psq2))
if ( ksq == blockSq1
&& opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq2
- || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
+ || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(weakerSide, BISHOP))
|| abs(r1 - r2) >= 2))
return SCALE_FACTOR_DRAW;
else if ( ksq == blockSq2
&& opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq1
- || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
+ || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(weakerSide, BISHOP))))
return SCALE_FACTOR_DRAW;
else
return SCALE_FACTOR_NONE;
// 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_bitbase(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+ return Bitbases::probe_kpk(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
}
projects / stockfish / blobdiff