X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=b9acc645847471f42e4a8101d1d439c2634fdb73;hp=281109b19a34a8ba6d3f6602115d7b61d4cbb43a;hb=3141490374182551ed26f39ba4e3efb59589f057;hpb=c081a81daf128048bb4cf4cbdb4d5fc48110bb78 diff --git a/src/position.cpp b/src/position.cpp index 281109b1..b9acc645 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -30,7 +30,6 @@ #include "rkiss.h" #include "thread.h" #include "tt.h" -#include "ucioption.h" using std::string; using std::cout; @@ -78,12 +77,11 @@ namespace { CheckInfo::CheckInfo(const Position& pos) { - Color us = pos.side_to_move(); - Color them = opposite_color(us); + Color them = flip(pos.side_to_move()); Square ksq = pos.king_square(them); - dcCandidates = pos.discovered_check_candidates(us); - pinned = pos.pinned_pieces(us); + pinned = pos.pinned_pieces(); + dcCandidates = pos.discovered_check_candidates(); checkSq[PAWN] = pos.attacks_from(ksq, them); checkSq[KNIGHT] = pos.attacks_from(ksq); @@ -101,9 +99,10 @@ CheckInfo::CheckInfo(const Position& pos) { Position::Position(const Position& pos, int th) { memcpy(this, &pos, sizeof(Position)); - detach(); // Always detach() in copy c'tor to avoid surprises threadID = th; nodes = 0; + + assert(is_ok()); } Position::Position(const string& fen, bool isChess960, int th) { @@ -113,18 +112,6 @@ Position::Position(const string& fen, bool isChess960, int th) { } -/// Position::detach() copies the content of the current state and castling -/// masks inside the position itself. This is needed when the st pointee could -/// become stale, as example because the caller is about to going out of scope. - -void Position::detach() { - - startState = *st; - st = &startState; - st->previous = NULL; // As a safe guard -} - - /// Position::from_fen() initializes the position object with the given FEN /// string. This function is not very robust - make sure that input FENs are /// correct (this is assumed to be the responsibility of the GUI). @@ -196,18 +183,22 @@ void Position::from_fen(const string& fenStr, bool isChess960) { && ((fen >> row) && (row == '3' || row == '6'))) { st->epSquare = make_square(File(col - 'a'), Rank(row - '1')); - Color them = opposite_color(sideToMove); + Color them = flip(sideToMove); if (!(attacks_from(st->epSquare, them) & pieces(PAWN, sideToMove))) st->epSquare = SQ_NONE; } // 5-6. Halfmove clock and fullmove number - fen >> std::skipws >> st->rule50 >> fullMoves; + fen >> std::skipws >> st->rule50 >> startPosPly; + + // Convert from fullmove starting from 1 to ply starting from 0, + // handle also common incorrect FEN with fullmove = 0. + startPosPly = Max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK); // Various initialisations chess960 = isChess960; - st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(opposite_color(sideToMove)); + st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); st->key = compute_key(); st->pawnKey = compute_pawn_key(); @@ -215,6 +206,8 @@ 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); + + assert(is_ok()); } @@ -258,7 +251,7 @@ void Position::set_castling_rights(char token) { else return; - if (square_file(rsq) < square_file(ksq)) + if (file_of(rsq) < file_of(ksq)) set_castle(WHITE_OOO << c, ksq, rsq); else set_castle(WHITE_OO << c, ksq, rsq); @@ -307,21 +300,21 @@ const string Position::to_fen() const { if (st->castleRights != CASTLES_NONE) { if (can_castle(WHITE_OO)) - fen << (chess960 ? char(toupper(file_to_char(square_file(castle_rook_square(WHITE_OO))))) : 'K'); + fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OO))))) : 'K'); if (can_castle(WHITE_OOO)) - fen << (chess960 ? char(toupper(file_to_char(square_file(castle_rook_square(WHITE_OOO))))) : 'Q'); + fen << (chess960 ? char(toupper(file_to_char(file_of(castle_rook_square(WHITE_OOO))))) : 'Q'); if (can_castle(BLACK_OO)) - fen << (chess960 ? file_to_char(square_file(castle_rook_square(BLACK_OO))) : 'k'); + fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OO))) : 'k'); if (can_castle(BLACK_OOO)) - fen << (chess960 ? file_to_char(square_file(castle_rook_square(BLACK_OOO))) : 'q'); + fen << (chess960 ? file_to_char(file_of(castle_rook_square(BLACK_OOO))) : 'q'); } else fen << '-'; fen << (ep_square() == SQ_NONE ? " -" : " " + square_to_string(ep_square())) - << " " << st->rule50 << " " << fullMoves; + << " " << st->rule50 << " " << 1 + (startPosPly - int(sideToMove == BLACK)) / 2; return fen.str(); } @@ -349,10 +342,10 @@ void Position::print(Move move) const { Square sq = make_square(file, rank); Piece piece = piece_on(sq); - if (piece == PIECE_NONE && square_color(sq) == DARK) + if (piece == PIECE_NONE && color_of(sq) == DARK) piece = PIECE_NONE_DARK_SQ; - char c = (piece_color(piece_on(sq)) == BLACK ? '=' : ' '); + char c = (color_of(piece_on(sq)) == BLACK ? '=' : ' '); cout << c << PieceToChar[piece] << c << '|'; } } @@ -361,36 +354,28 @@ void Position::print(Move move) const { /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the -/// king) pieces for the given color and for the given pinner type. Or, when -/// template parameter FindPinned is false, the pieces of the given color -/// candidate for a discovery check against the enemy king. -/// Bitboard checkersBB must be already updated when looking for pinners. +/// king) pieces for the given color. Or, when template parameter FindPinned is +/// false, the function return the pieces of the given color candidate for a +/// discovery check against the enemy king. template -Bitboard Position::hidden_checkers(Color c) const { - - Bitboard result = EmptyBoardBB; - Bitboard pinners = pieces(FindPinned ? opposite_color(c) : c); +Bitboard Position::hidden_checkers() const { - // Pinned pieces protect our king, dicovery checks attack - // the enemy king. - Square ksq = king_square(FindPinned ? c : opposite_color(c)); + // Pinned pieces protect our king, dicovery checks attack the enemy king + Bitboard b, result = EmptyBoardBB; + Bitboard pinners = pieces(FindPinned ? flip(sideToMove) : sideToMove); + Square ksq = king_square(FindPinned ? sideToMove : flip(sideToMove)); - // Pinners are sliders, not checkers, that give check when candidate pinned is removed - pinners &= (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq]) | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]); - - if (FindPinned && pinners) - pinners &= ~st->checkersBB; + // Pinners are sliders, that give check when candidate pinned is removed + pinners &= (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq]) + | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]); while (pinners) { - Square s = pop_1st_bit(&pinners); - Bitboard b = squares_between(s, ksq) & occupied_squares(); - - assert(b); + b = squares_between(ksq, pop_1st_bit(&pinners)) & occupied_squares(); - if ( !(b & (b - 1)) // Only one bit set? - && (b & pieces(c))) // Is an our piece? + // Only one bit set and is an our piece? + if (b && !(b & (b - 1)) && (b & pieces(sideToMove))) result |= b; } return result; @@ -398,23 +383,21 @@ Bitboard Position::hidden_checkers(Color c) const { /// Position:pinned_pieces() returns a bitboard of all pinned (against the -/// king) pieces for the given color. Note that checkersBB bitboard must -/// be already updated. +/// king) pieces for the side to move. -Bitboard Position::pinned_pieces(Color c) const { +Bitboard Position::pinned_pieces() const { - return hidden_checkers(c); + return hidden_checkers(); } /// Position:discovered_check_candidates() returns a bitboard containing all -/// pieces for the given side which are candidates for giving a discovered -/// check. Contrary to pinned_pieces() here there is no need of checkersBB -/// to be already updated. +/// pieces for the side to move which are candidates for giving a discovered +/// check. -Bitboard Position::discovered_check_candidates(Color c) const { +Bitboard Position::discovered_check_candidates() const { - return hidden_checkers(c); + return hidden_checkers(); } /// Position::attackers_to() computes a bitboard containing all pieces which @@ -475,7 +458,7 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { bool Position::move_attacks_square(Move m, Square s) const { - assert(move_is_ok(m)); + assert(is_ok(m)); assert(square_is_ok(s)); Bitboard occ, xray; @@ -491,7 +474,7 @@ bool Position::move_attacks_square(Move m, Square s) const { do_move_bb(&occ, make_move_bb(f, t)); xray = ( (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN)) |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN))) - & pieces(piece_color(piece_on(f))); + & pieces(color_of(piece_on(f))); // If we have attacks we need to verify that are caused by our move // and are not already existent ones. @@ -503,24 +486,23 @@ bool Position::move_attacks_square(Move m, Square s) const { bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { - assert(is_ok()); - assert(move_is_ok(m)); - assert(pinned == pinned_pieces(side_to_move())); + assert(is_ok(m)); + assert(pinned == pinned_pieces()); Color us = side_to_move(); Square from = move_from(m); - assert(piece_color(piece_on(from)) == us); + assert(color_of(piece_on(from)) == us); assert(piece_on(king_square(us)) == make_piece(us, KING)); - // En passant captures are a tricky special case. Because they are - // rather uncommon, we do it simply by testing whether the king is attacked - // after the move is made - if (move_is_ep(m)) + // En passant captures are a tricky special case. Because they are rather + // uncommon, we do it simply by testing whether the king is attacked after + // the move is made. + if (is_enpassant(m)) { - Color them = opposite_color(us); + Color them = flip(us); Square to = move_to(m); - Square capsq = make_square(square_file(to), square_rank(from)); + Square capsq = to + pawn_push(them); Square ksq = king_square(us); Bitboard b = occupied_squares(); @@ -540,8 +522,8 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { // 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 (piece_type(piece_on(from)) == KING) - return move_is_castle(m) || !(attackers_to(move_to(m)) & pieces(opposite_color(us))); + if (type_of(piece_on(from)) == KING) + return is_castle(m) || !(attackers_to(move_to(m)) & pieces(flip(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. @@ -551,7 +533,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { } -/// Position::move_is_legal() takes a move and tests whether the move +/// Position::move_is_legal() takes a random move and tests whether the move /// is legal. This version is not very fast and should be used only /// in non time-critical paths. @@ -565,21 +547,20 @@ bool Position::move_is_legal(const Move m) const { } -/// Fast version of Position::move_is_pl() that takes a move and a bitboard -/// of pinned pieces as input, and tests whether the move is pseudo legal. +/// Position::is_pseudo_legal() takes a random move and tests whether the move +/// is pseudo legal. It is used to validate moves from TT that can be corrupted +/// due to SMP concurrent access or hash position key aliasing. -bool Position::move_is_pl(const Move m) const { - - assert(is_ok()); +bool Position::is_pseudo_legal(const Move m) const { Color us = sideToMove; - Color them = opposite_color(sideToMove); + Color them = flip(sideToMove); Square from = move_from(m); Square to = move_to(m); Piece pc = piece_on(from); // Use a slower but simpler function for uncommon cases - if (move_is_special(m)) + if (is_special(m)) return move_is_legal(m); // Is not a promotion, so promotion piece must be empty @@ -588,15 +569,15 @@ bool Position::move_is_pl(const Move m) const { // 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 || piece_color(pc) != us) + if (pc == PIECE_NONE || color_of(pc) != us) return false; // The destination square cannot be occupied by a friendly piece - if (piece_color(piece_on(to)) == us) + if (color_of(piece_on(to)) == us) return false; // Handle the special case of a pawn move - if (piece_type(pc) == PAWN) + if (type_of(pc) == PAWN) { // Move direction must be compatible with pawn color int direction = to - from; @@ -605,7 +586,7 @@ bool Position::move_is_pl(const Move m) const { // We have already handled promotion moves, so destination // cannot be on the 8/1th rank. - if (square_rank(to) == RANK_8 || square_rank(to) == RANK_1) + if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1) return false; // Proceed according to the square delta between the origin and @@ -618,11 +599,11 @@ bool Position::move_is_pl(const Move m) const { case DELTA_SE: // Capture. The destination square must be occupied by an enemy // piece (en passant captures was handled earlier). - if (piece_color(piece_on(to)) != them) + if (color_of(piece_on(to)) != them) return false; // From and to files must be one file apart, avoids a7h5 - if (abs(square_file(from) - square_file(to)) != 1) + if (abs(file_of(from) - file_of(to)) != 1) return false; break; @@ -637,7 +618,7 @@ bool Position::move_is_pl(const Move m) const { // Double white pawn push. The destination square must be on the fourth // rank, and both the destination square and the square between the // source and destination squares must be empty. - if ( square_rank(to) != RANK_4 + if ( rank_of(to) != RANK_4 || !square_is_empty(to) || !square_is_empty(from + DELTA_N)) return false; @@ -647,7 +628,7 @@ bool Position::move_is_pl(const Move m) const { // Double black pawn push. The destination square must be on the fifth // rank, and both the destination square and the square between the // source and destination squares must be empty. - if ( square_rank(to) != RANK_5 + if ( rank_of(to) != RANK_5 || !square_is_empty(to) || !square_is_empty(from + DELTA_S)) return false; @@ -664,11 +645,11 @@ bool Position::move_is_pl(const Move m) const { { // 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 (piece_type(piece_on(from)) == KING) + if (type_of(piece_on(from)) == KING) { Bitboard b = occupied_squares(); clear_bit(&b, from); - if (attackers_to(move_to(m), b) & pieces(opposite_color(us))) + if (attackers_to(move_to(m), b) & pieces(flip(us))) return false; } else @@ -690,18 +671,17 @@ bool Position::move_is_pl(const Move m) const { } -/// Position::move_gives_check() tests whether a pseudo-legal move is a check +/// Position::move_gives_check() tests whether a pseudo-legal move gives a check 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(piece_color(piece_on(move_from(m))) == side_to_move()); + assert(is_ok(m)); + assert(ci.dcCandidates == discovered_check_candidates()); + assert(color_of(piece_on(move_from(m))) == side_to_move()); Square from = move_from(m); Square to = move_to(m); - PieceType pt = piece_type(piece_on(from)); + PieceType pt = type_of(piece_on(from)); // Direct check ? if (bit_is_set(ci.checkSq[pt], to)) @@ -712,20 +692,20 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { { // For pawn and king moves we need to verify also direction if ( (pt != PAWN && pt != KING) - || !squares_aligned(from, to, king_square(opposite_color(side_to_move())))) + || !squares_aligned(from, to, king_square(flip(side_to_move())))) return true; } // Can we skip the ugly special cases ? - if (!move_is_special(m)) + if (!is_special(m)) return false; Color us = side_to_move(); Bitboard b = occupied_squares(); - Square ksq = king_square(opposite_color(us)); + Square ksq = king_square(flip(us)); // Promotion with check ? - if (move_is_promotion(m)) + if (is_promotion(m)) { clear_bit(&b, from); @@ -748,9 +728,9 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { // of direct checks and ordinary discovered check, the only case we // need to handle is the unusual case of a discovered check through // the captured pawn. - if (move_is_ep(m)) + if (is_enpassant(m)) { - Square capsq = make_square(square_file(to), square_rank(from)); + Square capsq = make_square(file_of(to), rank_of(from)); clear_bit(&b, from); clear_bit(&b, capsq); set_bit(&b, to); @@ -759,7 +739,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { } // Castling with check ? - if (move_is_castle(m)) + if (is_castle(m)) { Square kfrom, kto, rfrom, rto; kfrom = from; @@ -784,30 +764,6 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { } -/// Position::do_setup_move() makes a permanent move on the board. It should -/// be used when setting up a position on board. You can't undo the move. - -void Position::do_setup_move(Move m) { - - StateInfo newSt; - - // Update the number of full moves after black's move - if (sideToMove == BLACK) - fullMoves++; - - do_move(m, newSt); - - // Reset "game ply" in case we made a non-reversible move. - // "game ply" is used for repetition detection. - if (st->rule50 == 0) - st->gamePly = 0; - - // Our StateInfo newSt is about going out of scope so copy - // its content before it disappears. - detach(); -} - - /// Position::do_move() makes a move, and saves all information necessary /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal /// moves should be filtered out before this function is called. @@ -820,8 +776,7 @@ void Position::do_move(Move m, StateInfo& newSt) { void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) { - assert(is_ok()); - assert(move_is_ok(m)); + assert(is_ok(m)); assert(&newSt != st); nodes++; @@ -832,10 +787,10 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // pointer to point to the new, ready to be updated, state. struct ReducedStateInfo { Key pawnKey, materialKey; - int castleRights, rule50, gamePly, pliesFromNull; - Square epSquare; - Score value; Value npMaterial[2]; + int castleRights, rule50, pliesFromNull; + Score value; + Square epSquare; }; memcpy(&newSt, st, sizeof(ReducedStateInfo)); @@ -843,10 +798,6 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI newSt.previous = st; st = &newSt; - // Save the current key to the history[] array, in order to be able to - // detect repetition draws. - history[st->gamePly++] = key; - // Update side to move key ^= zobSideToMove; @@ -855,7 +806,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->rule50++; st->pliesFromNull++; - if (move_is_castle(m)) + if (is_castle(m)) { st->key = key; do_castle_move(m); @@ -863,18 +814,18 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } Color us = side_to_move(); - Color them = opposite_color(us); + Color them = flip(us); Square from = move_from(m); Square to = move_to(m); - bool ep = move_is_ep(m); - bool pm = move_is_promotion(m); + bool ep = is_enpassant(m); + bool pm = is_promotion(m); Piece piece = piece_on(from); - PieceType pt = piece_type(piece); - PieceType capture = ep ? PAWN : piece_type(piece_on(to)); + PieceType pt = type_of(piece); + PieceType capture = ep ? PAWN : type_of(piece_on(to)); - assert(piece_color(piece_on(from)) == us); - assert(piece_color(piece_on(to)) == them || square_is_empty(to)); + assert(color_of(piece_on(from)) == us); + assert(color_of(piece_on(to)) == them || square_is_empty(to)); assert(!(ep || pm) || piece == make_piece(us, PAWN)); assert(!pm || relative_rank(us, to) == RANK_8); @@ -930,7 +881,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Set en passant square, only if moved pawn can be captured if ((to ^ from) == 16) { - if (attacks_from(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them)) + if (attacks_from(from + pawn_push(us), us) & pieces(PAWN, them)) { st->epSquare = Square((int(from) + int(to)) / 2); key ^= zobEp[st->epSquare]; @@ -1017,7 +968,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Finish - sideToMove = opposite_color(sideToMove); + sideToMove = flip(sideToMove); st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); assert(is_ok()); @@ -1039,10 +990,10 @@ void Position::do_capture_move(Key& key, PieceType capture, Color them, Square t { if (ep) // en passant ? { - capsq = (them == BLACK)? (to - DELTA_N) : (to - DELTA_S); + capsq = to + pawn_push(them); assert(to == st->epSquare); - assert(relative_rank(opposite_color(them), to) == RANK_6); + assert(relative_rank(flip(them), to) == RANK_6); assert(piece_on(to) == PIECE_NONE); assert(piece_on(capsq) == make_piece(them, PAWN)); @@ -1094,11 +1045,11 @@ void Position::do_capture_move(Key& key, PieceType capture, Color them, Square t void Position::do_castle_move(Move m) { - assert(move_is_ok(m)); - assert(move_is_castle(m)); + assert(is_ok(m)); + assert(is_castle(m)); Color us = side_to_move(); - Color them = opposite_color(us); + Color them = flip(us); // Find source squares for king and rook Square kfrom = move_from(m); @@ -1180,7 +1131,7 @@ void Position::do_castle_move(Move m) { st->checkersBB = attackers_to(king_square(them)) & pieces(us); // Finish - sideToMove = opposite_color(sideToMove); + sideToMove = flip(sideToMove); st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); assert(is_ok()); @@ -1192,28 +1143,27 @@ void Position::do_castle_move(Move m) { void Position::undo_move(Move m) { - assert(is_ok()); - assert(move_is_ok(m)); + assert(is_ok(m)); - sideToMove = opposite_color(sideToMove); + sideToMove = flip(sideToMove); - if (move_is_castle(m)) + if (is_castle(m)) { undo_castle_move(m); return; } Color us = side_to_move(); - Color them = opposite_color(us); + Color them = flip(us); Square from = move_from(m); Square to = move_to(m); - bool ep = move_is_ep(m); - bool pm = move_is_promotion(m); + bool ep = is_enpassant(m); + bool pm = is_promotion(m); - PieceType pt = piece_type(piece_on(to)); + PieceType pt = type_of(piece_on(to)); assert(square_is_empty(from)); - assert(piece_color(piece_on(to)) == us); + assert(color_of(piece_on(to)) == us); assert(!pm || relative_rank(us, to) == RANK_8); assert(!ep || to == st->previous->epSquare); assert(!ep || relative_rank(us, to) == RANK_6); @@ -1262,7 +1212,7 @@ void Position::undo_move(Move m) { Square capsq = to; if (ep) - capsq = (us == WHITE)? (to - DELTA_N) : (to - DELTA_S); + capsq = to - pawn_push(us); assert(st->capturedType != KING); assert(!ep || square_is_empty(capsq)); @@ -1296,8 +1246,8 @@ void Position::undo_move(Move m) { void Position::undo_castle_move(Move m) { - assert(move_is_ok(m)); - assert(move_is_castle(m)); + assert(is_ok(m)); + assert(is_castle(m)); // When we have arrived here, some work has already been done by // Position::undo_move. In particular, the side to move has been switched, @@ -1366,7 +1316,6 @@ void Position::undo_castle_move(Move m) { void Position::do_null_move(StateInfo& backupSt) { - assert(is_ok()); assert(!in_check()); // Back up the information necessary to undo the null move to the supplied @@ -1380,10 +1329,6 @@ void Position::do_null_move(StateInfo& backupSt) { backupSt.pliesFromNull = st->pliesFromNull; st->previous = &backupSt; - // Save the current key to the history[] array, in order to be able to - // detect repetition draws. - history[st->gamePly++] = st->key; - // Update the necessary information if (st->epSquare != SQ_NONE) st->key ^= zobEp[st->epSquare]; @@ -1391,11 +1336,13 @@ void Position::do_null_move(StateInfo& backupSt) { st->key ^= zobSideToMove; prefetch((char*)TT.first_entry(st->key)); - sideToMove = opposite_color(sideToMove); + sideToMove = flip(sideToMove); st->epSquare = SQ_NONE; st->rule50++; st->pliesFromNull = 0; st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue; + + assert(is_ok()); } @@ -1403,7 +1350,6 @@ void Position::do_null_move(StateInfo& backupSt) { void Position::undo_null_move() { - assert(is_ok()); assert(!in_check()); // Restore information from the our backup StateInfo object @@ -1415,9 +1361,10 @@ void Position::undo_null_move() { st->pliesFromNull = backupSt->pliesFromNull; // Update the necessary information - sideToMove = opposite_color(sideToMove); + sideToMove = flip(sideToMove); st->rule50--; - st->gamePly--; + + assert(is_ok()); } @@ -1429,7 +1376,7 @@ void Position::undo_null_move() { int Position::see_sign(Move m) const { - assert(move_is_ok(m)); + assert(is_ok(m)); Square from = move_from(m); Square to = move_to(m); @@ -1451,26 +1398,26 @@ int Position::see(Move m) const { PieceType capturedType, pt; Color stm; - assert(move_is_ok(m)); + assert(is_ok(m)); // As castle moves are implemented as capturing the rook, they have // SEE == RookValueMidgame most of the times (unless the rook is under // attack). - if (move_is_castle(m)) + if (is_castle(m)) return 0; from = move_from(m); to = move_to(m); - capturedType = piece_type(piece_on(to)); + capturedType = type_of(piece_on(to)); occupied = occupied_squares(); // Handle en passant moves - if (st->epSquare == to && piece_type(piece_on(from)) == PAWN) + if (st->epSquare == to && type_of(piece_on(from)) == PAWN) { - Square capQq = (side_to_move() == WHITE ? to - DELTA_N : to - DELTA_S); + Square capQq = to - pawn_push(side_to_move()); assert(capturedType == PIECE_TYPE_NONE); - assert(piece_type(piece_on(capQq)) == PAWN); + assert(type_of(piece_on(capQq)) == PAWN); // Remove the captured pawn clear_bit(&occupied, capQq); @@ -1483,7 +1430,7 @@ int Position::see(Move m) const { attackers = attackers_to(to, occupied); // If the opponent has no attackers we are finished - stm = opposite_color(piece_color(piece_on(from))); + stm = flip(color_of(piece_on(from))); stmAttackers = attackers & pieces(stm); if (!stmAttackers) return PieceValueMidgame[capturedType]; @@ -1495,7 +1442,7 @@ int Position::see(Move m) const { // capture with the least valuable piece. After each capture, we look for // new X-ray attacks from behind the capturing piece. swapList[0] = PieceValueMidgame[capturedType]; - capturedType = piece_type(piece_on(from)); + capturedType = type_of(piece_on(from)); do { // Locate the least valuable attacker for the side to move. The loop @@ -1521,7 +1468,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 = opposite_color(stm); + stm = flip(stm); stmAttackers = attackers & pieces(stm); // Stop before processing a king capture @@ -1566,7 +1513,6 @@ void Position::clear() { castleRightsMask[sq] = ALL_CASTLES; } sideToMove = WHITE; - fullMoves = 1; nodes = 0; } @@ -1576,8 +1522,8 @@ void Position::clear() { void Position::put_piece(Piece p, Square s) { - Color c = piece_color(p); - PieceType pt = piece_type(p); + Color c = color_of(p); + PieceType pt = type_of(p); board[s] = p; index[s] = pieceCount[c][pt]++; @@ -1600,7 +1546,7 @@ Key Position::compute_key() const { for (Square s = SQ_A1; s <= SQ_H8; s++) if (!square_is_empty(s)) - result ^= zobrist[piece_color(piece_on(s))][piece_type(piece_on(s))][s]; + result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s]; if (ep_square() != SQ_NONE) result ^= zobEp[ep_square()]; @@ -1707,9 +1653,24 @@ bool Position::is_draw() const { // Draw by repetition? if (!SkipRepetition) - for (int i = 4, e = Min(Min(st->gamePly, st->rule50), st->pliesFromNull); i <= e; i += 2) - if (history[st->gamePly - i] == st->key) - return true; + { + int i = 4, e = Min(st->rule50, st->pliesFromNull); + + if (i <= e) + { + StateInfo* stp = st->previous->previous; + + do { + stp = stp->previous->previous; + + if (stp->key == st->key) + return true; + + i +=2; + + } while (i <= e); + } + } return false; } @@ -1732,7 +1693,7 @@ bool Position::is_mate() const { /// 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 +/// Second, the black halves of the tables are initialized by flipping /// and changing the sign of the corresponding white scores. void Position::init() { @@ -1753,22 +1714,19 @@ void Position::init() { zobSideToMove = rk.rand(); zobExclusion = rk.rand(); - for (Square s = SQ_A1; s <= SQ_H8; s++) - for (Piece p = WP; p <= WK; p++) + for (Piece p = WP; p <= WK; p++) + for (Square s = SQ_A1; s <= SQ_H8; s++) + { pieceSquareTable[p][s] = make_score(MgPST[p][s], EgPST[p][s]); - - for (Square s = SQ_A1; s <= SQ_H8; s++) - for (Piece p = BP; p <= BK; p++) - pieceSquareTable[p][s] = -pieceSquareTable[p-8][flip_square(s)]; + pieceSquareTable[p+8][flip(s)] = -pieceSquareTable[p][s]; + } } -/// Position::flip() flips position with the white and black sides reversed. This +/// Position::flip_me() flips position with the white and black sides reversed. This /// is only useful for debugging especially for finding evaluation symmetry bugs. -void Position::flip() { - - assert(is_ok()); +void Position::flip_me() { // Make a copy of current position before to start changing const Position pos(*this, threadID); @@ -1779,27 +1737,27 @@ void Position::flip() { // 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_square(s)); + put_piece(Piece(pos.piece_on(s) ^ 8), flip(s)); // Side to move - sideToMove = opposite_color(pos.side_to_move()); + sideToMove = flip(pos.side_to_move()); // Castling rights if (pos.can_castle(WHITE_OO)) - set_castle(BLACK_OO, king_square(BLACK), flip_square(pos.castle_rook_square(WHITE_OO))); + set_castle(BLACK_OO, king_square(BLACK), flip(pos.castle_rook_square(WHITE_OO))); if (pos.can_castle(WHITE_OOO)) - set_castle(BLACK_OOO, king_square(BLACK), flip_square(pos.castle_rook_square(WHITE_OOO))); + set_castle(BLACK_OOO, king_square(BLACK), flip(pos.castle_rook_square(WHITE_OOO))); if (pos.can_castle(BLACK_OO)) - set_castle(WHITE_OO, king_square(WHITE), flip_square(pos.castle_rook_square(BLACK_OO))); + set_castle(WHITE_OO, king_square(WHITE), flip(pos.castle_rook_square(BLACK_OO))); if (pos.can_castle(BLACK_OOO)) - set_castle(WHITE_OOO, king_square(WHITE), flip_square(pos.castle_rook_square(BLACK_OOO))); + set_castle(WHITE_OOO, king_square(WHITE), flip(pos.castle_rook_square(BLACK_OOO))); // En passant square if (pos.st->epSquare != SQ_NONE) - st->epSquare = flip_square(pos.st->epSquare); + st->epSquare = flip(pos.st->epSquare); // Checkers - st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(opposite_color(sideToMove)); + st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove)); // Hash keys st->key = compute_key(); @@ -1859,8 +1817,8 @@ bool Position::is_ok(int* failedStep) const { { int kingCount[2] = {0, 0}; for (Square s = SQ_A1; s <= SQ_H8; s++) - if (piece_type(piece_on(s)) == KING) - kingCount[piece_color(piece_on(s))]++; + if (type_of(piece_on(s)) == KING) + kingCount[color_of(piece_on(s))]++; if (kingCount[0] != 1 || kingCount[1] != 1) return false; @@ -1871,7 +1829,7 @@ bool Position::is_ok(int* failedStep) const { if (debugKingCapture) { Color us = side_to_move(); - Color them = opposite_color(us); + Color them = flip(us); Square ksq = king_square(them); if (attackers_to(ksq) & pieces(us)) return false;