X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=3fc568eebf93a0e674d748ceee4095c8b92b7551;hp=f6b8d0ce0633675040893eb2f4a29aebfddfccb9;hb=d2a8ba329940655e4683a67a2528a92717700732;hpb=f99cb3dc27719021e126690b7fd5aa5f43663ed8 diff --git a/src/position.cpp b/src/position.cpp index f6b8d0ce..3fc568ee 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -38,16 +38,17 @@ static const string PieceToChar(" PNBRQK pnbrqk"); CACHE_LINE_ALIGNMENT -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 } }; +static Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; + namespace Zobrist { Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Key enpassant[FILE_NB]; - Key castling[CASTLING_FLAG_NB]; + Key castling[CASTLING_RIGHT_NB]; Key side; Key exclusion; } @@ -56,7 +57,7 @@ Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion;} namespace { -// min_attacker() is an helper function used by see() to locate the least +// min_attacker() is a helper function used by see() to locate the least // valuable attacker for the side to move, remove the attacker we just found // from the bitboards and scan for new X-ray attacks behind it. @@ -82,7 +83,7 @@ PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stm template<> FORCE_INLINE PieceType min_attacker(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) { - return KING; // No need to update bitboards, it is the last cycle + return KING; // No need to update bitboards: it is the last cycle } } // namespace @@ -109,9 +110,9 @@ 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. +/// Firstly, the white halves of the tables are copied from PSQT[] tables. +/// Secondly, the black halves of the tables are initialized by flipping and +/// changing the sign of the white scores. void Position::init() { @@ -155,7 +156,7 @@ void Position::init() { /// 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 +/// object to not depend on any external data so we detach state pointer from /// the source one. Position& Position::operator=(const Position& pos) { @@ -182,11 +183,11 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { A FEN string contains six fields separated by a space. The fields are: 1) Piece placement (from white's perspective). Each rank is described, starting - with rank 8 and ending with rank 1; within each rank, the contents of each + with rank 8 and ending with rank 1. Within each rank, the contents of each square are described from file A through file H. Following the Standard Algebraic Notation (SAN), each piece is identified by a single letter taken from the standard English names. White pieces are designated using upper-case - letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are + letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are noted using digits 1 through 8 (the number of blank squares), and "/" separates ranks. @@ -211,7 +212,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { */ char col, row, token; - size_t p; + size_t idx; Square sq = SQ_A8; std::istringstream ss(fenStr); @@ -227,9 +228,9 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { else if (token == '/') sq -= Square(16); - else if ((p = PieceToChar.find(token)) != string::npos) + else if ((idx = PieceToChar.find(token)) != string::npos) { - put_piece(sq, color_of(Piece(p)), type_of(Piece(p))); + put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx))); ++sq; } } @@ -263,7 +264,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { else continue; - set_castling_flag(c, rsq); + set_castling_right(c, rsq); } // 4. En passant square. Ignore if no pawn capture is possible @@ -297,57 +298,53 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { } -/// Position::set_castling_flag() is an helper function used to set castling -/// flags given the corresponding color and the rook starting square. +/// Position::set_castling_right() is a helper function used to set castling +/// rights given the corresponding color and the rook starting square. -void Position::set_castling_flag(Color c, Square rfrom) { +void Position::set_castling_right(Color c, Square rfrom) { Square kfrom = king_square(c); CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; - CastlingFlag cf = make_castling_flag(c, cs); + CastlingRight cr = (c | cs); - st->castlingFlags |= cf; - castlingFlagsMask[kfrom] |= cf; - castlingFlagsMask[rfrom] |= cf; - castlingRookSquare[c][cs] = rfrom; + st->castlingRights |= cr; + castlingRightsMask[kfrom] |= cr; + castlingRightsMask[rfrom] |= cr; + castlingRookSquare[cr] = rfrom; Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1); Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1); for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s) if (s != kfrom && s != rfrom) - castlingPath[c][cs] |= s; + castlingPath[cr] |= s; for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s) if (s != kfrom && s != rfrom) - castlingPath[c][cs] |= s; + castlingPath[cr] |= s; } -/// Position::fen() returns a FEN representation of the position. In case -/// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function. +/// Position::fen() returns a FEN representation of the position. In case of +/// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function. const string Position::fen() const { + int emptyCnt; std::ostringstream ss; for (Rank rank = RANK_8; rank >= RANK_1; --rank) { for (File file = FILE_A; file <= FILE_H; ++file) { - Square sq = file | rank; - - if (empty(sq)) - { - int emptyCnt = 1; - - for ( ; file < FILE_H && empty(++sq); ++file) - ++emptyCnt; + for (emptyCnt = 0; file <= FILE_H && empty(file | rank); ++file) + ++emptyCnt; + if (emptyCnt) ss << emptyCnt; - } - else - ss << PieceToChar[piece_on(sq)]; + + if (file <= FILE_H) + ss << PieceToChar[piece_on(file | rank)]; } if (rank > RANK_1) @@ -357,22 +354,22 @@ const string Position::fen() const { ss << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) - ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, KING_SIDE)), false) : 'K'); + ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE | KING_SIDE)), false) : 'K'); if (can_castle(WHITE_OOO)) - ss << (chess960 ? file_to_char(file_of(castling_rook_square(WHITE, QUEEN_SIDE)), false) : 'Q'); + ss << (chess960 ? to_char(file_of(castling_rook_square(WHITE | QUEEN_SIDE)), false) : 'Q'); if (can_castle(BLACK_OO)) - ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, KING_SIDE)), true) : 'k'); + ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | KING_SIDE)), true) : 'k'); if (can_castle(BLACK_OOO)) - ss << (chess960 ? file_to_char(file_of(castling_rook_square(BLACK, QUEEN_SIDE)), true) : 'q'); + ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | QUEEN_SIDE)), true) : 'q'); - if (st->castlingFlags == NO_CASTLING) + if (!can_castle(WHITE) && !can_castle(BLACK)) ss << '-'; - ss << (ep_square() == SQ_NONE ? " - " : " " + square_to_string(ep_square()) + " ") - << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2; + ss << (ep_square() == SQ_NONE ? " - " : " " + to_string(ep_square()) + " ") + << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2; return ss.str(); } @@ -405,7 +402,7 @@ const string Position::pretty(Move move) const { << std::setfill('0') << std::setw(16) << st->key << "\nCheckers: "; for (Bitboard b = checkers(); b; ) - ss << square_to_string(pop_lsb(&b)) << " "; + ss << to_string(pop_lsb(&b)) << " "; ss << "\nLegal moves: "; for (MoveList it(*this); *it; ++it) @@ -415,31 +412,35 @@ const string Position::pretty(Move move) const { } -/// Position:hidden_checkers() returns a bitboard of all pinned / discovery check -/// pieces, according to the call parameters. Pinned pieces protect our king, -/// discovery check pieces attack the enemy king. +/// Position::check_blockers() returns a bitboard of all the pieces with color +/// 'c' that are blocking check on the king with color 'kingColor'. A piece +/// blocks a check if removing that piece from the board would result in a +/// position where the king is in check. A check blocking piece can be either a +/// pinned or a discovered check piece, according if its color 'c' is the same +/// or the opposite of 'kingColor'. -Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const { +Bitboard Position::check_blockers(Color c, Color kingColor) const { Bitboard b, pinners, result = 0; + Square ksq = king_square(kingColor); - // Pinners are sliders that give check when pinned piece is removed + // Pinners are sliders that give check when a pinned piece is removed pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq]) - | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(c); + | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(~kingColor); while (pinners) { b = between_bb(ksq, pop_lsb(&pinners)) & pieces(); if (!more_than_one(b)) - result |= b & pieces(toMove); + result |= b & pieces(c); } return result; } /// Position::attackers_to() computes a bitboard of all pieces which attack a -/// given square. Slider attacks use occ bitboard as occupancy. +/// given square. Slider attacks use the occ bitboard to indicate occupancy. Bitboard Position::attackers_to(Square s, Bitboard occ) const { @@ -518,7 +519,7 @@ bool Position::pseudo_legal(const Move m) const { 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 + // If the 'from' square is not occupied by a piece belonging to the side to // move, the move is obviously not legal. if (pc == NO_PIECE || color_of(pc) != us) return false; @@ -530,71 +531,27 @@ bool Position::pseudo_legal(const Move m) const { // Handle the special case of a pawn move if (type_of(pc) == PAWN) { - // Move direction must be compatible with pawn color - int direction = to - from; - if ((us == WHITE) != (direction > 0)) - return false; - // We have already handled promotion moves, so destination - // cannot be on the 8/1th rank. - if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1) + // cannot be on the 8th/1st rank. + if (rank_of(to) == relative_rank(us, RANK_8)) return false; - // Proceed according to the square delta between the origin and - // destination squares. - switch (direction) - { - case DELTA_NW: - case DELTA_NE: - case DELTA_SW: - case DELTA_SE: - // Capture. The destination square must be occupied by an enemy - // piece (en passant captures was handled earlier). - if (piece_on(to) == NO_PIECE || color_of(piece_on(to)) != ~us) - return false; - - // From and to files must be one file apart, avoids a7h5 - if (abs(file_of(from) - file_of(to)) != 1) - return false; - break; + if ( !(attacks_from(from, us) & pieces(~us) & to) // Not a capture - case DELTA_N: - case DELTA_S: - // Pawn push. The destination square must be empty. - if (!empty(to)) - return false; - break; - - case DELTA_NN: - // 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 ( rank_of(to) != RANK_4 - || !empty(to) - || !empty(from + DELTA_N)) - return false; - break; - - case DELTA_SS: - // 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 ( rank_of(to) != RANK_5 - || !empty(to) - || !empty(from + DELTA_S)) - return false; - break; + && !((from + pawn_push(us) == to) && empty(to)) // Not a single push - default: + && !( (from + 2 * pawn_push(us) == to) // Not a double push + && (rank_of(from) == relative_rank(us, RANK_2)) + && empty(to) + && empty(to - pawn_push(us)))) return false; - } } else if (!(attacks_from(pc, from) & to)) return false; // Evasions generator already takes care to avoid some kind of illegal moves - // and pl_move_is_legal() relies on this. So we have to take care that the - // same kind of moves are filtered out here. + // and legal() relies on this. We therefore have to take care that the same + // kind of moves are filtered out here. if (checkers()) { if (type_of(pc) != KING) @@ -607,8 +564,8 @@ bool Position::pseudo_legal(const Move m) const { if (!((between_bb(lsb(checkers()), 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. + // In case of king moves under check we have to remove king so as to catch + // invalid moves like b1a1 when opposite queen is on c1. else if (attackers_to(to, pieces() ^ from) & pieces(~us)) return false; } @@ -617,7 +574,7 @@ bool Position::pseudo_legal(const Move m) const { } -/// Position::move_gives_check() tests whether a pseudo-legal move gives a check +/// Position::gives_check() tests whether a pseudo-legal move gives a check bool Position::gives_check(Move m, const CheckInfo& ci) const { @@ -629,30 +586,27 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { Square to = to_sq(m); PieceType pt = type_of(piece_on(from)); - // Direct check ? + // Is there a direct check? if (ci.checkSq[pt] & to) return true; - // Discovered check ? + // Is there a discovered check? if ( unlikely(ci.dcCandidates) && (ci.dcCandidates & from) - && !aligned(from, to, king_square(~sideToMove))) + && !aligned(from, to, ci.ksq)) return true; - // Can we skip the ugly special cases ? + // Can we skip the ugly special cases? if (type_of(m) == NORMAL) return false; - Color us = sideToMove; - Square ksq = king_square(~us); - switch (type_of(m)) { case PROMOTION: - return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq; + return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ci.ksq; - // En passant capture with check ? We have already handled the case - // of direct checks and ordinary discovered check, the only case we + // En passant capture with check? We have already handled the case + // of direct checks and ordinary discovered check, so the only case we // need to handle is the unusual case of a discovered check through // the captured pawn. case ENPASSANT: @@ -660,18 +614,18 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { Square capsq = file_of(to) | rank_of(from); Bitboard b = (pieces() ^ from ^ capsq) | to; - return (attacks_bb< ROOK>(ksq, b) & pieces(us, QUEEN, ROOK)) - | (attacks_bb(ksq, b) & pieces(us, QUEEN, BISHOP)); + return (attacks_bb< ROOK>(ci.ksq, b) & pieces(sideToMove, QUEEN, ROOK)) + | (attacks_bb(ci.ksq, b) & pieces(sideToMove, QUEEN, BISHOP)); } case CASTLING: { Square kfrom = from; Square rfrom = to; // Castling is encoded as 'King captures the rook' - Square kto = relative_square(us, rfrom > kfrom ? SQ_G1 : SQ_C1); - Square rto = relative_square(us, rfrom > kfrom ? SQ_F1 : SQ_D1); + Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1); + Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1); - return (PseudoAttacks[ROOK][rto] & ksq) - && (attacks_bb(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ksq); + return (PseudoAttacks[ROOK][rto] & ci.ksq) + && (attacks_bb(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ci.ksq); } default: assert(false); @@ -698,9 +652,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI ++nodes; Key k = st->key; - // Copy some fields of old state to our new StateInfo object except the ones - // which are going to be recalculated from scratch anyway, then switch our state - // pointer to point to the new, ready to be updated, state. + // Copy some fields of the old state to our new StateInfo object except the + // ones which are going to be recalculated from scratch anyway and then switch + // our state pointer to point to the new (ready to be updated) state. std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t)); newSt.previous = st; @@ -709,7 +663,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Update side to move k ^= Zobrist::side; - // Increment ply counters.In particular rule50 will be later reset it to zero + // Increment ply counters. In particular, rule50 will be reset to zero later on // in case of a capture or a pawn move. ++gamePly; ++st->rule50; @@ -794,12 +748,12 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->epSquare = SQ_NONE; } - // Update castling flags if needed - if (st->castlingFlags && (castlingFlagsMask[from] | castlingFlagsMask[to])) + // Update castling rights if needed + if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to])) { - int cf = castlingFlagsMask[from] | castlingFlagsMask[to]; - k ^= Zobrist::castling[st->castlingFlags & cf]; - st->castlingFlags &= ~cf; + int cr = castlingRightsMask[from] | castlingRightsMask[to]; + k ^= Zobrist::castling[st->castlingRights & cr]; + st->castlingRights &= ~cr; } // Prefetch TT access as soon as we know the new hash key @@ -812,7 +766,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // If the moving piece is a pawn do some special extra work if (pt == PAWN) { - // Set en-passant square, only if moved pawn can be captured + // Set en-passant square if the moved pawn can be captured if ( (int(to) ^ int(from)) == 16 && (attacks_from(from + pawn_push(us), us) & pieces(them, PAWN))) { @@ -860,7 +814,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Update the key with the final value st->key = k; - // Update checkers bitboard, piece must be already moved + // Update checkers bitboard: piece must be already moved st->checkersBB = 0; if (moveIsCheck) @@ -873,7 +827,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI if (ci.checkSq[pt] & to) st->checkersBB |= to; - // Discovery checks + // Discovered checks if (ci.dcCandidates && (ci.dcCandidates & from)) { if (pt != ROOK) @@ -1014,12 +968,9 @@ void Position::undo_null_move() { /// Position::see() is a static exchange evaluator: It tries to estimate the -/// material gain or loss resulting from a move. Parameter 'asymmThreshold' takes -/// tempi into account. If the side who initiated the capturing sequence does the -/// last capture, he loses a tempo and if the result is below 'asymmThreshold' -/// the capturing sequence is considered bad. +/// material gain or loss resulting from a move. -int Position::see_sign(Move m) const { +Value Position::see_sign(Move m) const { assert(is_ok(m)); @@ -1027,16 +978,17 @@ int Position::see_sign(Move m) const { // is not less then capturing one. Note that king moves always return // here because king midgame value is set to 0. if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))]) - return 1; + return VALUE_KNOWN_WIN; return see(m); } -int Position::see(Move m, int asymmThreshold) const { +Value Position::see(Move m) const { Square from, to; Bitboard occupied, attackers, stmAttackers; - int swapList[32], slIndex = 1; + Value swapList[32]; + int slIndex = 1; PieceType captured; Color stm; @@ -1052,7 +1004,7 @@ int Position::see(Move m, int asymmThreshold) const { // handled correctly. Simply return 0 that is always the correct value // unless in the rare case the rook ends up under attack. if (type_of(m) == CASTLING) - return 0; + return VALUE_ZERO; if (type_of(m) == ENPASSANT) { @@ -1083,30 +1035,24 @@ int Position::see(Move m, int asymmThreshold) const { // Add the new entry to the swap list swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured]; - ++slIndex; // Locate and remove the next least valuable attacker captured = min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); - stm = ~stm; - stmAttackers = attackers & pieces(stm); // Stop before processing a king capture - if (captured == KING && stmAttackers) + if (captured == KING) { - swapList[slIndex++] = QueenValueMg * 16; + if (stmAttackers == attackers) + ++slIndex; + break; } - } while (stmAttackers); + stm = ~stm; + stmAttackers = attackers & pieces(stm); + ++slIndex; - // If we are doing asymmetric SEE evaluation and the same side does the first - // and the last capture, he loses a tempo and gain must be at least worth - // 'asymmThreshold', otherwise we replace the score with a very low value, - // before negamaxing. - if (asymmThreshold) - for (int i = 0; i < slIndex; i += 2) - if (swapList[i] < asymmThreshold) - swapList[i] = - QueenValueMg * 16; + } while (stmAttackers); // Having built the swap list, we negamax through it to find the best // achievable score from the point of view of the side to move. @@ -1133,13 +1079,13 @@ void Position::clear() { /// Position::compute_key() computes the hash key of the position. The hash -/// key is usually updated incrementally as moves are made and unmade, the +/// key is usually updated incrementally as moves are made and unmade. The /// compute_key() function is only used when a new position is set up, and /// to verify the correctness of the hash key when running in debug mode. Key Position::compute_key() const { - Key k = Zobrist::castling[st->castlingFlags]; + Key k = Zobrist::castling[st->castlingRights]; for (Bitboard b = pieces(); b; ) { @@ -1158,8 +1104,8 @@ Key Position::compute_key() const { /// Position::compute_pawn_key() computes the hash key of the position. The -/// hash key is usually updated incrementally as moves are made and unmade, -/// the compute_pawn_key() function is only used when a new position is set +/// hash key is usually updated incrementally as moves are made and unmade. +/// The compute_pawn_key() function is only used when a new position is set /// up, and to verify the correctness of the pawn hash key when running in /// debug mode. @@ -1178,8 +1124,8 @@ Key Position::compute_pawn_key() const { /// Position::compute_material_key() computes the hash key of the position. -/// The hash key is usually updated incrementally as moves are made and unmade, -/// the compute_material_key() function is only used when a new position is set +/// The hash key is usually updated incrementally as moves are made and unmade. +/// The compute_material_key() function is only used when a new position is set /// up, and to verify the correctness of the material hash key when running in /// debug mode. @@ -1188,7 +1134,7 @@ Key Position::compute_material_key() const { Key k = 0; for (Color c = WHITE; c <= BLACK; ++c) - for (PieceType pt = PAWN; pt <= QUEEN; ++pt) + for (PieceType pt = PAWN; pt <= KING; ++pt) for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt) k ^= Zobrist::psq[c][pt][cnt]; @@ -1196,9 +1142,9 @@ Key Position::compute_material_key() const { } -/// 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 +/// Position::compute_psq_score() computes the incremental scores for the middlegame +/// 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_psq_score() const { @@ -1216,10 +1162,10 @@ Score Position::compute_psq_score() const { } -/// Position::compute_non_pawn_material() computes the total non-pawn middle -/// game material value for the given side. Material values are updated -/// incrementally during the search, this function is only used while -/// initializing a new Position object. +/// Position::compute_non_pawn_material() computes the total non-pawn middlegame +/// material value for the given side. Material values are updated incrementally +/// during the search. This function is only used when initializing a new Position +/// object. Value Position::compute_non_pawn_material(Color c) const { @@ -1232,35 +1178,25 @@ Value Position::compute_non_pawn_material(Color c) const { } -/// Position::is_draw() tests whether the position is drawn by material, -/// repetition, or the 50 moves rule. It does not detect stalemates, this -/// must be done by the search. +/// Position::is_draw() tests whether the position is drawn by material, 50 moves +/// rule or repetition. It does not detect stalemates. + bool Position::is_draw() const { - // Draw by material? if ( !pieces(PAWN) && (non_pawn_material(WHITE) + non_pawn_material(BLACK) <= BishopValueMg)) return true; - // Draw by the 50 moves rule? if (st->rule50 > 99 && (!checkers() || MoveList(*this).size())) return true; - int i = 4, e = std::min(st->rule50, st->pliesFromNull); - - if (i <= e) + StateInfo* stp = st; + for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2) { - StateInfo* stp = st->previous->previous; + stp = stp->previous->previous; - do { - stp = stp->previous->previous; - - if (stp->key == st->key) - return true; // Draw after first repetition - - i += 2; - - } while (i <= e); + if (stp->key == st->key) + return true; // Draw at first repetition } return false; @@ -1268,7 +1204,7 @@ bool Position::is_draw() const { /// Position::flip() flips position with the white and black sides reversed. This -/// is only useful for debugging especially for finding evaluation symmetry bugs. +/// is only useful for debugging e.g. for finding evaluation symmetry bugs. static char toggle_case(char c) { return char(islower(c) ? toupper(c) : tolower(c)); @@ -1305,7 +1241,7 @@ void Position::flip() { } -/// Position::pos_is_ok() performs some consitency checks for the position object. +/// Position::pos_is_ok() performs some consistency checks for the position object. /// This is meant to be helpful when debugging. bool Position::pos_is_ok(int* failedStep) const { @@ -1414,14 +1350,12 @@ bool Position::pos_is_ok(int* failedStep) const { for (Color c = WHITE; c <= BLACK; ++c) for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) { - CastlingFlag cf = make_castling_flag(c, s); - - if (!can_castle(cf)) + if (!can_castle(c | s)) continue; - if ( (castlingFlagsMask[king_square(c)] & cf) != cf - || piece_on(castlingRookSquare[c][s]) != make_piece(c, ROOK) - || castlingFlagsMask[castlingRookSquare[c][s]] != cf) + if ( (castlingRightsMask[king_square(c)] & (c | s)) != (c | s) + || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) + || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)) return false; }