Color us = pos.side_to_move();
Color them = opposite_color(us);
+ Square ksq = pos.king_square(them);
- ksq = pos.king_square(them);
dcCandidates = pos.discovered_check_candidates(us);
+ pinned = pos.pinned_pieces(us);
- checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
+ checkSq[PAWN]
= pos.attacks_from<PAWN>(ksq, them);
checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
- checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
- checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
- checkSq[KING] = EmptyBoardBB;
+ checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
+ checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
+ checkSq[KING] = EmptyBoardBB;
}
if ( ((ss >> col) && (col >= 'a' && col <= 'h'))
&& ((ss >> row) && (row == '3' || row == '6')))
{
- st->epSquare = make_square(file_from_char(col), rank_from_char(row));
+ st->epSquare = make_square(File(col - 'a') + FILE_A, Rank(row - '1') + RANK_1);
// Ignore if no capture is possible
Color them = opposite_color(sideToMove);
/// Position::move_gives_check() tests whether a pseudo-legal move is a check
-bool Position::move_gives_check(Move m) const {
-
- return move_gives_check(m, CheckInfo(*this));
-}
-
bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
assert(is_ok());
assert(move_is_ok(m));
assert(ci.dcCandidates == discovered_check_candidates(side_to_move()));
assert(color_of_piece_on(move_from(m)) == side_to_move());
- assert(piece_on(ci.ksq) == make_piece(opposite_color(side_to_move()), KING));
Square from = move_from(m);
Square to = move_to(m);
{
// For pawn and king moves we need to verify also direction
if ( (pt != PAWN && pt != KING)
- || !squares_aligned(from, to, ci.ksq))
+ || !squares_aligned(from, to, king_square(opposite_color(side_to_move()))))
return true;
}
Color us = side_to_move();
Bitboard b = occupied_squares();
+ Square ksq = king_square(opposite_color(us));
// Promotion with check ?
if (move_is_promotion(m))
switch (promotion_piece_type(m))
{
case KNIGHT:
- return bit_is_set(attacks_from<KNIGHT>(to), ci.ksq);
+ return bit_is_set(attacks_from<KNIGHT>(to), ksq);
case BISHOP:
- return bit_is_set(bishop_attacks_bb(to, b), ci.ksq);
+ return bit_is_set(bishop_attacks_bb(to, b), ksq);
case ROOK:
- return bit_is_set(rook_attacks_bb(to, b), ci.ksq);
+ return bit_is_set(rook_attacks_bb(to, b), ksq);
case QUEEN:
- return bit_is_set(queen_attacks_bb(to, b), ci.ksq);
+ return bit_is_set(queen_attacks_bb(to, b), ksq);
default:
assert(false);
}
clear_bit(&b, from);
clear_bit(&b, capsq);
set_bit(&b, to);
- return (rook_attacks_bb(ci.ksq, b) & pieces(ROOK, QUEEN, us))
- ||(bishop_attacks_bb(ci.ksq, b) & pieces(BISHOP, QUEEN, us));
+ return (rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, us))
+ ||(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us));
}
// Castling with check ?
clear_bit(&b, rfrom);
set_bit(&b, rto);
set_bit(&b, kto);
- return bit_is_set(rook_attacks_bb(rto, b), ci.ksq);
+ return bit_is_set(rook_attacks_bb(rto, b), ksq);
}
return false;
if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
{
if (pt != ROOK)
- st->checkersBB |= (attacks_from<ROOK>(ci.ksq) & pieces(ROOK, QUEEN, us));
+ st->checkersBB |= (attacks_from<ROOK>(king_square(them)) & pieces(ROOK, QUEEN, us));
if (pt != BISHOP)
- st->checkersBB |= (attacks_from<BISHOP>(ci.ksq) & pieces(BISHOP, QUEEN, us));
+ st->checkersBB |= (attacks_from<BISHOP>(king_square(them)) & pieces(BISHOP, QUEEN, us));
}
}
}
}
-/// Position::init_zobrist() is a static member function which initializes at
-/// startup the various arrays used to compute hash keys.
+/// Position::init() is a static member function which initializes at
+/// startup the various arrays used to compute hash keys and the piece
+/// square tables. The latter is a two-step operation: First, the white
+/// halves of the tables are copied from the MgPST[][] and EgPST[][] arrays.
+/// Second, the black halves of the tables are initialized by mirroring
+/// and changing the sign of the corresponding white scores.
-void Position::init_zobrist() {
+void Position::init() {
- int i,j, k;
RKISS rk;
- for (i = 0; i < 2; i++) for (j = 0; j < 8; j++) for (k = 0; k < 64; k++)
- zobrist[i][j][k] = rk.rand<Key>();
+ for (Color c = WHITE; c <= BLACK; c++)
+ for (PieceType pt = PAWN; pt <= KING; pt++)
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ zobrist[c][pt][s] = rk.rand<Key>();
- for (i = 0; i < 64; i++)
- zobEp[i] = rk.rand<Key>();
+ for (Square s = SQ_A1; s <= SQ_H8; s++)
+ zobEp[s] = rk.rand<Key>();
- for (i = 0; i < 16; i++)
+ for (int i = 0; i < 16; i++)
zobCastle[i] = rk.rand<Key>();
zobSideToMove = rk.rand<Key>();
zobExclusion = rk.rand<Key>();
-}
-
-
-/// Position::init_piece_square_tables() initializes the piece square tables.
-/// This is a two-step operation: First, the white halves of the tables are
-/// copied from the MgPST[][] and EgPST[][] arrays. Second, the black halves
-/// of the tables are initialized by mirroring and changing the sign of the
-/// corresponding white scores.
-
-void Position::init_piece_square_tables() {
for (Square s = SQ_A1; s <= SQ_H8; s++)
for (Piece p = WP; p <= WK; p++)
if (failedStep) *failedStep = 1;
// Side to move OK?
- if (!color_is_ok(side_to_move()))
+ if (side_to_move() != WHITE && side_to_move() != BLACK)
return false;
// Are the king squares in the position correct?
// Castle files OK?
if (failedStep) (*failedStep)++;
- if (!file_is_ok(initialKRFile))
+ if (!square_is_ok(make_square(initialKRFile, RANK_1)))
return false;
- if (!file_is_ok(initialQRFile))
+ if (!square_is_ok(make_square(initialQRFile, RANK_1)))
return false;
// Do both sides have exactly one king?
projects / stockfish / blobdiff