Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
Key enpassant[FILE_NB];
- Key castling[CASTLING_FLAG_NB];
+ Key castling[CASTLING_RIGHT_NB];
Key side;
Key exclusion;
}
else
continue;
- set_castling_flag(c, rsq);
+ set_castling_right(c, rsq);
}
// 4. En passant square. Ignore if no pawn capture is possible
}
-/// Position::set_castling_flag() is a helper function used to set castling
-/// flags given the corresponding color and the rook starting square.
+/// Position::set_castling_right() is a helper function used to set castling
+/// rights given the corresponding color and the rook starting square.
-void Position::set_castling_flag(Color c, Square rfrom) {
+void Position::set_castling_right(Color c, Square rfrom) {
Square kfrom = king_square(c);
CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
- CastlingFlag cf = make_castling_flag(c, cs);
+ CastlingRight cr = (c | cs);
- st->castlingFlags |= cf;
- castlingFlagsMask[kfrom] |= cf;
- castlingFlagsMask[rfrom] |= cf;
- castlingRookSquare[c][cs] = rfrom;
+ st->castlingRights |= cr;
+ castlingRightsMask[kfrom] |= cr;
+ castlingRightsMask[rfrom] |= cr;
+ castlingRookSquare[cr] = 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[cr] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
- castlingPath[c][cs] |= s;
+ castlingPath[cr] |= s;
}
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 (!can_castle(WHITE) && !can_castle(BLACK))
ss << '-';
- ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
+ 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 / discovered check
-/// pieces, according to the call parameters. Pinned pieces protect our king and
-/// discovered 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(Color c, Color kingColor) const {
+Bitboard Position::check_blockers(Color c, Color kingColor) const {
Bitboard b, pinners, result = 0;
Square ksq = king_square(kingColor);
}
-/// 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 {
// 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?
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
// of direct checks and ordinary discovered check, so the only case we
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);
st->epSquare = SQ_NONE;
}
- // Update castling flags if needed
- if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to]))
+ // Update castling rights if needed
+ if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to]))
{
- int cf = castlingFlagsMask[from] | castlingFlagsMask[to];
- k ^= Zobrist::castling[st->castlingFlags & cf];
- st->castlingFlags &= ~cf;
+ int cr = castlingRightsMask[from] | castlingRightsMask[to];
+ k ^= Zobrist::castling[st->castlingRights & cr];
+ st->castlingRights &= ~cr;
}
// Prefetch TT access as soon as we know the new hash key
/// Position::see() is a static exchange evaluator: It tries to estimate the
/// 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) 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;
}
+ stm = ~stm;
+ stmAttackers = attackers & pieces(stm);
+ ++slIndex;
+
} while (stmAttackers);
// Having built the swap list, we negamax through it to find the best
Key Position::compute_key() const {
- Key k = Zobrist::castling[st->castlingFlags];
+ Key k = Zobrist::castling[st->castlingRights];
for (Bitboard b = pieces(); b; )
{
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];
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 ( (castlingRightsMask[king_square(c)] & (c | s)) != (c | s)
+ || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK)
+ || castlingRightsMask[castlingRookSquare[c | s]] != (c | s))
return false;
}
projects / stockfish / blobdiff