X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=3a0f8b1c90f8bba670b942488b87966092cefd69;hp=ef510766afcd592e8e29b19f0e88a464447b51b9;hb=c2fc80e5d16339266b5bf6687fa843ff65de3b3e;hpb=821e1c72337e435d805aa2e29743d8b79c9d65a9 diff --git a/src/position.cpp b/src/position.cpp index ef510766..3a0f8b1c 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -36,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; @@ -66,7 +66,7 @@ const Value PieceValueEndgame[17] = { namespace { // Bonus for having the side to move (modified by Joona Kiiski) - const Score TempoValue = make_score(48, 22); + const Score Tempo = make_score(48, 22); // To convert a Piece to and from a FEN char const string PieceToChar(" PNBRQK pnbrqk ."); @@ -92,33 +92,27 @@ CheckInfo::CheckInfo(const Position& pos) { } -/// Position c'tors. Here we always create a copy of the original position -/// 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::copy() 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. -void Position::copy(const Position& pos, int th) { +void Position::copy(const Position& pos, Thread* th) { memcpy(this, &pos, sizeof(Position)); startState = *st; st = &startState; - threadID = th; + thisThread = th; nodes = 0; assert(pos_is_ok()); } -Position::Position(const string& fen, bool isChess960, int th) { - - from_fen(fen, isChess960); - threadID = th; -} - /// 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). -void Position::from_fen(const string& fenStr, bool isChess960) { +void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) { /* A FEN string defines a particular position using only the ASCII character set. @@ -229,11 +223,12 @@ void Position::from_fen(const string& fenStr, bool isChess960) { st->key = compute_key(); st->pawnKey = compute_pawn_key(); st->materialKey = compute_material_key(); - st->value = compute_value(); + st->psqScore = 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); chess960 = isChess960; + thisThread = th; assert(pos_is_ok()); } @@ -242,14 +237,27 @@ 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 color and the rook starting square. -void Position::set_castle_right(Color c, Square rsq) { +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; + + st->castleRights |= cr; + castleRightsMask[kfrom] |= cr; + castleRightsMask[rfrom] |= cr; + castleRookSquare[cr] = rfrom; + + Square kto = relative_square(c, kingSide ? SQ_G1 : SQ_C1); + Square rto = relative_square(c, kingSide ? SQ_F1 : SQ_D1); - int f = (rsq < king_square(c) ? WHITE_OOO : WHITE_OO) << c; + for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++) + if (s != kfrom && s != rfrom) + castlePath[cr] |= s; - st->castleRights |= f; - castleRightsMask[king_square(c)] ^= f; - castleRightsMask[rsq] ^= f; - castleRookSquare[f] = rsq; + for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++) + if (s != kfrom && s != rfrom) + castlePath[cr] |= s; } @@ -270,7 +278,7 @@ const string Position::to_fen() const { { sq = make_square(file, rank); - if (square_is_empty(sq)) + if (square_empty(sq)) emptyCnt++; else { @@ -323,7 +331,7 @@ void Position::print(Move move) const { if (move) { - Position p(*this, thread()); + Position p(*this, thisThread); cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move); } @@ -364,10 +372,9 @@ Bitboard Position::hidden_checkers() const { while (pinners) { - b = squares_between(ksq, pop_1st_bit(&pinners)) & occupied_squares(); + b = squares_between(ksq, pop_1st_bit(&pinners)) & pieces(); - // Only one bit set and is an our piece? - if (b && !(b & (b - 1)) && (b & pieces(sideToMove))) + if (b && single_bit(b) && (b & pieces(sideToMove))) result |= b; } return result; @@ -397,7 +404,7 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const { Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { - assert(square_is_ok(s)); + assert(is_ok(s)); switch (type_of(p)) { @@ -415,19 +422,17 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { bool Position::move_attacks_square(Move m, Square s) const { assert(is_ok(m)); - assert(square_is_ok(s)); + assert(is_ok(s)); Bitboard occ, xray; Square from = from_sq(m); Square to = to_sq(m); - Piece piece = piece_on(from); + Piece piece = piece_moved(m); - assert(!square_is_empty(from)); + assert(!square_empty(from)); // Update occupancy as if the piece is moving - occ = occupied_squares(); - occ ^= from; - occ ^= to; + occ = pieces() ^ from ^ to; // The piece moved in 'to' attacks the square 's' ? if (attacks_from(piece, to, occ) & s) @@ -452,7 +457,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { 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 @@ -464,17 +469,13 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { Square to = to_sq(m); Square capsq = to + pawn_push(them); Square ksq = king_square(us); - Bitboard b = occupied_squares(); + Bitboard b = (pieces() ^ 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) == NO_PIECE); - b ^= from; - b ^= capsq; - b |= to; - return !(attacks_bb(ksq, b) & pieces(ROOK, QUEEN, them)) && !(attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, them)); } @@ -517,14 +518,14 @@ bool Position::is_pseudo_legal(const Move m) const { Color them = ~sideToMove; Square from = from_sq(m); Square to = to_sq(m); - Piece pc = piece_on(from); + 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 != NO_PIECE_TYPE) + 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 @@ -570,7 +571,7 @@ bool Position::is_pseudo_legal(const Move m) const { case DELTA_N: case DELTA_S: // Pawn push. The destination square must be empty. - if (!square_is_empty(to)) + if (!square_empty(to)) return false; break; @@ -579,8 +580,8 @@ bool Position::is_pseudo_legal(const Move m) const { // rank, and both the destination square and the square between the // source and destination squares must be empty. if ( rank_of(to) != RANK_4 - || !square_is_empty(to) - || !square_is_empty(from + DELTA_N)) + || !square_empty(to) + || !square_empty(from + DELTA_N)) return false; break; @@ -589,8 +590,8 @@ bool Position::is_pseudo_legal(const Move m) const { // rank, and both the destination square and the square between the // source and destination squares must be empty. if ( rank_of(to) != RANK_5 - || !square_is_empty(to) - || !square_is_empty(from + DELTA_S)) + || !square_empty(to) + || !square_empty(from + DELTA_S)) return false; break; @@ -606,28 +607,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) - { - Bitboard b = occupied_squares(); - b ^= from; - if (attackers_to(to_sq(m), b) & pieces(~us)) - return false; - } - else + if (type_of(pc) != KING) { - 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 (!(target & to_sq(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, pieces() ^ from) & pieces(~us)) + return false; } return true; @@ -664,15 +659,11 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { return false; Color us = sideToMove; - Bitboard b = occupied_squares(); Square ksq = king_square(~us); // Promotion with check ? if (is_promotion(m)) - { - b ^= from; - return attacks_from(Piece(promotion_piece_type(m)), to, b) & ksq; - } + return attacks_from(Piece(promotion_type(m)), to, pieces() ^ from) & ksq; // En passant capture with check ? We have already handled the case // of direct checks and ordinary discovered check, the only case we @@ -681,32 +672,21 @@ 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)); - b ^= from; - b ^= capsq; - b |= to; - return (attacks_bb(ksq, b) & pieces(ROOK, QUEEN, us)) - ||(attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us)); + Bitboard b = (pieces() ^ 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 = (pieces() ^ 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); - } - b ^= kfrom; - b ^= rfrom; - b |= rto; - b |= kto; return attacks_bb(rto, b) & ksq; } @@ -739,7 +719,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI Key pawnKey, materialKey; Value npMaterial[2]; int castleRights, rule50, pliesFromNull; - Score value; + Score psq_score; Square epSquare; }; @@ -802,9 +782,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->npMaterial[them] -= PieceValueMidgame[capture]; // Remove the captured piece - byColorBB[them] ^= capsq; + byTypeBB[ALL_PIECES] ^= capsq; byTypeBB[capture] ^= capsq; - occupied ^= capsq; + byColorBB[them] ^= capsq; // Update piece list, move the last piece at index[capsq] position and // shrink the list. @@ -823,7 +803,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]]; // Update incremental scores - st->value -= pst(make_piece(them, capture), capsq); + st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq]; // Reset rule 50 counter st->rule50 = 0; @@ -835,17 +815,16 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Reset en passant square if (st->epSquare != SQ_NONE) { - k ^= 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])) { - int cr = castleRightsMask[from] & castleRightsMask[to]; - k ^= zobCastle[st->castleRights & (cr ^ ALL_CASTLES)]; - st->castleRights &= cr; + 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 @@ -853,9 +832,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Move the piece Bitboard from_to_bb = SquareBB[from] | SquareBB[to]; - byColorBB[us] ^= from_to_bb; + byTypeBB[ALL_PIECES] ^= from_to_bb; byTypeBB[pt] ^= from_to_bb; - occupied ^= from_to_bb; + byColorBB[us] ^= from_to_bb; board[to] = board[from]; board[from] = NO_PIECE; @@ -869,16 +848,16 @@ 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); - k ^= 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); @@ -904,8 +883,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI ^ zobrist[us][PAWN][pieceCount[us][PAWN]]; // Update incremental score - st->value += pst(make_piece(us, promotion), to) - - pst(make_piece(us, PAWN), to); + st->psqScore += pieceSquareTable[make_piece(us, promotion)][to] + - pieceSquareTable[make_piece(us, PAWN)][to]; // Update material st->npMaterial[us] += PieceValueMidgame[promotion]; @@ -919,11 +898,11 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Prefetch pawn and material hash tables - Threads[threadID].pawnTable.prefetch(st->pawnKey); - Threads[threadID].materialTable.prefetch(st->materialKey); + prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]); + prefetch((char*)thisThread->materialTable.entries[st->materialKey]); // Update incremental scores - st->value += pst_delta(piece, from, to); + st->psqScore += psq_delta(piece, from, to); // Set capture piece st->capturedType = capture; @@ -958,7 +937,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Finish sideToMove = ~sideToMove; - st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); + st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo); assert(pos_is_ok()); } @@ -987,13 +966,13 @@ void Position::undo_move(Move m) { PieceType pt = type_of(piece); PieceType capture = st->capturedType; - assert(square_is_empty(from)); + assert(square_empty(from)); assert(color_of(piece) == us); assert(capture != KING); 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); @@ -1018,9 +997,9 @@ void Position::undo_move(Move m) { // Put the piece back at the source square Bitboard from_to_bb = SquareBB[from] | SquareBB[to]; - byColorBB[us] ^= from_to_bb; + byTypeBB[ALL_PIECES] ^= from_to_bb; byTypeBB[pt] ^= from_to_bb; - occupied ^= from_to_bb; + byColorBB[us] ^= from_to_bb; board[from] = board[to]; board[to] = NO_PIECE; @@ -1045,9 +1024,9 @@ void Position::undo_move(Move m) { } // Restore the captured piece - byColorBB[them] |= capsq; + byTypeBB[ALL_PIECES] |= capsq; byTypeBB[capture] |= capsq; - occupied |= capsq; + byColorBB[them] |= capsq; board[capsq] = make_piece(them, capture); @@ -1101,20 +1080,20 @@ void Position::do_castle_move(Move m) { assert(piece_on(rfrom) == make_piece(us, ROOK)); // Remove pieces from source squares - byColorBB[us] ^= kfrom; + byTypeBB[ALL_PIECES] ^= kfrom; byTypeBB[KING] ^= kfrom; - occupied ^= kfrom; - byColorBB[us] ^= rfrom; + byColorBB[us] ^= kfrom; + byTypeBB[ALL_PIECES] ^= rfrom; byTypeBB[ROOK] ^= rfrom; - occupied ^= rfrom; + byColorBB[us] ^= rfrom; // Put pieces on destination squares - byColorBB[us] |= kto; + byTypeBB[ALL_PIECES] |= kto; byTypeBB[KING] |= kto; - occupied |= kto; - byColorBB[us] |= rto; + byColorBB[us] |= kto; + byTypeBB[ALL_PIECES] |= rto; byTypeBB[ROOK] |= rto; - occupied |= rto; + byColorBB[us] |= rto; // Update board Piece king = make_piece(us, KING); @@ -1136,8 +1115,8 @@ void Position::do_castle_move(Move m) { st->capturedType = NO_PIECE_TYPE; // Update incremental scores - st->value += pst_delta(king, kfrom, kto); - st->value += pst_delta(rook, rfrom, rto); + st->psqScore += psq_delta(king, kfrom, kto); + st->psqScore += psq_delta(rook, rfrom, rto); // Update hash key st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto]; @@ -1146,21 +1125,20 @@ 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 - int cr = castleRightsMask[kfrom]; - st->key ^= zobCastle[st->castleRights & (cr ^ ALL_CASTLES)]; - st->castleRights &= cr; + st->key ^= zobCastle[st->castleRights & castleRightsMask[kfrom]]; + st->castleRights &= ~castleRightsMask[kfrom]; // Update checkers BB st->checkersBB = attackers_to(king_square(~us)) & pieces(us); // Finish sideToMove = ~sideToMove; - st->value += (sideToMove == WHITE ? TempoValue : -TempoValue); + st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo); } else // Undo: point our state pointer back to the previous state @@ -1186,7 +1164,7 @@ void Position::do_null_move(StateInfo& backupSt) { dst->key = src->key; dst->epSquare = src->epSquare; - dst->value = src->value; + dst->psqScore = src->psqScore; dst->rule50 = src->rule50; dst->pliesFromNull = src->pliesFromNull; @@ -1195,7 +1173,7 @@ void Position::do_null_move(StateInfo& backupSt) { 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)); @@ -1203,7 +1181,7 @@ void Position::do_null_move(StateInfo& backupSt) { st->epSquare = SQ_NONE; st->rule50++; st->pliesFromNull = 0; - st->value += (sideToMove == WHITE) ? TempoValue : -TempoValue; + st->psqScore += (sideToMove == WHITE ? Tempo : -Tempo); } assert(pos_is_ok()); @@ -1224,13 +1202,10 @@ int Position::see_sign(Move m) const { assert(is_ok(m)); - Square from = from_sq(m); - Square to = to_sq(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); @@ -1255,7 +1230,7 @@ int Position::see(Move m) const { from = from_sq(m); to = to_sq(m); capturedType = type_of(piece_on(to)); - occ = occupied_squares(); + occ = pieces(); // Handle en passant moves if (is_enpassant(m)) @@ -1340,27 +1315,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] = NO_PIECE; - castleRightsMask[sq] = ALL_CASTLES; - } - sideToMove = WHITE; - nodes = 0; - occupied = 0; } @@ -1376,9 +1340,9 @@ void Position::put_piece(Piece p, Square s) { index[s] = pieceCount[c][pt]++; pieceList[c][pt][index[s]] = s; + byTypeBB[ALL_PIECES] |= s; byTypeBB[pt] |= s; byColorBB[c] |= s; - occupied |= s; } @@ -1392,11 +1356,11 @@ Key Position::compute_key() const { Key result = zobCastle[st->castleRights]; for (Square s = SQ_A1; s <= SQ_H8; s++) - if (!square_is_empty(s)) + if (!square_empty(s)) 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 (sideToMove == BLACK) result ^= zobSideToMove; @@ -1445,11 +1409,11 @@ Key Position::compute_material_key() const { } -/// Position::compute_value() compute the incremental scores for the middle +/// Position::compute_psq_score() computes 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. -Score Position::compute_value() const { +Score Position::compute_psq_score() const { Bitboard b; Score result = SCORE_ZERO; @@ -1459,10 +1423,10 @@ Score Position::compute_value() const { { b = pieces(pt, c); while (b) - result += pst(make_piece(c, pt), pop_1st_bit(&b)); + result += pieceSquareTable[make_piece(c, pt)][pop_1st_bit(&b)]; } - result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2); + result += (sideToMove == WHITE ? Tempo / 2 : -Tempo / 2); return result; } @@ -1542,15 +1506,15 @@ 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 cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++) { Bitboard b = cr; while (b) { - Key k = zobCastle[1 << pop_1st_bit(&b)]; + Key k = zobCastle[1ULL << pop_1st_bit(&b)]; zobCastle[cr] ^= k ? k : rk.rand(); } } @@ -1571,20 +1535,20 @@ void Position::init() { } -/// Position::flip_me() flips position with the white and black sides reversed. This +/// Position::flip() flips position with the white and black sides reversed. This /// is only useful for debugging especially for finding evaluation symmetry bugs. -void Position::flip_me() { +void Position::flip() { // Make a copy of current position before to start changing - const Position pos(*this, threadID); + const Position pos(*this, thisThread); clear(); - threadID = pos.thread(); + thisThread = pos.this_thread(); // Board for (Square s = SQ_A1; s <= SQ_H8; s++) - if (!pos.square_is_empty(s)) + if (!pos.square_empty(s)) put_piece(Piece(pos.piece_on(s) ^ 8), ~s); // Side to move @@ -1613,7 +1577,7 @@ void Position::flip_me() { st->materialKey = compute_material_key(); // Incremental scores - st->value = compute_value(); + st->psqScore = compute_psq_score(); // Material st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); @@ -1693,12 +1657,12 @@ 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))) + if (pieces(WHITE) & pieces(BLACK)) return false; // The union of the white and black pieces must be equal to all // occupied squares - if ((pieces(WHITE) | pieces(BLACK)) != occupied_squares()) + if ((pieces(WHITE) | pieces(BLACK)) != pieces()) return false; // Separate piece type bitboards must have empty intersections @@ -1735,7 +1699,7 @@ bool Position::pos_is_ok(int* failedStep) const { // Incremental eval OK? if (failedStep) (*failedStep)++; - if (debugIncrementalEval && st->value != compute_value()) + if (debugIncrementalEval && st->psqScore != compute_psq_score()) return false; // Non-pawn material OK? @@ -1779,8 +1743,8 @@ bool Position::pos_is_ok(int* failedStep) const { 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; }