X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fposition.cpp;h=435384cf93740bea491d47e4f3112e39dd5abe8d;hb=b7cb6180cf2a6fcab81dcd1b07f9dd4e650c8ea4;hp=3bb8fef931c00924a9aa52cf3823fdecda4a73f6;hpb=734941672ee239636d4327525243c39261a9b171;p=stockfish diff --git a/src/position.cpp b/src/position.cpp index 3bb8fef9..435384cf 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -210,8 +210,8 @@ void Position::from_fen(const std::string& fen) { key = compute_key(); pawnKey = compute_pawn_key(); materialKey = compute_material_key(); - mgValue = compute_mg_value(); - egValue = compute_eg_value(); + mgValue = compute_value(); + egValue = compute_value(); npMaterial[WHITE] = compute_non_pawn_material(WHITE); npMaterial[BLACK] = compute_non_pawn_material(BLACK); } @@ -536,29 +536,19 @@ bool Position::pl_move_is_legal(Move m) const { } -/// Position::move_is_check() tests whether a pseudo-legal move is a check. -/// There are two versions of this function: One which takes only a move as -/// input, and one which takes a move and a bitboard of discovered check -/// candidates. The latter function is faster, and should always be preferred -/// when a discovered check candidates bitboard has already been computed. +/// Position::move_is_check() tests whether a pseudo-legal move is a check bool Position::move_is_check(Move m) const { - Bitboard dc = discovered_check_candidates(side_to_move()); - return move_is_check(m, dc); -} - -bool Position::move_is_check(Move m, Bitboard dcCandidates) const { - assert(is_ok()); assert(move_is_ok(m)); - assert(dcCandidates == discovered_check_candidates(side_to_move())); Color us = side_to_move(); Color them = opposite_color(us); Square from = move_from(m); Square to = move_to(m); Square ksq = king_square(them); + Bitboard dcCandidates = discovered_check_candidates(us); assert(color_of_piece_on(from) == us); assert(piece_on(ksq) == piece_of_color_and_type(them, KING)); @@ -679,62 +669,6 @@ bool Position::move_is_capture(Move m) const { } -/// Position::backup() is called when making a move. All information -/// necessary to restore the position when the move is later unmade -/// is saved to an UndoInfo object. The function Position::restore -/// does the reverse operation: When one does a backup followed by -/// a restore with the same UndoInfo object, the position is restored -/// to the state before backup was called. - -void Position::backup(UndoInfo& u) const { - - u.castleRights = castleRights; - u.epSquare = epSquare; - u.checkersBB = checkersBB; - u.key = key; - u.pawnKey = pawnKey; - u.materialKey = materialKey; - u.rule50 = rule50; - u.lastMove = lastMove; - u.mgValue = mgValue; - u.egValue = egValue; - u.capture = NO_PIECE_TYPE; - - for (Color c = WHITE; c <= BLACK; c++) - { - u.pinners[c] = pinners[c]; - u.pinned[c] = pinned[c]; - u.dcCandidates[c] = dcCandidates[c]; - } -} - - -/// Position::restore() is called when unmaking a move. It copies back -/// the information backed up during a previous call to Position::backup. - -void Position::restore(const UndoInfo& u) { - - castleRights = u.castleRights; - epSquare = u.epSquare; - checkersBB = u.checkersBB; - key = u.key; - pawnKey = u.pawnKey; - materialKey = u.materialKey; - rule50 = u.rule50; - lastMove = u.lastMove; - mgValue = u.mgValue; - egValue = u.egValue; - // u.capture is restored in undo_move() - - for (Color c = WHITE; c <= BLACK; c++) - { - pinners[c] = u.pinners[c]; - pinned[c] = u.pinned[c]; - dcCandidates[c] = u.dcCandidates[c]; - } -} - - /// Position::update_checkers() is a private method to udpate chekers info template @@ -758,25 +692,20 @@ inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square /// Position::do_move() makes a move, and backs up all information necessary /// to undo the move to an UndoInfo object. The move is assumed to be legal. /// Pseudo-legal moves should be filtered out before this function is called. -/// There are two versions of this function, one which takes only the move and -/// the UndoInfo as input, and one which takes a third parameter, a bitboard of -/// discovered check candidates. The second version is faster, because knowing -/// the discovered check candidates makes it easier to update the checkersBB -/// member variable in the position object. void Position::do_move(Move m, UndoInfo& u) { - do_move(m, u, discovered_check_candidates(side_to_move())); -} - -void Position::do_move(Move m, UndoInfo& u, Bitboard dc) { - assert(is_ok()); assert(move_is_ok(m)); + // Get now the current (pre-move) dc candidates that we will use + // in update_checkers(). + Bitboard oldDcCandidates = discovered_check_candidates(side_to_move()); + // Back up the necessary information to our UndoInfo object (except the // captured piece, which is taken care of later. - backup(u); + u = undoInfoUnion; + u.capture = NO_PIECE_TYPE; // Save the current key to the history[] array, in order to be able to // detect repetition draws. @@ -829,10 +758,10 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dc) { key ^= zobrist[us][piece][from] ^ zobrist[us][piece][to]; // Update incremental scores - mgValue -= mg_pst(us, piece, from); - mgValue += mg_pst(us, piece, to); - egValue -= eg_pst(us, piece, from); - egValue += eg_pst(us, piece, to); + mgValue -= pst(us, piece, from); + mgValue += pst(us, piece, to); + egValue -= pst(us, piece, from); + egValue += pst(us, piece, to); // If the moving piece was a king, update the king square if (piece == KING) @@ -881,12 +810,12 @@ void Position::do_move(Move m, UndoInfo& u, Bitboard dc) { Square ksq = king_square(them); switch (piece) { - case PAWN: update_checkers(&checkersBB, ksq, from, to, dc); break; - case KNIGHT: update_checkers(&checkersBB, ksq, from, to, dc); break; - case BISHOP: update_checkers(&checkersBB, ksq, from, to, dc); break; - case ROOK: update_checkers(&checkersBB, ksq, from, to, dc); break; - case QUEEN: update_checkers(&checkersBB, ksq, from, to, dc); break; - case KING: update_checkers(&checkersBB, ksq, from, to, dc); break; + case PAWN: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case KNIGHT: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case BISHOP: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case ROOK: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case QUEEN: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; + case KING: update_checkers(&checkersBB, ksq, from, to, oldDcCandidates); break; default: assert(false); break; } } @@ -922,8 +851,8 @@ void Position::do_capture_move(Move m, PieceType capture, Color them, Square to) pawnKey ^= zobrist[them][PAWN][to]; // Update incremental scores - mgValue -= mg_pst(them, capture, to); - egValue -= eg_pst(them, capture, to); + mgValue -= pst(them, capture, to); + egValue -= pst(them, capture, to); assert(!move_promotion(m) || capture != PAWN); @@ -1010,14 +939,14 @@ void Position::do_castle_move(Move m) { index[rto] = tmp; // Update incremental scores - mgValue -= mg_pst(us, KING, kfrom); - mgValue += mg_pst(us, KING, kto); - egValue -= eg_pst(us, KING, kfrom); - egValue += eg_pst(us, KING, kto); - mgValue -= mg_pst(us, ROOK, rfrom); - mgValue += mg_pst(us, ROOK, rto); - egValue -= eg_pst(us, ROOK, rfrom); - egValue += eg_pst(us, ROOK, rto); + mgValue -= pst(us, KING, kfrom); + mgValue += pst(us, KING, kto); + egValue -= pst(us, KING, kfrom); + egValue += pst(us, KING, kto); + mgValue -= pst(us, ROOK, rfrom); + mgValue += pst(us, ROOK, rto); + egValue -= pst(us, ROOK, rfrom); + egValue += pst(us, ROOK, rto); // Update hash key key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto]; @@ -1110,10 +1039,10 @@ void Position::do_promotion_move(Move m, UndoInfo &u) { index[to] = pieceCount[us][promotion] - 1; // Update incremental scores - mgValue -= mg_pst(us, PAWN, from); - mgValue += mg_pst(us, promotion, to); - egValue -= eg_pst(us, PAWN, from); - egValue += eg_pst(us, promotion, to); + mgValue -= pst(us, PAWN, from); + mgValue += pst(us, promotion, to); + egValue -= pst(us, PAWN, from); + egValue += pst(us, promotion, to); // Update material npMaterial[us] += piece_value_midgame(promotion); @@ -1204,12 +1133,12 @@ void Position::do_ep_move(Move m) { pawnKey ^= zobrist[them][PAWN][capsq]; // Update incremental scores - mgValue -= mg_pst(them, PAWN, capsq); - mgValue -= mg_pst(us, PAWN, from); - mgValue += mg_pst(us, PAWN, to); - egValue -= eg_pst(them, PAWN, capsq); - egValue -= eg_pst(us, PAWN, from); - egValue += eg_pst(us, PAWN, to); + mgValue -= pst(them, PAWN, capsq); + mgValue -= pst(us, PAWN, from); + mgValue += pst(us, PAWN, to); + egValue -= pst(them, PAWN, capsq); + egValue -= pst(us, PAWN, from); + egValue += pst(us, PAWN, to); // Reset en passant square epSquare = SQ_NONE; @@ -1237,7 +1166,7 @@ void Position::undo_move(Move m, const UndoInfo &u) { // Restore information from our UndoInfo object (except the captured piece, // which is taken care of later) - restore(u); + undoInfoUnion = u; if (move_is_castle(m)) undo_castle_move(m); @@ -1882,13 +1811,12 @@ Key Position::compute_material_key() const { } -/// Position::compute_mg_value() and Position::compute_eg_value() compute the -/// incremental scores for the middle game and the endgame. These functions -/// are used to initialize the incremental scores when a new position is set -/// up, and to verify that the scores are correctly updated by do_move -/// and undo_move when the program is running in debug mode. - -Value Position::compute_mg_value() const { +/// Position::compute_value() compute the incremental scores for the middle +/// game and the endgame. These functions are used to initialize the incremental +/// scores when a new position is set up, and to verify that the scores are correctly +/// updated by do_move and undo_move when the program is running in debug mode. +template +Value Position::compute_value() const { Value result = Value(0); Bitboard b; @@ -1902,31 +1830,12 @@ Value Position::compute_mg_value() const { { s = pop_1st_bit(&b); assert(piece_on(s) == piece_of_color_and_type(c, pt)); - result += mg_pst(c, pt, s); + result += pst(c, pt, s); } } - result += (side_to_move() == WHITE)? TempoValueMidgame / 2 : -TempoValueMidgame / 2; - return result; -} - -Value Position::compute_eg_value() const { - Value result = Value(0); - Bitboard b; - Square s; - - for (Color c = WHITE; c <= BLACK; c++) - for (PieceType pt = PAWN; pt <= KING; pt++) - { - b = pieces_of_color_and_type(c, pt); - while(b) - { - s = pop_1st_bit(&b); - assert(piece_on(s) == piece_of_color_and_type(c, pt)); - result += eg_pst(c, pt, s); - } - } - result += (side_to_move() == WHITE)? TempoValueEndgame / 2 : -TempoValueEndgame / 2; + const Value TempoValue = (Phase == MidGame ? TempoValueMidgame : TempoValueEndgame); + result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2; return result; } @@ -2147,8 +2056,8 @@ void Position::flipped_copy(const Position &pos) { materialKey = compute_material_key(); // Incremental scores - mgValue = compute_mg_value(); - egValue = compute_eg_value(); + mgValue = compute_value(); + egValue = compute_value(); // Material npMaterial[WHITE] = compute_non_pawn_material(WHITE); @@ -2277,10 +2186,10 @@ bool Position::is_ok(int* failedStep) const { if (failedStep) (*failedStep)++; if (debugIncrementalEval) { - if (mgValue != compute_mg_value()) + if (mgValue != compute_value()) return false; - if (egValue != compute_eg_value()) + if (egValue != compute_value()) return false; }