#include <cassert>
#include <cstring>
#include <iomanip>
-#include <iostream>
#include <sstream>
#include "bitcount.h"
#include "tt.h"
using std::string;
-using std::cout;
-using std::endl;
static const string PieceToChar(" PNBRQK pnbrqk");
Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
Key enpassant[FILE_NB];
- Key castle[CASTLE_RIGHT_NB];
+ Key castling[CASTLING_FLAG_NB];
Key side;
Key exclusion;
}
Color them = ~pos.side_to_move();
ksq = pos.king_square(them);
- pinned = pos.pinned_pieces();
+ pinned = pos.pinned_pieces(pos.side_to_move());
dcCandidates = pos.discovered_check_candidates();
checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
for (File f = FILE_A; f <= FILE_H; ++f)
Zobrist::enpassant[f] = rk.rand<Key>();
- for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; ++cr)
+ for (int cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf)
{
- Bitboard b = cr;
+ Bitboard b = cf;
while (b)
{
- Key k = Zobrist::castle[1ULL << pop_lsb(&b)];
- Zobrist::castle[cr] ^= k ? k : rk.rand<Key>();
+ Key k = Zobrist::castling[1ULL << pop_lsb(&b)];
+ Zobrist::castling[cf] ^= k ? k : rk.rand<Key>();
}
}
else
continue;
- set_castle_right(c, rsq);
+ set_castling_flag(c, rsq);
}
// 4. En passant square. Ignore if no pawn capture is possible
}
-/// Position::set_castle_right() is an helper function used to set castling
-/// rights given the corresponding color and the rook starting square.
+/// Position::set_castling_flag() is an helper function used to set castling
+/// flags given the corresponding color and the rook starting square.
-void Position::set_castle_right(Color c, Square rfrom) {
+void Position::set_castling_flag(Color c, Square rfrom) {
Square kfrom = king_square(c);
CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE;
- CastleRight cr = make_castle_right(c, cs);
+ CastlingFlag cf = make_castling_flag(c, cs);
- st->castleRights |= cr;
- castleRightsMask[kfrom] |= cr;
- castleRightsMask[rfrom] |= cr;
- castleRookSquare[c][cs] = rfrom;
+ st->castlingFlags |= cf;
+ castlingFlagsMask[kfrom] |= cf;
+ castlingFlagsMask[rfrom] |= cf;
+ castlingRookSquare[c][cs] = 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)
- castlePath[c][cs] |= s;
+ castlingPath[c][cs] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
- castlePath[c][cs] |= s;
+ castlingPath[c][cs] |= s;
}
ss << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, KING_SIDE)), false) : 'K');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, KING_SIDE)), false) : 'K');
if (can_castle(WHITE_OOO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q');
if (can_castle(BLACK_OO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, KING_SIDE)), true) : 'k');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, KING_SIDE)), true) : 'k');
if (can_castle(BLACK_OOO))
- ss << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK, QUEEN_SIDE)), true) : 'q');
+ ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)), true) : 'q');
- if (st->castleRights == CASTLES_NONE)
+ if (st->castlingFlags == NO_CASTLING)
ss << '-';
ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ")
/// pieces, according to the call parameters. Pinned pieces protect our king,
/// discovery check pieces attack the enemy king.
-Bitboard Position::hidden_checkers(Square ksq, Color c) const {
+Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
Bitboard b, pinners, result = 0;
b = between_bb(ksq, pop_lsb(&pinners)) & pieces();
if (!more_than_one(b))
- result |= b & pieces(sideToMove);
+ result |= b & pieces(toMove);
}
return result;
}
}
-/// Position::attacks_from() computes a bitboard of all attacks of a given piece
-/// put in a given square. Slider attacks use occ bitboard as occupancy.
-
-Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
-
- assert(is_ok(s));
-
- switch (type_of(p))
- {
- case BISHOP: return attacks_bb<BISHOP>(s, occ);
- case ROOK : return attacks_bb<ROOK>(s, occ);
- case QUEEN : return attacks_bb<BISHOP>(s, occ) | attacks_bb<ROOK>(s, occ);
- default : return StepAttacksBB[p][s];
- }
-}
-
-
/// Position::legal() tests whether a pseudo-legal move is legal
bool Position::legal(Move m, Bitboard pinned) const {
assert(is_ok(m));
- assert(pinned == pinned_pieces());
+ assert(pinned == pinned_pieces(sideToMove));
Color us = sideToMove;
Square from = from_sq(m);
// square is attacked by the opponent. Castling moves are checked
// for legality during move generation.
if (type_of(piece_on(from)) == KING)
- return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us));
+ return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us));
// A non-king move is legal if and only if it is not pinned or it
// is moving along the ray towards or away from the king.
return !pinned
|| !(pinned & from)
- || squares_aligned(from, to_sq(m), king_square(us));
+ || aligned(from, to_sq(m), king_square(us));
}
if (ci.checkSq[pt] & to)
return true;
- // Discovery check ?
- if (unlikely(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;
- }
+ // Discovered check ?
+ if ( unlikely(ci.dcCandidates)
+ && (ci.dcCandidates & from)
+ && !aligned(from, to, king_square(~sideToMove)))
+ return true;
// Can we skip the ugly special cases ?
if (type_of(m) == NORMAL)
switch (type_of(m))
{
case PROMOTION:
- return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
+ return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
// En passant capture with check ? We have already handled the case
// of direct checks and ordinary discovered check, the only case we
return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK))
| (attacks_bb<BISHOP>(ksq, b) & pieces(us, QUEEN, BISHOP));
}
- case CASTLE:
+ case CASTLING:
{
Square kfrom = from;
- Square rfrom = to; // 'King captures the rook' notation
+ 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);
PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to));
assert(color_of(pc) == us);
- assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE);
+ assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING);
assert(captured != KING);
- if (type_of(m) == CASTLE)
+ if (type_of(m) == CASTLING)
{
assert(pc == make_piece(us, KING));
bool kingSide = to > from;
- Square rfrom = to; // Castle is encoded as "king captures friendly rook"
+ Square rfrom = to; // Castling is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
captured = NO_PIECE_TYPE;
- do_castle(from, to, rfrom, rto);
+ do_castling(from, to, rfrom, rto);
st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom];
k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto];
st->epSquare = SQ_NONE;
}
- // Update castle rights if needed
- if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to]))
+ // Update castling flags if needed
+ if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to]))
{
- int cr = castleRightsMask[from] | castleRightsMask[to];
- k ^= Zobrist::castle[st->castleRights & cr];
- st->castleRights &= ~cr;
+ int cf = castlingFlagsMask[from] | castlingFlagsMask[to];
+ k ^= Zobrist::castling[st->castlingFlags & cf];
+ st->castlingFlags &= ~cf;
}
// Prefetch TT access as soon as we know the new hash key
prefetch((char*)TT.first_entry(k));
- // Move the piece. The tricky Chess960 castle is handled earlier
- if (type_of(m) != CASTLE)
+ // Move the piece. The tricky Chess960 castling is handled earlier
+ if (type_of(m) != CASTLING)
move_piece(from, to, us, pt);
// If the moving piece is a pawn do some special extra work
PieceType pt = type_of(piece_on(to));
PieceType captured = st->capturedType;
- assert(empty(from) || type_of(m) == CASTLE);
+ assert(empty(from) || type_of(m) == CASTLING);
assert(captured != KING);
if (type_of(m) == PROMOTION)
pt = PAWN;
}
- if (type_of(m) == CASTLE)
+ if (type_of(m) == CASTLING)
{
bool kingSide = to > from;
- Square rfrom = to; // Castle is encoded as "king captures friendly rook"
+ Square rfrom = to; // Castling is encoded as "king captures friendly rook"
Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1);
to = relative_square(us, kingSide ? SQ_G1 : SQ_C1);
captured = NO_PIECE_TYPE;
pt = KING;
- do_castle(to, from, rto, rfrom);
+ do_castling(to, from, rto, rfrom);
}
else
move_piece(to, from, us, pt); // Put the piece back at the source square
}
-/// Position::do_castle() is a helper used to do/undo a castling move. This
+/// Position::do_castling() is a helper used to do/undo a castling move. This
/// is a bit tricky, especially in Chess960.
-void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) {
+void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) {
// Remove both pieces first since squares could overlap in Chess960
remove_piece(kfrom, sideToMove, KING);
from = from_sq(m);
to = to_sq(m);
- swapList[0] = PieceValue[MG][type_of(piece_on(to))];
+ swapList[0] = PieceValue[MG][piece_on(to)];
stm = color_of(piece_on(from));
occupied = pieces() ^ from;
- // Castle moves are implemented as king capturing the rook so cannot be
+ // Castling moves are implemented as king capturing the rook so cannot be
// 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) == CASTLE)
+ if (type_of(m) == CASTLING)
return 0;
if (type_of(m) == ENPASSANT)
// 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.
while (--slIndex)
- swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
+ swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]);
return swapList[0];
}
Key Position::compute_key() const {
- Key k = Zobrist::castle[st->castleRights];
+ Key k = Zobrist::castling[st->castlingFlags];
for (Bitboard b = pieces(); b; )
{
const bool debugNonPawnMaterial = all || false;
const bool debugPieceCounts = all || false;
const bool debugPieceList = all || false;
- const bool debugCastleSquares = all || false;
+ const bool debugCastlingSquares = all || false;
*step = 1;
|| index[pieceList[c][pt][i]] != i)
return false;
- if ((*step)++, debugCastleSquares)
+ if ((*step)++, debugCastlingSquares)
for (Color c = WHITE; c <= BLACK; ++c)
for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
{
- CastleRight cr = make_castle_right(c, s);
+ CastlingFlag cf = make_castling_flag(c, s);
- if (!can_castle(cr))
+ if (!can_castle(cf))
continue;
- if ( (castleRightsMask[king_square(c)] & cr) != cr
- || piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
- || castleRightsMask[castleRookSquare[c][s]] != cr)
+ if ( (castlingFlagsMask[king_square(c)] & cf) != cf
+ || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK)
+ || castlingFlagsMask[castlingRookSquare[c][s]] != cf)
return false;
}