X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=537674c9119c123370c44456cfb7b9ea94301451;hp=0f6a3febeb98d92a8e50232fcb16df4e1bd98716;hb=34178205fc762638e633a61ecc45360e1662bdee;hpb=8a89b12641ab26e7f49b77a82be2d160de2ab6a5 diff --git a/src/position.cpp b/src/position.cpp index 0f6a3feb..537674c9 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2012 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 @@ -19,7 +19,6 @@ #include #include -#include #include #include #include @@ -37,7 +36,7 @@ using std::cout; using std::endl; Key Position::zobrist[2][8][64]; -Key Position::zobEp[64]; +Key Position::zobEp[8]; Key Position::zobCastle[16]; Key Position::zobSideToMove; Key Position::zobExclusion; @@ -70,7 +69,7 @@ namespace { const Score TempoValue = make_score(48, 22); // To convert a Piece to and from a FEN char - const string PieceToChar(".PNBRQK pnbrqk "); + const string PieceToChar(" PNBRQK pnbrqk ."); } @@ -78,8 +77,8 @@ namespace { CheckInfo::CheckInfo(const Position& pos) { - Color them = flip(pos.side_to_move()); - Square ksq = pos.king_square(them); + Color them = ~pos.side_to_move(); + ksq = pos.king_square(them); pinned = pos.pinned_pieces(); dcCandidates = pos.discovered_check_candidates(); @@ -89,7 +88,7 @@ CheckInfo::CheckInfo(const Position& pos) { checkSq[BISHOP] = pos.attacks_from(ksq); checkSq[ROOK] = pos.attacks_from(ksq); checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK]; - checkSq[KING] = EmptyBoardBB; + checkSq[KING] = 0; } @@ -97,9 +96,11 @@ CheckInfo::CheckInfo(const Position& pos) { /// or the FEN string, we want the new born Position object do not depend /// on any external data so we detach state pointer from the source one. -Position::Position(const Position& pos, int th) { +void Position::copy(const Position& pos, int th) { memcpy(this, &pos, sizeof(Position)); + startState = *st; + st = &startState; threadID = th; nodes = 0; @@ -163,11 +164,11 @@ void Position::from_fen(const string& fenStr, bool isChess960) { // 1. Piece placement while ((fen >> token) && !isspace(token)) { - if (token == '/') - sq -= Square(16); // Jump back of 2 rows + if (isdigit(token)) + sq += Square(token - '0'); // Advance the given number of files - else if (isdigit(token)) - sq += Square(token - '0'); // Skip the given number of files + else if (token == '/') + sq = make_square(FILE_A, rank_of(sq) - Rank(2)); else if ((p = PieceToChar.find(token)) != string::npos) { @@ -190,15 +191,14 @@ void Position::from_fen(const string& fenStr, bool isChess960) { { Square rsq; Color c = islower(token) ? BLACK : WHITE; - Piece rook = make_piece(c, ROOK); token = char(toupper(token)); if (token == 'K') - for (rsq = relative_square(c, SQ_H1); piece_on(rsq) != rook; rsq--) {} + for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {} else if (token == 'Q') - for (rsq = relative_square(c, SQ_A1); piece_on(rsq) != rook; rsq++) {} + for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {} else if (token >= 'A' && token <= 'H') rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1)); @@ -206,7 +206,7 @@ void Position::from_fen(const string& fenStr, bool isChess960) { else continue; - set_castle_right(king_square(c), rsq); + set_castle_right(c, rsq); } // 4. En passant square. Ignore if no pawn capture is possible @@ -232,7 +232,7 @@ void Position::from_fen(const string& fenStr, bool isChess960) { st->value = compute_value(); st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); - st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); + st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); chess960 = isChess960; assert(pos_is_ok()); @@ -240,16 +240,29 @@ void Position::from_fen(const string& fenStr, bool isChess960) { /// Position::set_castle_right() is an helper function used to set castling -/// rights given the corresponding king and rook starting squares. +/// rights given the corresponding color and the rook starting square. + +void Position::set_castle_right(Color c, Square rfrom) { + + Square kfrom = king_square(c); + bool kingSide = kfrom < rfrom; + int cr = (kingSide ? WHITE_OO : WHITE_OOO) << c; -void Position::set_castle_right(Square ksq, Square rsq) { + st->castleRights |= cr; + castleRightsMask[kfrom] |= cr; + castleRightsMask[rfrom] |= cr; + castleRookSquare[cr] = rfrom; - int f = (rsq < ksq ? WHITE_OOO : WHITE_OO) << color_of(piece_on(ksq)); + Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1); + Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1); - st->castleRights |= f; - castleRightsMask[ksq] ^= f; - castleRightsMask[rsq] ^= f; - castleRookSquare[f] = rsq; + for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++) + if (s != kfrom && s != rfrom) + castlePath[cr] |= s; + + for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++) + if (s != kfrom && s != rfrom) + castlePath[cr] |= s; } @@ -336,8 +349,8 @@ void Position::print(Move move) const { Piece piece = piece_on(sq); char c = (color_of(piece) == BLACK ? '=' : ' '); - if (piece == PIECE_NONE && color_of(sq) == DARK) - piece = PIECE_NONE_DARK_SQ; + if (piece == NO_PIECE && !opposite_colors(sq, SQ_A1)) + piece++; // Index the dot cout << c << PieceToChar[piece] << c << '|'; } @@ -355,12 +368,12 @@ Bitboard Position::hidden_checkers() const { // Pinned pieces protect our king, dicovery checks attack the enemy king Bitboard b, result = 0; - Bitboard pinners = pieces(FindPinned ? flip(sideToMove) : sideToMove); - Square ksq = king_square(FindPinned ? sideToMove : flip(sideToMove)); + Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove); + Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove); // Pinners are sliders, that give check when candidate pinned is removed - pinners &= (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq]) - | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]); + pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq]) + | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]); while (pinners) { @@ -386,8 +399,8 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const { return (attacks_from(s, BLACK) & pieces(PAWN, WHITE)) | (attacks_from(s, WHITE) & pieces(PAWN, BLACK)) | (attacks_from(s) & pieces(KNIGHT)) - | (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN)) - | (bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)) + | (attacks_bb(s, occ) & pieces(ROOK, QUEEN)) + | (attacks_bb(s, occ) & pieces(BISHOP, QUEEN)) | (attacks_from(s) & pieces(KING)); } @@ -399,12 +412,12 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { assert(square_is_ok(s)); - switch (p) + switch (type_of(p)) { - case WB: case BB: return bishop_attacks_bb(s, occ); - case WR: case BR: return rook_attacks_bb(s, occ); - case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ); - default: return StepAttacksBB[p][s]; + case BISHOP: return attacks_bb(s, occ); + case ROOK : return attacks_bb(s, occ); + case QUEEN : return attacks_bb(s, occ) | attacks_bb(s, occ); + default : return StepAttacksBB[p][s]; } } @@ -418,23 +431,22 @@ bool Position::move_attacks_square(Move m, Square s) const { assert(square_is_ok(s)); Bitboard occ, xray; - Square from = move_from(m); - Square to = move_to(m); - Piece piece = piece_on(from); + Square from = from_sq(m); + Square to = to_sq(m); + Piece piece = piece_moved(m); assert(!square_is_empty(from)); // Update occupancy as if the piece is moving - occ = occupied_squares(); - do_move_bb(&occ, make_move_bb(from, to)); + occ = occupied_squares() ^ from ^ to; // The piece moved in 'to' attacks the square 's' ? - if (bit_is_set(attacks_from(piece, to, occ), s)) + if (attacks_from(piece, to, occ) & s) return true; // Scan for possible X-ray attackers behind the moved piece - xray = (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN, color_of(piece))) - |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece))); + xray = (attacks_bb(s, occ) & pieces(ROOK, QUEEN, color_of(piece))) + |(attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece))); // Verify attackers are triggered by our move and not already existing return xray && (xray ^ (xray & attacks_from(s))); @@ -448,10 +460,10 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { assert(is_ok(m)); assert(pinned == pinned_pieces()); - Color us = side_to_move(); - Square from = move_from(m); + Color us = sideToMove; + Square from = from_sq(m); - assert(color_of(piece_on(from)) == us); + assert(color_of(piece_moved(m)) == us); assert(piece_on(king_square(us)) == make_piece(us, KING)); // En passant captures are a tricky special case. Because they are rather @@ -459,36 +471,32 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { // the move is made. if (is_enpassant(m)) { - Color them = flip(us); - Square to = move_to(m); + Color them = ~us; + Square to = to_sq(m); Square capsq = to + pawn_push(them); Square ksq = king_square(us); - Bitboard b = occupied_squares(); + Bitboard b = (occupied_squares() ^ from ^ capsq) | to; assert(to == ep_square()); - assert(piece_on(from) == make_piece(us, PAWN)); + assert(piece_moved(m) == make_piece(us, PAWN)); assert(piece_on(capsq) == make_piece(them, PAWN)); - assert(piece_on(to) == PIECE_NONE); - - clear_bit(&b, from); - clear_bit(&b, capsq); - set_bit(&b, to); + assert(piece_on(to) == NO_PIECE); - return !(rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, them)) - && !(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, them)); + return !(attacks_bb(ksq, b) & pieces(ROOK, QUEEN, them)) + && !(attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, them)); } // If the moving piece is a king, check whether the destination // square is attacked by the opponent. Castling moves are checked // for legality during move generation. if (type_of(piece_on(from)) == KING) - return is_castle(m) || !(attackers_to(move_to(m)) & pieces(flip(us))); + return is_castle(m) || !(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 - || !bit_is_set(pinned, from) - || squares_aligned(from, move_to(m), king_square(us)); + || !(pinned & from) + || squares_aligned(from, to_sq(m), king_square(us)); } @@ -513,22 +521,22 @@ bool Position::move_is_legal(const Move m) const { bool Position::is_pseudo_legal(const Move m) const { Color us = sideToMove; - Color them = flip(sideToMove); - Square from = move_from(m); - Square to = move_to(m); - Piece pc = piece_on(from); + Color them = ~sideToMove; + Square from = from_sq(m); + Square to = to_sq(m); + Piece pc = piece_moved(m); // Use a slower but simpler function for uncommon cases if (is_special(m)) return move_is_legal(m); // Is not a promotion, so promotion piece must be empty - if (promotion_piece_type(m) - 2 != PIECE_TYPE_NONE) + 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 // move, the move is obviously not legal. - if (pc == PIECE_NONE || color_of(pc) != us) + if (pc == NO_PIECE || color_of(pc) != us) return false; // The destination square cannot be occupied by a friendly piece @@ -597,7 +605,7 @@ bool Position::is_pseudo_legal(const Move m) const { return false; } } - else if (!bit_is_set(attacks_from(pc, from), to)) + else if (!(attacks_from(pc, from) & to)) return false; // Evasions generator already takes care to avoid some kind of illegal moves @@ -605,28 +613,22 @@ bool Position::is_pseudo_legal(const Move m) const { // same kind of moves are filtered out here. if (in_check()) { - // 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. - if (type_of(piece_on(from)) == KING) + if (type_of(pc) != KING) { - Bitboard b = occupied_squares(); - clear_bit(&b, from); - if (attackers_to(move_to(m), b) & pieces(flip(us))) - return false; - } - else - { - Bitboard target = checkers(); - Square checksq = pop_1st_bit(&target); + Bitboard b = checkers(); + Square checksq = pop_1st_bit(&b); - if (target) // double check ? In this case a king move is required + if (b) // double check ? In this case a king move is required return false; // Our move must be a blocking evasion or a capture of the checking piece - target = squares_between(checksq, king_square(us)) | checkers(); - if (!bit_is_set(target, move_to(m))) + if (!((squares_between(checksq, 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. + else if (attackers_to(to, occupied_squares() ^ from) & pieces(~us)) + return false; } return true; @@ -639,22 +641,22 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { assert(is_ok(m)); assert(ci.dcCandidates == discovered_check_candidates()); - assert(color_of(piece_on(move_from(m))) == side_to_move()); + assert(color_of(piece_moved(m)) == sideToMove); - Square from = move_from(m); - Square to = move_to(m); + Square from = from_sq(m); + Square to = to_sq(m); PieceType pt = type_of(piece_on(from)); // Direct check ? - if (bit_is_set(ci.checkSq[pt], to)) + if (ci.checkSq[pt] & to) return true; // Discovery check ? - if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from)) + 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(flip(side_to_move())))) + || !squares_aligned(from, to, king_square(~sideToMove))) return true; } @@ -662,16 +664,12 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { if (!is_special(m)) return false; - Color us = side_to_move(); - Bitboard b = occupied_squares(); - Square ksq = king_square(flip(us)); + Color us = sideToMove; + Square ksq = king_square(~us); // Promotion with check ? if (is_promotion(m)) - { - clear_bit(&b, from); - return bit_is_set(attacks_from(Piece(promotion_piece_type(m)), to, b), ksq); - } + return attacks_from(Piece(promotion_type(m)), to, occupied_squares() ^ from) & ksq; // En passant capture with check ? We have already handled the case // of direct checks and ordinary discovered check, the only case we @@ -680,33 +678,22 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { if (is_enpassant(m)) { Square capsq = make_square(file_of(to), rank_of(from)); - clear_bit(&b, from); - clear_bit(&b, capsq); - set_bit(&b, to); - return (rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, us)) - ||(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us)); + Bitboard b = (occupied_squares() ^ from ^ capsq) | to; + + return (attacks_bb< ROOK>(ksq, b) & pieces( ROOK, QUEEN, us)) + | (attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us)); } // Castling with check ? if (is_castle(m)) { - Square kfrom, kto, rfrom, rto; - kfrom = from; - rfrom = to; + Square kfrom = from; + Square rfrom = to; // 'King captures the rook' notation + Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1); + Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1); + Bitboard b = (occupied_squares() ^ kfrom ^ rfrom) | rto | kto; - if (rfrom > kfrom) - { - kto = relative_square(us, SQ_G1); - rto = relative_square(us, SQ_F1); - } else { - kto = relative_square(us, SQ_C1); - rto = relative_square(us, SQ_D1); - } - clear_bit(&b, kfrom); - clear_bit(&b, rfrom); - set_bit(&b, rto); - set_bit(&b, kto); - return bit_is_set(rook_attacks_bb(rto, b), ksq); + return attacks_bb(rto, b) & ksq; } return false; @@ -729,7 +716,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(&newSt != st); nodes++; - Key key = st->key; + 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 @@ -748,24 +735,24 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st = &newSt; // Update side to move - key ^= zobSideToMove; + k ^= zobSideToMove; // Increment the 50 moves rule draw counter. Resetting it to zero in the - // case of non-reversible moves is taken care of later. + // case of a capture or a pawn move is taken care of later. st->rule50++; st->pliesFromNull++; if (is_castle(m)) { - st->key = key; + st->key = k; do_castle_move(m); return; } - Color us = side_to_move(); - Color them = flip(us); - Square from = move_from(m); - Square to = move_to(m); + Color us = sideToMove; + Color them = ~us; + Square from = from_sq(m); + Square to = to_sq(m); Piece piece = piece_on(from); PieceType pt = type_of(piece); PieceType capture = is_enpassant(m) ? PAWN : type_of(piece_on(to)); @@ -789,10 +776,10 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(pt == PAWN); assert(to == st->epSquare); assert(relative_rank(us, to) == RANK_6); - assert(piece_on(to) == PIECE_NONE); + assert(piece_on(to) == NO_PIECE); assert(piece_on(capsq) == make_piece(them, PAWN)); - board[capsq] = PIECE_NONE; + board[capsq] = NO_PIECE; } st->pawnKey ^= zobrist[them][PAWN][capsq]; @@ -801,9 +788,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->npMaterial[them] -= PieceValueMidgame[capture]; // Remove the captured piece - clear_bit(&byColorBB[them], capsq); - clear_bit(&byTypeBB[capture], capsq); - clear_bit(&occupied, capsq); + byColorBB[them] ^= capsq; + byTypeBB[capture] ^= capsq; + occupied ^= capsq; // Update piece list, move the last piece at index[capsq] position and // shrink the list. @@ -818,7 +805,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE; // Update hash keys - key ^= zobrist[them][capture][capsq]; + k ^= zobrist[them][capture][capsq]; st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]]; // Update incremental scores @@ -829,35 +816,34 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Update hash key - key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to]; + k ^= zobrist[us][pt][from] ^ zobrist[us][pt][to]; // Reset en passant square if (st->epSquare != SQ_NONE) { - key ^= zobEp[st->epSquare]; + k ^= zobEp[file_of(st->epSquare)]; st->epSquare = SQ_NONE; } // Update castle rights if needed - if ( st->castleRights != CASTLES_NONE - && (castleRightsMask[from] & castleRightsMask[to]) != ALL_CASTLES) + if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to])) { - key ^= zobCastle[st->castleRights]; - st->castleRights &= castleRightsMask[from] & castleRightsMask[to]; - key ^= zobCastle[st->castleRights]; + int cr = castleRightsMask[from] | castleRightsMask[to]; + k ^= zobCastle[st->castleRights & cr]; + st->castleRights &= ~cr; } // Prefetch TT access as soon as we know key is updated - prefetch((char*)TT.first_entry(key)); + prefetch((char*)TT.first_entry(k)); // Move the piece - Bitboard move_bb = make_move_bb(from, to); - do_move_bb(&byColorBB[us], move_bb); - do_move_bb(&byTypeBB[pt], move_bb); - do_move_bb(&occupied, move_bb); + Bitboard from_to_bb = SquareBB[from] | SquareBB[to]; + byColorBB[us] ^= from_to_bb; + byTypeBB[pt] ^= from_to_bb; + occupied ^= from_to_bb; board[to] = board[from]; - board[from] = PIECE_NONE; + board[from] = NO_PIECE; // Update piece lists, index[from] is not updated and becomes stale. This // works as long as index[] is accessed just by known occupied squares. @@ -868,23 +854,23 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI if (pt == PAWN) { // Set en-passant square, only if moved pawn can be captured - if ( (to ^ from) == 16 + if ( (int(to) ^ int(from)) == 16 && (attacks_from(from + pawn_push(us), us) & pieces(PAWN, them))) { st->epSquare = Square((from + to) / 2); - key ^= zobEp[st->epSquare]; + k ^= zobEp[file_of(st->epSquare)]; } if (is_promotion(m)) { - PieceType promotion = promotion_piece_type(m); + PieceType promotion = promotion_type(m); assert(relative_rank(us, to) == RANK_8); assert(promotion >= KNIGHT && promotion <= QUEEN); // Replace the pawn with the promoted piece - clear_bit(&byTypeBB[PAWN], to); - set_bit(&byTypeBB[promotion], to); + byTypeBB[PAWN] ^= to; + byTypeBB[promotion] |= to; board[to] = make_piece(us, promotion); // Update piece lists, move the last pawn at index[to] position @@ -897,7 +883,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI pieceList[us][promotion][index[to]] = to; // Update hash keys - key ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to]; + k ^= zobrist[us][PAWN][to] ^ zobrist[us][promotion][to]; st->pawnKey ^= zobrist[us][PAWN][to]; st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]++] ^ zobrist[us][PAWN][pieceCount[us][PAWN]]; @@ -928,10 +914,10 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->capturedType = capture; // Update the key with the final value - st->key = key; + st->key = k; // Update checkers bitboard, piece must be already moved - st->checkersBB = EmptyBoardBB; + st->checkersBB = 0; if (moveIsCheck) { @@ -940,11 +926,11 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI else { // Direct checks - if (bit_is_set(ci.checkSq[pt], to)) - st->checkersBB = SetMaskBB[to]; + if (ci.checkSq[pt] & to) + st->checkersBB |= to; // Discovery checks - if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from)) + if (ci.dcCandidates && (ci.dcCandidates & from)) { if (pt != ROOK) st->checkersBB |= attacks_from(king_square(them)) & pieces(ROOK, QUEEN, us); @@ -956,7 +942,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Finish - sideToMove = flip(sideToMove); + sideToMove = ~sideToMove; st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); assert(pos_is_ok()); @@ -970,7 +956,7 @@ void Position::undo_move(Move m) { assert(is_ok(m)); - sideToMove = flip(sideToMove); + sideToMove = ~sideToMove; if (is_castle(m)) { @@ -978,10 +964,10 @@ void Position::undo_move(Move m) { return; } - Color us = side_to_move(); - Color them = flip(us); - Square from = move_from(m); - Square to = move_to(m); + Color us = sideToMove; + Color them = ~us; + Square from = from_sq(m); + Square to = to_sq(m); Piece piece = piece_on(to); PieceType pt = type_of(piece); PieceType capture = st->capturedType; @@ -992,15 +978,15 @@ void Position::undo_move(Move m) { if (is_promotion(m)) { - PieceType promotion = promotion_piece_type(m); + PieceType promotion = promotion_type(m); assert(promotion == pt); assert(relative_rank(us, to) == RANK_8); assert(promotion >= KNIGHT && promotion <= QUEEN); // Replace the promoted piece with the pawn - clear_bit(&byTypeBB[promotion], to); - set_bit(&byTypeBB[PAWN], to); + byTypeBB[promotion] ^= to; + byTypeBB[PAWN] |= to; board[to] = make_piece(us, PAWN); // Update piece lists, move the last promoted piece at index[to] position @@ -1016,13 +1002,13 @@ void Position::undo_move(Move m) { } // Put the piece back at the source square - Bitboard move_bb = make_move_bb(to, from); - do_move_bb(&byColorBB[us], move_bb); - do_move_bb(&byTypeBB[pt], move_bb); - do_move_bb(&occupied, move_bb); + Bitboard from_to_bb = SquareBB[from] | SquareBB[to]; + byColorBB[us] ^= from_to_bb; + byTypeBB[pt] ^= from_to_bb; + occupied ^= from_to_bb; board[from] = board[to]; - board[to] = PIECE_NONE; + board[to] = NO_PIECE; // Update piece lists, index[to] is not updated and becomes stale. This // works as long as index[] is accessed just by known occupied squares. @@ -1040,13 +1026,13 @@ void Position::undo_move(Move m) { assert(pt == PAWN); assert(to == st->previous->epSquare); assert(relative_rank(us, to) == RANK_6); - assert(piece_on(capsq) == PIECE_NONE); + assert(piece_on(capsq) == NO_PIECE); } // Restore the captured piece - set_bit(&byColorBB[them], capsq); - set_bit(&byTypeBB[capture], capsq); - set_bit(&occupied, capsq); + byColorBB[them] |= capsq; + byTypeBB[capture] |= capsq; + occupied |= capsq; board[capsq] = make_piece(them, capture); @@ -1074,9 +1060,9 @@ void Position::do_castle_move(Move m) { Square kto, kfrom, rfrom, rto, kAfter, rAfter; - Color us = side_to_move(); - Square kBefore = move_from(m); - Square rBefore = move_to(m); + Color us = sideToMove; + Square kBefore = from_sq(m); + Square rBefore = to_sq(m); // Find after-castle squares for king and rook if (rBefore > kBefore) // O-O @@ -1100,25 +1086,25 @@ void Position::do_castle_move(Move m) { assert(piece_on(rfrom) == make_piece(us, ROOK)); // Remove pieces from source squares - clear_bit(&byColorBB[us], kfrom); - clear_bit(&byTypeBB[KING], kfrom); - clear_bit(&occupied, kfrom); - clear_bit(&byColorBB[us], rfrom); - clear_bit(&byTypeBB[ROOK], rfrom); - clear_bit(&occupied, rfrom); + byColorBB[us] ^= kfrom; + byTypeBB[KING] ^= kfrom; + occupied ^= kfrom; + byColorBB[us] ^= rfrom; + byTypeBB[ROOK] ^= rfrom; + occupied ^= rfrom; // Put pieces on destination squares - set_bit(&byColorBB[us], kto); - set_bit(&byTypeBB[KING], kto); - set_bit(&occupied, kto); - set_bit(&byColorBB[us], rto); - set_bit(&byTypeBB[ROOK], rto); - set_bit(&occupied, rto); + byColorBB[us] |= kto; + byTypeBB[KING] |= kto; + occupied |= kto; + byColorBB[us] |= rto; + byTypeBB[ROOK] |= rto; + occupied |= rto; // Update board Piece king = make_piece(us, KING); Piece rook = make_piece(us, ROOK); - board[kfrom] = board[rfrom] = PIECE_NONE; + board[kfrom] = board[rfrom] = NO_PIECE; board[kto] = king; board[rto] = rook; @@ -1132,7 +1118,7 @@ void Position::do_castle_move(Move m) { if (Do) { // Reset capture field - st->capturedType = PIECE_TYPE_NONE; + st->capturedType = NO_PIECE_TYPE; // Update incremental scores st->value += pst_delta(king, kfrom, kto); @@ -1145,23 +1131,19 @@ void Position::do_castle_move(Move m) { // Clear en passant square if (st->epSquare != SQ_NONE) { - st->key ^= zobEp[st->epSquare]; + st->key ^= zobEp[file_of(st->epSquare)]; st->epSquare = SQ_NONE; } // Update castling rights - st->key ^= zobCastle[st->castleRights]; - st->castleRights &= castleRightsMask[kfrom]; - st->key ^= zobCastle[st->castleRights]; - - // Reset rule 50 counter - st->rule50 = 0; + st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]]; + st->castleRights &= ~castleRightsMask[kfrom]; // Update checkers BB - st->checkersBB = attackers_to(king_square(flip(us))) & pieces(us); + st->checkersBB = attackers_to(king_square(~us)) & pieces(us); // Finish - sideToMove = flip(sideToMove); + sideToMove = ~sideToMove; st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); } else @@ -1192,12 +1174,12 @@ void Position::do_null_move(StateInfo& backupSt) { dst->rule50 = src->rule50; dst->pliesFromNull = src->pliesFromNull; - sideToMove = flip(sideToMove); + sideToMove = ~sideToMove; if (Do) { if (st->epSquare != SQ_NONE) - st->key ^= zobEp[st->epSquare]; + st->key ^= zobEp[file_of(st->epSquare)]; st->key ^= zobSideToMove; prefetch((char*)TT.first_entry(st->key)); @@ -1226,13 +1208,10 @@ int Position::see_sign(Move m) const { assert(is_ok(m)); - Square from = move_from(m); - Square to = move_to(m); - // 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 (PieceValueMidgame[piece_on(to)] >= PieceValueMidgame[piece_on(from)]) + if (PieceValueMidgame[piece_on(to_sq(m))] >= PieceValueMidgame[piece_moved(m)]) return 1; return see(m); @@ -1254,31 +1233,31 @@ int Position::see(Move m) const { if (is_castle(m)) return 0; - from = move_from(m); - to = move_to(m); + from = from_sq(m); + to = to_sq(m); capturedType = type_of(piece_on(to)); occ = occupied_squares(); // Handle en passant moves if (is_enpassant(m)) { - Square capQq = to - pawn_push(side_to_move()); + Square capQq = to - pawn_push(sideToMove); - assert(capturedType == PIECE_TYPE_NONE); + assert(!capturedType); assert(type_of(piece_on(capQq)) == PAWN); // Remove the captured pawn - clear_bit(&occ, capQq); + occ ^= capQq; capturedType = PAWN; } // Find all attackers to the destination square, with the moving piece // removed, but possibly an X-ray attacker added behind it. - clear_bit(&occ, from); + occ ^= from; attackers = attackers_to(to, occ); // If the opponent has no attackers we are finished - stm = flip(color_of(piece_on(from))); + stm = ~color_of(piece_on(from)); stmAttackers = attackers & pieces(stm); if (!stmAttackers) return PieceValueMidgame[capturedType]; @@ -1303,8 +1282,8 @@ int Position::see(Move m) const { // and scan for new X-ray attacks behind the attacker. b = stmAttackers & pieces(pt); occ ^= (b & (~b + 1)); - attackers |= (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN)) - | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN)); + attackers |= (attacks_bb(to, occ) & pieces(ROOK, QUEEN)) + | (attacks_bb(to, occ) & pieces(BISHOP, QUEEN)); attackers &= occ; // Cut out pieces we've already done @@ -1316,7 +1295,7 @@ int Position::see(Move m) const { // Remember the value of the capturing piece, and change the side to // move before beginning the next iteration. capturedType = pt; - stm = flip(stm); + stm = ~stm; stmAttackers = attackers & pieces(stm); // Stop before processing a king capture @@ -1342,27 +1321,16 @@ int Position::see(Move m) const { void Position::clear() { + memset(this, 0, sizeof(Position)); + startState.epSquare = SQ_NONE; st = &startState; - memset(st, 0, sizeof(StateInfo)); - st->epSquare = SQ_NONE; - - memset(byColorBB, 0, sizeof(Bitboard) * 2); - memset(byTypeBB, 0, sizeof(Bitboard) * 8); - memset(pieceCount, 0, sizeof(int) * 2 * 8); - memset(index, 0, sizeof(int) * 64); 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] = PIECE_NONE; - castleRightsMask[sq] = ALL_CASTLES; - } - sideToMove = WHITE; - nodes = 0; - occupied = 0; + board[sq] = NO_PIECE; } @@ -1378,9 +1346,9 @@ void Position::put_piece(Piece p, Square s) { index[s] = pieceCount[c][pt]++; pieceList[c][pt][index[s]] = s; - set_bit(&byTypeBB[pt], s); - set_bit(&byColorBB[c], s); - set_bit(&occupied, s); + byTypeBB[pt] |= s; + byColorBB[c] |= s; + occupied |= s; } @@ -1398,9 +1366,9 @@ Key Position::compute_key() const { result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s]; if (ep_square() != SQ_NONE) - result ^= zobEp[ep_square()]; + result ^= zobEp[file_of(ep_square())]; - if (side_to_move() == BLACK) + if (sideToMove == BLACK) result ^= zobSideToMove; return result; @@ -1464,7 +1432,7 @@ Score Position::compute_value() const { result += pst(make_piece(c, pt), pop_1st_bit(&b)); } - result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2); + result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2); return result; } @@ -1497,7 +1465,7 @@ bool Position::is_draw() const { return true; // Draw by the 50 moves rule? - if (st->rule50 > 99 && !is_mate()) + if (st->rule50 > 99 && (!in_check() || MoveList(*this).size())) return true; // Draw by repetition? @@ -1529,15 +1497,6 @@ template bool Position::is_draw() const; template bool Position::is_draw() const; -/// Position::is_mate() returns true or false depending on whether the -/// side to move is checkmated. - -bool Position::is_mate() const { - - return in_check() && !MoveList(*this).size(); -} - - /// 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 @@ -1553,23 +1512,30 @@ void Position::init() { for (Square s = SQ_A1; s <= SQ_H8; s++) zobrist[c][pt][s] = rk.rand(); - for (Square s = SQ_A1; s <= SQ_H8; s++) - zobEp[s] = rk.rand(); + for (File f = FILE_A; f <= FILE_H; f++) + zobEp[f] = rk.rand(); - for (int i = 0; i < 16; i++) - zobCastle[i] = rk.rand(); + for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++) + { + Bitboard b = cr; + while (b) + { + Key k = zobCastle[1 << pop_1st_bit(&b)]; + zobCastle[cr] ^= k ? k : rk.rand(); + } + } zobSideToMove = rk.rand(); zobExclusion = rk.rand(); - for (Piece p = WP; p <= WK; p++) + for (Piece p = W_PAWN; p <= W_KING; p++) { Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]); for (Square s = SQ_A1; s <= SQ_H8; s++) { pieceSquareTable[p][s] = ps + PSQT[p][s]; - pieceSquareTable[p+8][flip(s)] = -pieceSquareTable[p][s]; + pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s]; } } } @@ -1589,27 +1555,27 @@ void Position::flip_me() { // Board for (Square s = SQ_A1; s <= SQ_H8; s++) if (!pos.square_is_empty(s)) - put_piece(Piece(pos.piece_on(s) ^ 8), flip(s)); + put_piece(Piece(pos.piece_on(s) ^ 8), ~s); // Side to move - sideToMove = flip(pos.side_to_move()); + sideToMove = ~pos.side_to_move(); // Castling rights if (pos.can_castle(WHITE_OO)) - set_castle_right(king_square(BLACK), flip(pos.castle_rook_square(WHITE_OO))); + set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO)); if (pos.can_castle(WHITE_OOO)) - set_castle_right(king_square(BLACK), flip(pos.castle_rook_square(WHITE_OOO))); + set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO)); if (pos.can_castle(BLACK_OO)) - set_castle_right(king_square(WHITE), flip(pos.castle_rook_square(BLACK_OO))); + set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO)); if (pos.can_castle(BLACK_OOO)) - set_castle_right(king_square(WHITE), flip(pos.castle_rook_square(BLACK_OOO))); + set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO)); // En passant square if (pos.st->epSquare != SQ_NONE) - st->epSquare = flip(pos.st->epSquare); + st->epSquare = ~pos.st->epSquare; // Checkers - st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); + st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); // Hash keys st->key = compute_key(); @@ -1651,16 +1617,16 @@ bool Position::pos_is_ok(int* failedStep) const { if (failedStep) *failedStep = 1; // Side to move OK? - if (side_to_move() != WHITE && side_to_move() != BLACK) + if (sideToMove != WHITE && sideToMove != BLACK) return false; // Are the king squares in the position correct? if (failedStep) (*failedStep)++; - if (piece_on(king_square(WHITE)) != WK) + if (piece_on(king_square(WHITE)) != W_KING) return false; if (failedStep) (*failedStep)++; - if (piece_on(king_square(BLACK)) != BK) + if (piece_on(king_square(BLACK)) != B_KING) return false; // Do both sides have exactly one king? @@ -1680,8 +1646,8 @@ bool Position::pos_is_ok(int* failedStep) const { if (failedStep) (*failedStep)++; if (debugKingCapture) { - Color us = side_to_move(); - Color them = flip(us); + Color us = sideToMove; + Color them = ~us; Square ksq = king_square(them); if (attackers_to(ksq) & pieces(us)) return false; @@ -1689,7 +1655,7 @@ bool Position::pos_is_ok(int* failedStep) const { // Is there more than 2 checkers? if (failedStep) (*failedStep)++; - if (debugCheckerCount && count_1s(st->checkersBB) > 2) + if (debugCheckerCount && popcount(st->checkersBB) > 2) return false; // Bitboards OK? @@ -1697,7 +1663,7 @@ bool Position::pos_is_ok(int* failedStep) const { if (debugBitboards) { // The intersection of the white and black pieces must be empty - if ((pieces(WHITE) & pieces(BLACK)) != EmptyBoardBB) + if (pieces(WHITE) & pieces(BLACK)) return false; // The union of the white and black pieces must be equal to all @@ -1718,7 +1684,7 @@ bool Position::pos_is_ok(int* failedStep) const { { // The en passant square must be on rank 6, from the point of view of the // side to move. - if (relative_rank(side_to_move(), ep_square()) != RANK_6) + if (relative_rank(sideToMove, ep_square()) != RANK_6) return false; } @@ -1758,7 +1724,7 @@ bool Position::pos_is_ok(int* failedStep) const { if (debugPieceCounts) for (Color c = WHITE; c <= BLACK; c++) for (PieceType pt = PAWN; pt <= KING; pt++) - if (pieceCount[c][pt] != count_1s(pieces(pt, c))) + if (pieceCount[c][pt] != popcount(pieces(pt, c))) return false; if (failedStep) (*failedStep)++; @@ -1781,10 +1747,10 @@ bool Position::pos_is_ok(int* failedStep) const { if (!can_castle(f)) continue; - Piece rook = (f & (WHITE_OO | WHITE_OOO) ? WR : BR); + Piece rook = (f & (WHITE_OO | WHITE_OOO) ? W_ROOK : B_ROOK); - if ( castleRightsMask[castleRookSquare[f]] != (ALL_CASTLES ^ f) - || piece_on(castleRookSquare[f]) != rook) + if ( piece_on(castleRookSquare[f]) != rook + || castleRightsMask[castleRookSquare[f]] != f) return false; }