X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=05a02f158948e73513b33e62e24ef095377c3e4e;hp=2227c553ca6c7a79c1e5f50e8e588ce359ddc618;hb=a6e0f62a4f83bf4303e920d5f689de7cbc0467e8;hpb=db4cd89cb889446fb349d0d93640b640b1b9a8a1 diff --git a/src/position.cpp b/src/position.cpp index 2227c553..05a02f15 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -41,67 +41,16 @@ static const string PieceToChar(" PNBRQK pnbrqk"); CACHE_LINE_ALIGNMENT -Score pieceSquareTable[PIECE_NB][SQUARE_NB]; +Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Value PieceValue[PHASE_NB][PIECE_NB] = { { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg }, { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg } }; -namespace Zobrist { - -Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; -Key enpassant[FILE_NB]; -Key castle[CASTLE_RIGHT_NB]; -Key side; -Key exclusion; - -/// init() 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 PSQT[] tables. Second, the black -/// halves of the tables are initialized by flipping and changing the sign of -/// the white scores. - -void init() { - - RKISS rk; - - for (Color c = WHITE; c <= BLACK; c++) - for (PieceType pt = PAWN; pt <= KING; pt++) - for (Square s = SQ_A1; s <= SQ_H8; s++) - psq[c][pt][s] = rk.rand(); - - for (File f = FILE_A; f <= FILE_H; f++) - enpassant[f] = rk.rand(); - - for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++) - { - Bitboard b = cr; - while (b) - { - Key k = castle[1ULL << pop_lsb(&b)]; - castle[cr] ^= k ? k : rk.rand(); - } - } - - side = rk.rand(); - exclusion = rk.rand(); - - for (Piece pc = W_PAWN; pc <= W_KING; pc++) - { - PieceValue[MG][~pc] = PieceValue[MG][pc]; - PieceValue[EG][~pc] = PieceValue[EG][pc]; - - Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]); - - for (Square s = SQ_A1; s <= SQ_H8; s++) - { - pieceSquareTable[ pc][ s] = (v + PSQT[pc][s]); - pieceSquareTable[~pc][~s] = -(v + PSQT[pc][s]); - } - } -} - -} // namespace Zobrist - +Key Zobrist::psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; +Key Zobrist::enpassant[FILE_NB]; +Key Zobrist::castle[CASTLE_RIGHT_NB]; +Key Zobrist::side; +Key Zobrist::exclusion; namespace { @@ -156,6 +105,53 @@ CheckInfo::CheckInfo(const Position& pos) { } +/// Position::init() 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 PSQT[] tables. Second, +/// the black halves of the tables are initialized by flipping and changing the +/// sign of the white scores. + +void Position::init() { + + RKISS rk; + + for (Color c = WHITE; c <= BLACK; c++) + for (PieceType pt = PAWN; pt <= KING; pt++) + for (Square s = SQ_A1; s <= SQ_H8; s++) + Zobrist::psq[c][pt][s] = rk.rand(); + + for (File f = FILE_A; f <= FILE_H; f++) + Zobrist::enpassant[f] = rk.rand(); + + for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++) + { + Bitboard b = cr; + while (b) + { + Key k = Zobrist::castle[1ULL << pop_lsb(&b)]; + Zobrist::castle[cr] ^= k ? k : rk.rand(); + } + } + + Zobrist::side = rk.rand(); + Zobrist::exclusion = rk.rand(); + + for (PieceType pt = PAWN; pt <= KING; pt++) + { + PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt]; + PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt]; + + Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]); + + for (Square s = SQ_A1; s <= SQ_H8; s++) + { + psq[WHITE][pt][ s] = (v + PSQT[pt][s]); + psq[BLACK][pt][~s] = -(v + PSQT[pt][s]); + } + } +} + + /// Position::operator=() creates a copy of 'pos'. We want the new born Position /// object do not depend on any external data so we detach state pointer from /// the source one. @@ -288,7 +284,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { st->key = compute_key(); st->pawnKey = compute_pawn_key(); st->materialKey = compute_material_key(); - st->psqScore = compute_psq_score(); + st->psq = compute_psq_score(); st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); @@ -747,17 +743,17 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); - Piece piece = piece_on(from); - PieceType pt = type_of(piece); + Piece pc = piece_on(from); + PieceType pt = type_of(pc); PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); - assert(color_of(piece) == us); + assert(color_of(pc) == us); assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE); assert(capture != KING); if (type_of(m) == CASTLE) { - assert(piece == make_piece(us, KING)); + assert(pc == make_piece(us, KING)); bool kingSide = to > from; Square rfrom = to; // Castle is encoded as "king captures friendly rook" @@ -767,9 +763,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI do_castle(from, to, rfrom, rto); + st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom]; k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto]; - st->psqScore += pieceSquareTable[make_piece(us, ROOK)][rto] - - pieceSquareTable[make_piece(us, ROOK)][rfrom]; } if (capture) @@ -821,7 +816,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI prefetch((char*)thisThread->materialTable[st->materialKey]); // Update incremental scores - st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq]; + st->psq -= psq[them][capture][capsq]; // Reset rule 50 counter st->rule50 = 0; @@ -857,7 +852,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI byColorBB[us] ^= from_to_bb; board[from] = NO_PIECE; - board[to] = piece; + board[to] = pc; // Update piece lists, index[from] is not updated and becomes stale. This // works as long as index[] is accessed just by known occupied squares. @@ -904,8 +899,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]]; // Update incremental score - st->psqScore += pieceSquareTable[make_piece(us, promotion)][to] - - pieceSquareTable[make_piece(us, PAWN)][to]; + st->psq += psq[us][promotion][to] - psq[us][PAWN][to]; // Update material st->npMaterial[us] += PieceValue[MG][promotion]; @@ -920,7 +914,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Update incremental scores - st->psqScore += pieceSquareTable[piece][to] - pieceSquareTable[piece][from]; + st->psq += psq[us][pt][to] - psq[us][pt][from]; // Set capture piece st->capturedType = capture; @@ -1351,7 +1345,8 @@ Score Position::compute_psq_score() const { for (Bitboard b = pieces(); b; ) { Square s = pop_lsb(&b); - score += pieceSquareTable[piece_on(s)][s]; + Piece pc = piece_on(s); + score += psq[color_of(pc)][type_of(pc)][s]; } return score; @@ -1446,7 +1441,7 @@ void Position::flip() { st->key = compute_key(); st->pawnKey = compute_pawn_key(); st->materialKey = compute_material_key(); - st->psqScore = compute_psq_score(); + st->psq = compute_psq_score(); st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); @@ -1537,7 +1532,7 @@ bool Position::pos_is_ok(int* failedStep) const { if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key()) return false; - if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score()) + if ((*step)++, debugIncrementalEval && st->psq != compute_psq_score()) return false; if ((*step)++, debugNonPawnMaterial)