/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace {
-// min_attacker() is an helper function used by see() to locate the least
+// min_attacker() is a helper function used by see() to locate the least
// valuable attacker for the side to move, remove the attacker we just found
// from the bitboards and scan for new X-ray attacks behind it.
*/
char col, row, token;
- size_t p;
+ size_t idx;
Square sq = SQ_A8;
std::istringstream ss(fenStr);
else if (token == '/')
sq -= Square(16);
- else if ((p = PieceToChar.find(token)) != string::npos)
+ else if ((idx = PieceToChar.find(token)) != string::npos)
{
- put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
+ put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx)));
++sq;
}
}
}
-/// Position::set_castling_flag() is an helper function used to set castling
+/// Position::set_castling_flag() is a helper function used to set castling
/// flags given the corresponding color and the rook starting square.
void Position::set_castling_flag(Color c, Square rfrom) {
Square kfrom = king_square(c);
CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
- CastlingFlag cf = make_castling_flag(c, cs);
+ CastlingFlag cf = (c | cs);
st->castlingFlags |= cf;
castlingFlagsMask[kfrom] |= cf;
castlingFlagsMask[rfrom] |= cf;
- castlingRookSquare[c][cs] = rfrom;
+ castlingRookSquare[cf] = rfrom;
Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
if (s != kfrom && s != rfrom)
- castlingPath[c][cs] |= s;
+ castlingPath[cf] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
- castlingPath[c][cs] |= s;
+ castlingPath[cf] |= s;
}
const string Position::fen() const {
+ int emptyCnt;
std::ostringstream ss;
for (Rank rank = RANK_8; rank >= RANK_1; --rank)
{
for (File file = FILE_A; file <= FILE_H; ++file)
{
- Square sq = file | rank;
-
- if (empty(sq))
- {
- int emptyCnt = 1;
-
- for ( ; file < FILE_H && empty(++sq); ++file)
- ++emptyCnt;
+ for (emptyCnt = 0; file <= FILE_H && empty(file | rank); ++file)
+ ++emptyCnt;
+ if (emptyCnt)
ss << emptyCnt;
- }
- else
- ss << PieceToChar[piece_on(sq)];
+
+ if (file <= FILE_H)
+ ss << PieceToChar[piece_on(file | rank)];
}
if (rank > RANK_1)
ss << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO))
- ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, KING_SIDE)), false) : 'K');
+ ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE | KING_SIDE)), false) : 'K');
if (can_castle(WHITE_OOO))
- ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
+ ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE | QUEEN_SIDE)), false) : 'Q');
if (can_castle(BLACK_OO))
- ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, KING_SIDE)), true) : 'k');
+ ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | KING_SIDE)), true) : 'k');
if (can_castle(BLACK_OOO))
- ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)), true) : 'q');
+ ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | QUEEN_SIDE)), true) : 'q');
- if (st->castlingFlags == NO_CASTLING)
+ if (!can_castle(WHITE) && !can_castle(BLACK))
ss << '-';
- ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
- << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
+ ss << (ep_square() == SQ_NONE ? " - " : " " + to_string(ep_square()) + " ")
+ << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
return ss.str();
}
<< std::setfill('0') << std::setw(16) << st->key << "\nCheckers: ";
for (Bitboard b = checkers(); b; )
- ss << square_to_string(pop_lsb(&b)) << " ";
+ ss << to_string(pop_lsb(&b)) << " ";
ss << "\nLegal moves: ";
for (MoveList<LEGAL> it(*this); *it; ++it)
}
-/// Position:hidden_checkers() returns a bitboard of all pinned / discovery check
-/// pieces, according to the call parameters. Pinned pieces protect our king and
-/// discovery check pieces attack the enemy king.
+/// Position::check_blockers() returns a bitboard of all the pieces with color
+/// 'c' that are blocking check on the king with color 'kingColor'. A piece
+/// blocks a check if removing that piece from the board would result in a
+/// position where the king is in check. A check blocking piece can be either a
+/// pinned or a discovered check piece, according if its color 'c' is the same
+/// or the opposite of 'kingColor'.
-Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
+Bitboard Position::check_blockers(Color c, Color kingColor) const {
Bitboard b, pinners, result = 0;
+ Square ksq = king_square(kingColor);
// Pinners are sliders that give check when a pinned piece is removed
pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq])
- | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(c);
+ | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(~kingColor);
while (pinners)
{
b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
if (!more_than_one(b))
- result |= b & pieces(toMove);
+ result |= b & pieces(c);
}
return result;
}
if (promotion_type(m) - 2 != NO_PIECE_TYPE)
return false;
- // If the from square is not occupied by a piece belonging to the side to
+ // If the 'from' square is not occupied by a piece belonging to the side to
// move, the move is obviously not legal.
if (pc == NO_PIECE || color_of(pc) != us)
return false;
return false;
// We have already handled promotion moves, so destination
- // cannot be on the 8/1th rank.
+ // cannot be on the 8th/1st rank.
if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
return false;
if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to))
return false;
}
- // In case of king moves under check we have to remove king so to catch
- // as invalid moves like b1a1 when opposite queen is on c1.
+ // In case of king moves under check we have to remove king so as to catch
+ // invalid moves like b1a1 when opposite queen is on c1.
else if (attackers_to(to, pieces() ^ from) & pieces(~us))
return false;
}
}
-/// Position::move_gives_check() tests whether a pseudo-legal move gives a check
+/// Position::gives_check() tests whether a pseudo-legal move gives a check
bool Position::gives_check(Move m, const CheckInfo& ci) const {
Square to = to_sq(m);
PieceType pt = type_of(piece_on(from));
- // Is there a direct check ?
+ // Is there a direct check?
if (ci.checkSq[pt] & to)
return true;
- // Is there a discovered check ?
+ // Is there a discovered check?
if ( unlikely(ci.dcCandidates)
&& (ci.dcCandidates & from)
- && !aligned(from, to, king_square(~sideToMove)))
+ && !aligned(from, to, ci.ksq))
return true;
- // Can we skip the ugly special cases ?
+ // Can we skip the ugly special cases?
if (type_of(m) == NORMAL)
return false;
- Color us = sideToMove;
- Square ksq = king_square(~us);
-
switch (type_of(m))
{
case PROMOTION:
- return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
+ return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ci.ksq;
- // En passant capture with check ? We have already handled the case
+ // En passant capture with check? We have already handled the case
// of direct checks and ordinary discovered check, so the only case we
// need to handle is the unusual case of a discovered check through
// the captured pawn.
Square capsq = file_of(to) | rank_of(from);
Bitboard b = (pieces() ^ from ^ capsq) | to;
- return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
- | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
+ return (attacks_bb< ROOK>(ci.ksq, b) & pieces(sideToMove, QUEEN, ROOK))
+ | (attacks_bb<BISHOP>(ci.ksq, b) & pieces(sideToMove, QUEEN, BISHOP));
}
case CASTLING:
{
Square kfrom = from;
Square rfrom = to; // Castling is encoded as 'King captures the rook'
- Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1);
- Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
+ Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1);
+ Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1);
- return (PseudoAttacks[ROOK][rto] & ksq)
- && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ksq);
+ return (PseudoAttacks[ROOK][rto] & ci.ksq)
+ && (attacks_bb<ROOK>(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ci.ksq);
}
default:
assert(false);
++nodes;
Key k = st->key;
- // Copy some fields of old state to our new StateInfo object except the ones
- // which are going to be recalculated from scratch anyway, then switch our state
- // pointer to point to the new (ready to be updated) state.
+ // Copy some fields of the old state to our new StateInfo object except the
+ // ones which are going to be recalculated from scratch anyway and then switch
+ // our state pointer to point to the new (ready to be updated) state.
std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
newSt.previous = st;
// Update side to move
k ^= Zobrist::side;
- // Increment ply counters.In particular rule50 will be reset to zero later on
+ // Increment ply counters. In particular, rule50 will be reset to zero later on
// in case of a capture or a pawn move.
++gamePly;
++st->rule50;
if (ci.checkSq[pt] & to)
st->checkersBB |= to;
- // Discovery checks
+ // Discovered checks
if (ci.dcCandidates && (ci.dcCandidates & from))
{
if (pt != ROOK)
/// Position::see() is a static exchange evaluator: It tries to estimate the
-/// material gain or loss resulting from a move. Parameter 'asymmThreshold' takes
-/// tempi into account. If the side who initiated the capturing sequence does the
-/// last capture, he loses a tempo and if the result is below 'asymmThreshold'
-/// the capturing sequence is considered bad.
+/// material gain or loss resulting from a move.
-int Position::see_sign(Move m) const {
+Value Position::see_sign(Move m) const {
assert(is_ok(m));
// is not less then capturing one. Note that king moves always return
// here because king midgame value is set to 0.
if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))])
- return 1;
+ return VALUE_KNOWN_WIN;
return see(m);
}
-int Position::see(Move m, int asymmThreshold) const {
+Value Position::see(Move m) const {
Square from, to;
Bitboard occupied, attackers, stmAttackers;
- int swapList[32], slIndex = 1;
+ Value swapList[32];
+ int slIndex = 1;
PieceType captured;
Color stm;
// handled correctly. Simply return 0 that is always the correct value
// unless in the rare case the rook ends up under attack.
if (type_of(m) == CASTLING)
- return 0;
+ return VALUE_ZERO;
if (type_of(m) == ENPASSANT)
{
// Add the new entry to the swap list
swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
- ++slIndex;
// Locate and remove the next least valuable attacker
captured = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
- stm = ~stm;
- stmAttackers = attackers & pieces(stm);
// Stop before processing a king capture
- if (captured == KING && stmAttackers)
+ if (captured == KING)
{
- swapList[slIndex++] = QueenValueMg * 16;
+ if (stmAttackers == attackers)
+ ++slIndex;
+
break;
}
- } while (stmAttackers);
+ stm = ~stm;
+ stmAttackers = attackers & pieces(stm);
+ ++slIndex;
- // If we are doing asymmetric SEE evaluation and the same side does the first
- // and the last capture, he loses a tempo and gain must be at least worth
- // 'asymmThreshold', otherwise we replace the score with a very low value,
- // before negamaxing.
- if (asymmThreshold)
- for (int i = 0; i < slIndex; i += 2)
- if (swapList[i] < asymmThreshold)
- swapList[i] = - QueenValueMg * 16;
+ } while (stmAttackers);
// Having built the swap list, we negamax through it to find the best
// achievable score from the point of view of the side to move.
Key k = 0;
for (Color c = WHITE; c <= BLACK; ++c)
- for (PieceType pt = PAWN; pt <= QUEEN; ++pt)
+ for (PieceType pt = PAWN; pt <= KING; ++pt)
for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
k ^= Zobrist::psq[c][pt][cnt];
}
-/// Position::compute_psq_score() computes the incremental scores for the middle
-/// game and the endgame. These functions are used to initialize the incremental
-/// scores when a new position is set up, and to verify that the scores are correctly
+/// Position::compute_psq_score() computes the incremental scores for the middlegame
+/// and the endgame. These functions are used to initialize the incremental scores
+/// when a new position is set up, and to verify that the scores are correctly
/// updated by do_move and undo_move when the program is running in debug mode.
Score Position::compute_psq_score() const {
}
-/// Position::compute_non_pawn_material() computes the total non-pawn middle
-/// game material value for the given side. Material values are updated
-/// incrementally during the search. This function is only used when
-/// initializing a new Position object.
+/// Position::compute_non_pawn_material() computes the total non-pawn middlegame
+/// material value for the given side. Material values are updated incrementally
+/// during the search. This function is only used when initializing a new Position
+/// object.
Value Position::compute_non_pawn_material(Color c) const {
}
-/// Position::is_draw() tests whether the position is drawn by material,
-/// repetition, or the 50 moves rule. It does not detect stalemates: this
-/// must be done by the search.
+/// Position::is_draw() tests whether the position is drawn by material, 50 moves
+/// rule or repetition. It does not detect stalemates.
+
bool Position::is_draw() const {
- // Draw by material?
if ( !pieces(PAWN)
&& (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg))
return true;
- // Draw by the 50 moves rule?
if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
return true;
- int i = 4, e = std::min(st->rule50, st->pliesFromNull);
-
- if (i <= e)
+ StateInfo* stp = st;
+ for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2)
{
- StateInfo* stp = st->previous->previous;
-
- do {
- stp = stp->previous->previous;
-
- if (stp->key == st->key)
- return true; // Draw after first repetition
+ stp = stp->previous->previous;
- i += 2;
-
- } while (i <= e);
+ if (stp->key == st->key)
+ return true; // Draw at first repetition
}
return false;
for (Color c = WHITE; c <= BLACK; ++c)
for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
{
- CastlingFlag cf = make_castling_flag(c, s);
-
- if (!can_castle(cf))
+ if (!can_castle(c | s))
continue;
- if ( (castlingFlagsMask[king_square(c)] & cf) != cf
- || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK)
- || castlingFlagsMask[castlingRookSquare[c][s]] != cf)
+ if ( (castlingFlagsMask[king_square(c)] & (c | s)) != (c | s)
+ || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
+ || castlingFlagsMask[castlingRookSquare[c | s]] != (c | s))
return false;
}