key = compute_key();
pawnKey = compute_pawn_key();
materialKey = compute_material_key();
- mgValue = compute_mg_value();
- egValue = compute_eg_value();
+ mgValue = compute_value<MidGame>();
+ egValue = compute_value<EndGame>();
npMaterial[WHITE] = compute_non_pawn_material(WHITE);
npMaterial[BLACK] = compute_non_pawn_material(BLACK);
}
}
-/// 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<PieceType Piece>
// 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.
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<MidGame>(us, piece, from);
+ mgValue += pst<MidGame>(us, piece, to);
+ egValue -= pst<EndGame>(us, piece, from);
+ egValue += pst<EndGame>(us, piece, to);
// If the moving piece was a king, update the king square
if (piece == KING)
pawnKey ^= zobrist[them][PAWN][to];
// Update incremental scores
- mgValue -= mg_pst(them, capture, to);
- egValue -= eg_pst(them, capture, to);
+ mgValue -= pst<MidGame>(them, capture, to);
+ egValue -= pst<EndGame>(them, capture, to);
assert(!move_promotion(m) || capture != PAWN);
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<MidGame>(us, KING, kfrom);
+ mgValue += pst<MidGame>(us, KING, kto);
+ egValue -= pst<EndGame>(us, KING, kfrom);
+ egValue += pst<EndGame>(us, KING, kto);
+ mgValue -= pst<MidGame>(us, ROOK, rfrom);
+ mgValue += pst<MidGame>(us, ROOK, rto);
+ egValue -= pst<EndGame>(us, ROOK, rfrom);
+ egValue += pst<EndGame>(us, ROOK, rto);
// Update hash key
key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
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<MidGame>(us, PAWN, from);
+ mgValue += pst<MidGame>(us, promotion, to);
+ egValue -= pst<EndGame>(us, PAWN, from);
+ egValue += pst<EndGame>(us, promotion, to);
// Update material
npMaterial[us] += piece_value_midgame(promotion);
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<MidGame>(them, PAWN, capsq);
+ mgValue -= pst<MidGame>(us, PAWN, from);
+ mgValue += pst<MidGame>(us, PAWN, to);
+ egValue -= pst<EndGame>(them, PAWN, capsq);
+ egValue -= pst<EndGame>(us, PAWN, from);
+ egValue += pst<EndGame>(us, PAWN, to);
// Reset en passant square
epSquare = SQ_NONE;
// 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);
}
-/// 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<Position::GamePhase Phase>
+Value Position::compute_value() const {
Value result = Value(0);
Bitboard b;
{
s = pop_1st_bit(&b);
assert(piece_on(s) == piece_of_color_and_type(c, pt));
- result += mg_pst(c, pt, s);
+ result += pst<Phase>(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;
}
materialKey = compute_material_key();
// Incremental scores
- mgValue = compute_mg_value();
- egValue = compute_eg_value();
+ mgValue = compute_value<MidGame>();
+ egValue = compute_value<EndGame>();
// Material
npMaterial[WHITE] = compute_non_pawn_material(WHITE);
if (failedStep) (*failedStep)++;
if (debugIncrementalEval)
{
- if (mgValue != compute_mg_value())
+ if (mgValue != compute_value<MidGame>())
return false;
- if (egValue != compute_eg_value())
+ if (egValue != compute_value<EndGame>())
return false;
}
projects / stockfish / blobdiff