CACHE_LINE_ALIGNMENT
-Score pieceSquareTable[16][64]; // [piece][square]
-Value PieceValue[2][18] = { // [Mg / Eg][piece / pieceType]
+Score pieceSquareTable[PIECE_NB][SQUARE_NB];
+Value PieceValue[PHASE_NB][PIECE_NB] = {
{ VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
{ VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } };
namespace Zobrist {
-Key psq[2][8][64]; // [color][pieceType][square / piece count]
-Key enpassant[8]; // [file]
-Key castle[16]; // [castleRight]
+Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Key enpassant[FILE_NB];
+Key castle[CASTLE_RIGHT_NB];
Key side;
Key exclusion;
for (PieceType pt = PAWN; pt <= KING; pt++)
{
- PieceValue[Mg][make_piece(BLACK, pt)] = PieceValue[Mg][pt];
- PieceValue[Eg][make_piece(BLACK, pt)] = PieceValue[Eg][pt];
+ PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
+ PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
- Score v = make_score(PieceValue[Mg][pt], PieceValue[Eg][pt]);
+ Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
for (Square s = SQ_A1; s <= SQ_H8; s++)
{
} // namespace Zobrist
+namespace {
+
+/// next_attacker() is an helper function used by see() to locate the least
+/// valuable attacker for the side to move, remove the attacker we just found
+/// from the 'occupied' bitboard and scan for new X-ray attacks behind it.
+
+template<int Pt> FORCE_INLINE
+PieceType next_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers,
+ Bitboard& occupied, Bitboard& attackers) {
+
+ if (stmAttackers & bb[Pt])
+ {
+ Bitboard b = stmAttackers & bb[Pt];
+ occupied ^= b & ~(b - 1);
+
+ if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
+ attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
+
+ if (Pt == ROOK || Pt == QUEEN)
+ attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
+
+ return (PieceType)Pt;
+ }
+ return next_attacker<Pt+1>(bb, to, stmAttackers, occupied, attackers);
+}
+
+template<> FORCE_INLINE
+PieceType next_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
+ return KING; // No need to update bitboards, it is the last cycle
+}
+
+} // namespace
+
+
/// CheckInfo c'tor
CheckInfo::CheckInfo(const Position& pos) {
sync_cout;
if (move)
- {
- Position p(*this);
- cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
- }
+ cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "")
+ << move_to_san(*const_cast<Position*>(this), move);
for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
if (piece_on(sq) != NO_PIECE)
}
-/// Position::move_attacks_square() tests whether a move from the current
-/// position attacks a given square.
-
-bool Position::move_attacks_square(Move m, Square s) const {
-
- assert(is_ok(m));
- assert(is_ok(s));
-
- Bitboard occ, xray;
- Square from = from_sq(m);
- Square to = to_sq(m);
- Piece piece = piece_moved(m);
-
- assert(!is_empty(from));
-
- // Update occupancy as if the piece is moving
- occ = pieces() ^ from ^ to;
-
- // The piece moved in 'to' attacks the square 's' ?
- if (attacks_from(piece, to, occ) & s)
- return true;
-
- // Scan for possible X-ray attackers behind the moved piece
- xray = (attacks_bb< ROOK>(s, occ) & pieces(color_of(piece), QUEEN, ROOK))
- | (attacks_bb<BISHOP>(s, occ) & pieces(color_of(piece), QUEEN, BISHOP));
-
- // Verify attackers are triggered by our move and not already existing
- return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
-}
-
-
/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
/// Position::move_gives_check() tests whether a pseudo-legal move gives a check
-bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
+CheckType Position::move_gives_check(Move m, const CheckInfo& ci) const {
assert(is_ok(m));
assert(ci.dcCandidates == discovered_check_candidates());
// Direct check ?
if (ci.checkSq[pt] & to)
- return true;
+ return DIRECT_CHECK;
// Discovery check ?
if (ci.dcCandidates && (ci.dcCandidates & from))
// For pawn and king moves we need to verify also direction
if ( (pt != PAWN && pt != KING)
|| !squares_aligned(from, to, king_square(~sideToMove)))
- return true;
+ return DISCO_CHECK;
}
// Can we skip the ugly special cases ?
if (type_of(m) == NORMAL)
- return false;
+ return NO_CHECK;
Color us = sideToMove;
Square ksq = king_square(~us);
// Promotion with check ?
if (type_of(m) == PROMOTION)
- return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
+ return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq ? DIRECT_CHECK : NO_CHECK;
// En passant capture with check ? We have already handled the case
// of direct checks and ordinary discovered check, the only case we
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));
+ | (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP)) ? DISCO_CHECK : NO_CHECK;
}
// Castling with check ?
Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1);
Bitboard b = (pieces() ^ kfrom ^ rfrom) | rto | kto;
- return attacks_bb<ROOK>(rto, b) & ksq;
+ return attacks_bb<ROOK>(rto, b) & ksq ? DIRECT_CHECK : NO_CHECK;
}
- return false;
+ return NO_CHECK;
}
Key k = st->key;
// Copy some fields of old state to our new StateInfo object except the ones
- // which are recalculated from scratch anyway, then switch our state pointer
- // to point to the new, ready to be updated, state.
- memcpy(&newSt, st, sizeof(ReducedStateInfo));
+ // which are going to be recalculated from scratch anyway, then switch our state
+ // pointer to point to the new, ready to be updated, state.
+ memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
newSt.previous = st;
st = &newSt;
st->pawnKey ^= Zobrist::psq[them][PAWN][capsq];
}
else
- st->npMaterial[them] -= PieceValue[Mg][capture];
+ st->npMaterial[them] -= PieceValue[MG][capture];
// Remove the captured piece
byTypeBB[ALL_PIECES] ^= capsq;
- pieceSquareTable[make_piece(us, PAWN)][to];
// Update material
- st->npMaterial[us] += PieceValue[Mg][promotion];
+ st->npMaterial[us] += PieceValue[MG][promotion];
}
// Update pawn hash key
// Early return if SEE cannot be negative because captured piece value
// is not less then capturing one. Note that king moves always return
// here because king midgame value is set to 0.
- if (PieceValue[Mg][piece_on(to_sq(m))] >= PieceValue[Mg][piece_moved(m)])
+ if (PieceValue[MG][piece_on(to_sq(m))] >= PieceValue[MG][piece_moved(m)])
return 1;
return see(m);
int Position::see(Move m) const {
Square from, to;
- Bitboard occupied, attackers, stmAttackers, b;
+ Bitboard occupied, attackers, stmAttackers;
int swapList[32], slIndex = 1;
PieceType captured;
Color stm;
stm = ~color_of(piece_on(from));
stmAttackers = attackers & pieces(stm);
if (!stmAttackers)
- return PieceValue[Mg][captured];
+ return PieceValue[MG][captured];
// The destination square is defended, which makes things rather more
// difficult to compute. We proceed by building up a "swap list" containing
// destination square, where the sides alternately capture, and always
// capture with the least valuable piece. After each capture, we look for
// new X-ray attacks from behind the capturing piece.
- swapList[0] = PieceValue[Mg][captured];
+ swapList[0] = PieceValue[MG][captured];
captured = type_of(piece_on(from));
do {
assert(slIndex < 32);
// Add the new entry to the swap list
- swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[Mg][captured];
+ swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured];
slIndex++;
- // Locate the least valuable attacker for the side to move. The loop
- // below looks like it is potentially infinite, but it isn't. We know
- // that the side to move still has at least one attacker left.
- for (captured = PAWN; (b = stmAttackers & pieces(captured)) == 0; captured++)
- assert(captured < KING);
+ // Locate and remove from 'occupied' the next least valuable attacker
+ captured = next_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
- // Remove the attacker we just found from the 'occupied' bitboard,
- // and scan for new X-ray attacks behind the attacker.
- occupied ^= (b & (~b + 1));
- attackers |= (attacks_bb<ROOK>(to, occupied) & pieces(ROOK, QUEEN))
- | (attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN));
-
- attackers &= occupied; // Cut out pieces we've already done
+ attackers &= occupied; // Remove the just found attacker
stm = ~stm;
stmAttackers = attackers & pieces(stm);
- // Stop before processing a king capture
- if (captured == KING && stmAttackers)
+ if (captured == KING)
{
- assert(slIndex < 32);
- swapList[slIndex++] = QueenValueMg * 16;
+ // Stop before processing a king capture
+ if (stmAttackers)
+ swapList[slIndex++] = QueenValueMg * 16;
+
break;
}
for (int i = 0; i < 8; i++)
for (int j = 0; j < 16; j++)
pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
-
- for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
- board[sq] = NO_PIECE;
}
Value value = VALUE_ZERO;
for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
- value += piece_count(c, pt) * PieceValue[Mg][pt];
+ value += piece_count(c, pt) * PieceValue[MG][pt];
return value;
}
/// 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.
-template<bool SkipRepetition>
+template<bool CheckRepetition, bool CheckThreeFold>
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 && (!in_check() || MoveList<LEGAL>(*this).size()))
return true;
- // Draw by repetition?
- if (!SkipRepetition)
+ if (CheckRepetition)
{
- int i = 4, e = std::min(st->rule50, st->pliesFromNull);
+ int i = 4, e = std::min(st->rule50, st->pliesFromNull), cnt;
if (i <= e)
{
StateInfo* stp = st->previous->previous;
- do {
+ for (cnt = 0; i <= e; i += 2)
+ {
stp = stp->previous->previous;
- if (stp->key == st->key)
+ if (stp->key == st->key && (!CheckThreeFold || ++cnt >= 2))
return true;
-
- i +=2;
-
- } while (i <= e);
+ }
}
}
}
// Explicit template instantiations
-template bool Position::is_draw<false>() const;
-template bool Position::is_draw<true>() const;
+template bool Position::is_draw<true, true>() const;
+template bool Position::is_draw<true, false>() const;
+template bool Position::is_draw<false,false>() const;
/// Position::flip() flips position with the white and black sides reversed. This
if ((*step)++, debugKingCount)
{
- int kingCount[2] = {};
+ int kingCount[COLOR_NB] = {};
for (Square s = SQ_A1; s <= SQ_H8; s++)
if (type_of(piece_on(s)) == KING)