X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=ebbf82992273cd44b60d8a6d600b0626d5bdf63f;hp=ad699cc0e93423ef4112093b442da41c0466cb72;hb=1e032ece92da0085000cfdde28cab05029dedce3;hpb=d5e49a3ad44bde500102090e7fe2c19027a73b14 diff --git a/src/position.cpp b/src/position.cpp index ad699cc0..ebbf8299 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 @@ -17,12 +17,11 @@ along with this program. If not, see . */ +#include #include #include #include -#include #include -#include #include "bitcount.h" #include "movegen.h" @@ -34,104 +33,57 @@ #include "tt.h" using std::string; -using std::cout; -using std::endl; static const string PieceToChar(" PNBRQK pnbrqk"); CACHE_LINE_ALIGNMENT -Score pieceSquareTable[PIECE_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(); +static Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; - 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]); +namespace Zobrist { - for (Square s = SQ_A1; s <= SQ_H8; s++) - { - pieceSquareTable[make_piece(WHITE, pt)][ s] = (v + PSQT[pt][s]); - pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]); - } - } + Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; + Key enpassant[FILE_NB]; + Key castling[CASTLING_RIGHT_NB]; + Key side; + Key exclusion; } -} // namespace Zobrist - +Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion;} namespace { -/// next_attacker() is an helper function used by see() to locate the least -/// valuable attacker for the side to move, remove the attacker we just found -/// from the 'occupied' bitboard and scan for new X-ray attacks behind it. +// 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. template FORCE_INLINE -PieceType next_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers, - Bitboard& occupied, Bitboard& attackers) { +PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers, + Bitboard& occupied, Bitboard& attackers) { - if (stmAttackers & bb[Pt]) - { - Bitboard b = stmAttackers & bb[Pt]; - occupied ^= b & ~(b - 1); + Bitboard b = stmAttackers & bb[Pt]; + if (!b) + return min_attacker(bb, to, stmAttackers, occupied, attackers); - if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[BISHOP] | bb[QUEEN]); + occupied ^= b & ~(b - 1); - if (Pt == ROOK || Pt == QUEEN) - attackers |= attacks_bb(to, occupied) & (bb[ROOK] | bb[QUEEN]); + if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN) + attackers |= attacks_bb(to, occupied) & (bb[BISHOP] | bb[QUEEN]); - return (PieceType)Pt; - } - return next_attacker(bb, to, stmAttackers, occupied, attackers); + if (Pt == ROOK || Pt == QUEEN) + attackers |= attacks_bb(to, occupied) & (bb[ROOK] | bb[QUEEN]); + + attackers &= occupied; // After X-ray that may add already processed pieces + return (PieceType)Pt; } template<> FORCE_INLINE -PieceType next_attacker(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) { - return KING; // No need to update bitboards, it is the last cycle +PieceType min_attacker(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) { + return KING; // No need to update bitboards: it is the last cycle } } // namespace @@ -144,7 +96,7 @@ CheckInfo::CheckInfo(const Position& pos) { Color them = ~pos.side_to_move(); ksq = pos.king_square(them); - pinned = pos.pinned_pieces(); + pinned = pos.pinned_pieces(pos.side_to_move()); dcCandidates = pos.discovered_check_candidates(); checkSq[PAWN] = pos.attacks_from(ksq, them); @@ -156,13 +108,60 @@ 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: +/// 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() { + + 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 cf = NO_CASTLING; cf <= ANY_CASTLING; ++cf) + { + Bitboard b = cf; + while (b) + { + Key k = Zobrist::castling[1ULL << pop_lsb(&b)]; + Zobrist::castling[cf] ^= 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 +/// object to not depend on any external data so we detach state pointer from /// the source one. Position& Position::operator=(const Position& pos) { - memcpy(this, &pos, sizeof(Position)); + std::memcpy(this, &pos, sizeof(Position)); startState = *st; st = &startState; nodes = 0; @@ -184,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. @@ -213,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); @@ -229,10 +228,10 @@ 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(Piece(p), sq); - sq++; + put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx))); + ++sq; } } @@ -254,10 +253,10 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { token = char(toupper(token)); if (token == 'K') - for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {} + for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {} else if (token == 'Q') - for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {} + for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {} else if (token >= 'A' && token <= 'H') rsq = File(token - 'A') | relative_rank(c, RANK_1); @@ -265,7 +264,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { else continue; - set_castle_right(c, rsq); + set_castling_right(c, rsq); } // 4. En passant square. Ignore if no pawn capture is possible @@ -285,12 +284,9 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { // handle also common incorrect FEN with fullmove = 0. gamePly = std::max(2 * (gamePly - 1), 0) + int(sideToMove == BLACK); - st->key = compute_key(); - st->pawnKey = compute_pawn_key(); - st->materialKey = compute_material_key(); - st->psqScore = compute_psq_score(); - st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); - st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); + compute_keys(st); + compute_non_pawn_material(st); + st->psq = compute_psq_score(); st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); chess960 = isChess960; thisThread = th; @@ -299,57 +295,53 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { } -/// Position::set_castle_right() is an helper function used to set castling +/// 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_castle_right(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; - CastleRight cr = make_castle_right(c, cs); + CastlingRight cr = (c | cs); - st->castleRights |= cr; - castleRightsMask[kfrom] |= cr; - castleRightsMask[rfrom] |= cr; - castleRookSquare[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++) + for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s) if (s != kfrom && s != rfrom) - castlePath[c][cs] |= s; + castlingPath[cr] |= s; - for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++) + for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s) if (s != kfrom && s != rfrom) - castlePath[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 (Rank rank = RANK_8; rank >= RANK_1; --rank) { - for (File file = FILE_A; file <= FILE_H; file++) + for (File file = FILE_A; file <= FILE_H; ++file) { - Square sq = file | rank; - - if (is_empty(sq)) - { - int emptyCnt = 1; - - for ( ; file < FILE_H && is_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) @@ -359,22 +351,22 @@ const string Position::fen() const { ss << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) - ss << (chess960 ? file_to_char(file_of(castle_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(castle_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(castle_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(castle_rook_square(BLACK, QUEEN_SIDE)), true) : 'q'); + ss << (chess960 ? to_char(file_of(castling_rook_square(BLACK | QUEEN_SIDE)), true) : 'q'); - if (st->castleRights == CASTLES_NONE) + 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(); } @@ -391,63 +383,61 @@ const string Position::pretty(Move move) const { string brd = twoRows + twoRows + twoRows + twoRows + dottedLine; + for (Bitboard b = pieces(); b; ) + { + Square s = pop_lsb(&b); + brd[513 - 68 * rank_of(s) + 4 * file_of(s)] = PieceToChar[piece_on(s)]; + } + std::ostringstream ss; if (move) ss << "\nMove: " << (sideToMove == BLACK ? ".." : "") << move_to_san(*const_cast(this), move); - for (Square sq = SQ_A1; sq <= SQ_H8; sq++) - if (piece_on(sq) != NO_PIECE) - brd[513 - 68*rank_of(sq) + 4*file_of(sq)] = PieceToChar[piece_on(sq)]; - ss << brd << "\nFen: " << fen() << "\nKey: " << std::hex << std::uppercase << 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 ml(*this); !ml.end(); ++ml) - ss << move_to_san(*const_cast(this), ml.move()) << " "; + for (MoveList it(*this); *it; ++it) + ss << move_to_san(*const_cast(this), *it) << " "; return ss.str(); } -/// Position:hidden_checkers<>() returns a bitboard of all pinned (against the -/// king) pieces for the given color. Or, when template parameter FindPinned is -/// false, the function return the pieces of the given color candidate for a -/// discovery check against the enemy king. -template -Bitboard Position::hidden_checkers() const { +/// 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::check_blockers(Color c, Color kingColor) const { - // Pinned pieces protect our king, dicovery checks attack the enemy king - Bitboard b, result = 0; - Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove); - Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove); + Bitboard b, pinners, result = 0; + Square ksq = king_square(kingColor); - // Pinners are sliders, that give check when candidate pinned is removed - pinners &= (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq]) - | (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq]); + // 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(~kingColor); while (pinners) { b = between_bb(ksq, pop_lsb(&pinners)) & pieces(); - if (b && !more_than_one(b) && (b & pieces(sideToMove))) - result |= b; + if (!more_than_one(b)) + result |= b & pieces(c); } return result; } -// Explicit template instantiations -template Bitboard Position::hidden_checkers() const; -template Bitboard Position::hidden_checkers() const; - /// 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 { @@ -460,34 +450,17 @@ Bitboard Position::attackers_to(Square s, Bitboard occ) const { } -/// Position::attacks_from() computes a bitboard of all attacks of a given piece -/// put in a given square. Slider attacks use occ bitboard as occupancy. - -Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) { - - assert(is_ok(s)); - - switch (type_of(p)) - { - case BISHOP: return attacks_bb(s, occ); - case ROOK : return attacks_bb(s, occ); - case QUEEN : return attacks_bb(s, occ) | attacks_bb(s, occ); - default : return StepAttacksBB[p][s]; - } -} - +/// Position::legal() tests whether a pseudo-legal move is legal -/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal - -bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { +bool Position::legal(Move m, Bitboard pinned) const { assert(is_ok(m)); - assert(pinned == pinned_pieces()); + assert(pinned == pinned_pieces(sideToMove)); Color us = sideToMove; Square from = from_sq(m); - assert(color_of(piece_moved(m)) == us); + assert(color_of(moved_piece(m)) == us); assert(piece_on(king_square(us)) == make_piece(us, KING)); // En passant captures are a tricky special case. Because they are rather @@ -502,7 +475,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { Bitboard b = (pieces() ^ from ^ capsq) | to; assert(to == ep_square()); - assert(piece_moved(m) == make_piece(us, PAWN)); + assert(moved_piece(m) == make_piece(us, PAWN)); assert(piece_on(capsq) == make_piece(them, PAWN)); assert(piece_on(to) == NO_PIECE); @@ -514,26 +487,26 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const { // square is attacked by the opponent. Castling moves are checked // for legality during move generation. if (type_of(piece_on(from)) == KING) - return type_of(m) == CASTLE || !(attackers_to(to_sq(m)) & pieces(~us)); + return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us)); // A non-king move is legal if and only if it is not pinned or it // is moving along the ray towards or away from the king. return !pinned || !(pinned & from) - || squares_aligned(from, to_sq(m), king_square(us)); + || aligned(from, to_sq(m), king_square(us)); } -/// Position::is_pseudo_legal() takes a random move and tests whether the move -/// is pseudo legal. It is used to validate moves from TT that can be corrupted +/// Position::pseudo_legal() takes a random move and tests whether the move is +/// pseudo legal. It is used to validate moves from TT that can be corrupted /// due to SMP concurrent access or hash position key aliasing. -bool Position::is_pseudo_legal(const Move m) const { +bool Position::pseudo_legal(const Move m) const { Color us = sideToMove; Square from = from_sq(m); Square to = to_sq(m); - Piece pc = piece_moved(m); + Piece pc = moved_piece(m); // Use a slower but simpler function for uncommon cases if (type_of(m) != NORMAL) @@ -543,83 +516,39 @@ bool Position::is_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; // The destination square cannot be occupied by a friendly piece - if (piece_on(to) != NO_PIECE && color_of(piece_on(to)) == us) + if (pieces(us) & to) return false; // 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) - 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) + // cannot be on the 8th/1st rank. + if (rank_of(to) == relative_rank(us, RANK_8)) 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 (!is_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 - || !is_empty(to) - || !is_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 - || !is_empty(to) - || !is_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) @@ -632,8 +561,8 @@ bool Position::is_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; } @@ -642,45 +571,38 @@ bool Position::is_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::move_gives_check(Move m, const CheckInfo& ci) const { +bool Position::gives_check(Move m, const CheckInfo& ci) const { assert(is_ok(m)); assert(ci.dcCandidates == discovered_check_candidates()); - assert(color_of(piece_moved(m)) == sideToMove); + assert(color_of(moved_piece(m)) == sideToMove); Square from = from_sq(m); 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; - // Discovery check ? - if (ci.dcCandidates && (ci.dcCandidates & from)) - { - // For pawn and king moves we need to verify also direction - if ( (pt != PAWN && pt != KING) - || !squares_aligned(from, to, king_square(~sideToMove))) - return true; - } - - // Can we skip the ugly special cases ? - if (type_of(m) == NORMAL) - return false; - - Color us = sideToMove; - Square ksq = king_square(~us); + // Is there a discovered check? + if ( unlikely(ci.dcCandidates) + && (ci.dcCandidates & from) + && !aligned(from, to, ci.ksq)) + return true; switch (type_of(m)) { + case NORMAL: + return false; + case PROMOTION: - return attacks_from(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: @@ -688,18 +610,18 @@ bool Position::move_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 CASTLE: + case CASTLING: { 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; + Square rfrom = to; // Castling is encoded as 'King captures the rook' + Square kto = relative_square(sideToMove, rfrom > kfrom ? SQ_G1 : SQ_C1); + Square rto = relative_square(sideToMove, rfrom > kfrom ? SQ_F1 : SQ_D1); - return attacks_bb(rto, b) & ksq; + return (PseudoAttacks[ROOK][rto] & ci.ksq) + && (attacks_bb(rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & ci.ksq); } default: assert(false); @@ -715,7 +637,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const { void Position::do_move(Move m, StateInfo& newSt) { CheckInfo ci(*this); - do_move(m, newSt, ci, move_gives_check(m, ci)); + do_move(m, newSt, ci, gives_check(m, ci)); } void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) { @@ -723,13 +645,13 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(is_ok(m)); assert(&newSt != st); - nodes++; + ++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. - memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t)); + // 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; st = &newSt; @@ -737,47 +659,47 @@ 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++; - st->pliesFromNull++; + ++gamePly; + ++st->rule50; + ++st->pliesFromNull; Color us = sideToMove; Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); - Piece piece = piece_on(from); - PieceType pt = type_of(piece); - PieceType capture = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); + Piece pc = piece_on(from); + PieceType pt = type_of(pc); + PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); - assert(color_of(piece) == us); - assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLE); - assert(capture != KING); + assert(color_of(pc) == us); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING); + assert(captured != KING); - if (type_of(m) == CASTLE) + if (type_of(m) == CASTLING) { - 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" + Square rfrom = to; // Castling is encoded as "king captures friendly rook" Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); to = relative_square(us, kingSide ? SQ_G1 : SQ_C1); - capture = NO_PIECE_TYPE; + captured = NO_PIECE_TYPE; - do_castle(from, to, rfrom, rto); + do_castling(from, to, rfrom, rto); - st->psqScore += psq_delta(make_piece(us, ROOK), rfrom, rto); + st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom]; k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto]; } - if (capture) + if (captured) { Square capsq = to; // If the captured piece is a pawn, update pawn hash key, otherwise // update non-pawn material. - if (capture == PAWN) + if (captured == PAWN) { if (type_of(m) == ENPASSANT) { @@ -795,32 +717,18 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->pawnKey ^= Zobrist::psq[them][PAWN][capsq]; } else - st->npMaterial[them] -= PieceValue[MG][capture]; - - // Remove the captured piece - byTypeBB[ALL_PIECES] ^= capsq; - byTypeBB[capture] ^= capsq; - byColorBB[them] ^= capsq; - - // Update piece list, move the last piece at index[capsq] position and - // shrink the list. - // - // WARNING: This is a not reversible operation. When we will reinsert the - // captured piece in undo_move() we will put it at the end of the list and - // not in its original place, it means index[] and pieceList[] are not - // guaranteed to be invariant to a do_move() + undo_move() sequence. - Square lastSquare = pieceList[them][capture][--pieceCount[them][capture]]; - index[lastSquare] = index[capsq]; - pieceList[them][capture][index[lastSquare]] = lastSquare; - pieceList[them][capture][pieceCount[them][capture]] = SQ_NONE; + st->npMaterial[them] -= PieceValue[MG][captured]; + + // Update board and piece lists + remove_piece(capsq, them, captured); // Update material hash key and prefetch access to materialTable - k ^= Zobrist::psq[them][capture][capsq]; - st->materialKey ^= Zobrist::psq[them][capture][pieceCount[them][capture]]; + k ^= Zobrist::psq[them][captured][capsq]; + st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]]; prefetch((char*)thisThread->materialTable[st->materialKey]); // Update incremental scores - st->psqScore -= pieceSquareTable[make_piece(them, capture)][capsq]; + st->psq -= psq[them][captured][capsq]; // Reset rule 50 counter st->rule50 = 0; @@ -836,38 +744,25 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->epSquare = SQ_NONE; } - // Update castle rights if needed - if (st->castleRights && (castleRightsMask[from] | castleRightsMask[to])) + // Update castling rights if needed + if (st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to])) { - int cr = castleRightsMask[from] | castleRightsMask[to]; - k ^= Zobrist::castle[st->castleRights & cr]; - st->castleRights &= ~cr; + 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 prefetch((char*)TT.first_entry(k)); - // Move the piece. The tricky Chess960 castle is handled earlier - if (type_of(m) != CASTLE) - { - Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; - byTypeBB[ALL_PIECES] ^= from_to_bb; - byTypeBB[pt] ^= from_to_bb; - byColorBB[us] ^= from_to_bb; - - board[from] = NO_PIECE; - board[to] = piece; - - // Update piece lists, index[from] is not updated and becomes stale. This - // works as long as index[] is accessed just by known occupied squares. - index[to] = index[from]; - pieceList[us][pt][index[to]] = to; - } + // Move the piece. The tricky Chess960 castling is handled earlier + if (type_of(m) != CASTLING) + move_piece(from, to, us, pt); // 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))) { @@ -882,29 +777,17 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(relative_rank(us, to) == RANK_8); assert(promotion >= KNIGHT && promotion <= QUEEN); - // Replace the pawn with the promoted piece - byTypeBB[PAWN] ^= to; - byTypeBB[promotion] |= to; - board[to] = make_piece(us, promotion); - - // Update piece lists, move the last pawn at index[to] position - // and shrink the list. Add a new promotion piece to the list. - Square lastSquare = pieceList[us][PAWN][--pieceCount[us][PAWN]]; - index[lastSquare] = index[to]; - pieceList[us][PAWN][index[lastSquare]] = lastSquare; - pieceList[us][PAWN][pieceCount[us][PAWN]] = SQ_NONE; - index[to] = pieceCount[us][promotion]; - pieceList[us][promotion][index[to]] = to; + remove_piece(to, us, PAWN); + put_piece(to, us, promotion); // Update hash keys k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to]; st->pawnKey ^= Zobrist::psq[us][PAWN][to]; - st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]++] + st->materialKey ^= Zobrist::psq[us][promotion][pieceCount[us][promotion]-1] ^ 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]; @@ -919,15 +802,15 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI } // Update incremental scores - st->psqScore += psq_delta(piece, from, to); + st->psq += psq[us][pt][to] - psq[us][pt][from]; // Set capture piece - st->capturedType = capture; + st->capturedType = captured; // 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) @@ -940,7 +823,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) @@ -972,10 +855,10 @@ void Position::undo_move(Move m) { Square from = from_sq(m); Square to = to_sq(m); PieceType pt = type_of(piece_on(to)); - PieceType capture = st->capturedType; + PieceType captured = st->capturedType; - assert(is_empty(from) || type_of(m) == CASTLE); - assert(capture != KING); + assert(empty(from) || type_of(m) == CASTLING); + assert(captured != KING); if (type_of(m) == PROMOTION) { @@ -985,51 +868,25 @@ void Position::undo_move(Move m) { assert(relative_rank(us, to) == RANK_8); assert(promotion >= KNIGHT && promotion <= QUEEN); - // Replace the promoted piece with the pawn - byTypeBB[promotion] ^= to; - byTypeBB[PAWN] |= to; - board[to] = make_piece(us, PAWN); - - // Update piece lists, move the last promoted piece at index[to] position - // and shrink the list. Add a new pawn to the list. - Square lastSquare = pieceList[us][promotion][--pieceCount[us][promotion]]; - index[lastSquare] = index[to]; - pieceList[us][promotion][index[lastSquare]] = lastSquare; - pieceList[us][promotion][pieceCount[us][promotion]] = SQ_NONE; - index[to] = pieceCount[us][PAWN]++; - pieceList[us][PAWN][index[to]] = to; - + remove_piece(to, us, promotion); + put_piece(to, us, PAWN); pt = PAWN; } - if (type_of(m) == CASTLE) + if (type_of(m) == CASTLING) { bool kingSide = to > from; - Square rfrom = to; // Castle is encoded as "king captures friendly rook" + Square rfrom = to; // Castling is encoded as "king captures friendly rook" Square rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); to = relative_square(us, kingSide ? SQ_G1 : SQ_C1); - capture = NO_PIECE_TYPE; + captured = NO_PIECE_TYPE; pt = KING; - do_castle(to, from, rto, rfrom); + do_castling(to, from, rto, rfrom); } else - { - // Put the piece back at the source square - Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; - byTypeBB[ALL_PIECES] ^= from_to_bb; - byTypeBB[pt] ^= from_to_bb; - byColorBB[us] ^= from_to_bb; - - board[to] = NO_PIECE; - board[from] = make_piece(us, pt); - - // Update piece lists, index[to] is not updated and becomes stale. This - // works as long as index[] is accessed just by known occupied squares. - index[from] = index[to]; - pieceList[us][pt][index[from]] = from; - } + move_piece(to, from, us, pt); // Put the piece back at the source square - if (capture) + if (captured) { Square capsq = to; @@ -1043,50 +900,28 @@ void Position::undo_move(Move m) { assert(piece_on(capsq) == NO_PIECE); } - // Restore the captured piece - byTypeBB[ALL_PIECES] |= capsq; - byTypeBB[capture] |= capsq; - byColorBB[them] |= capsq; - - board[capsq] = make_piece(them, capture); - - // Update piece list, add a new captured piece in capsq square - index[capsq] = pieceCount[them][capture]++; - pieceList[them][capture][index[capsq]] = capsq; + put_piece(capsq, them, captured); // Restore the captured piece } // Finally point our state pointer back to the previous state st = st->previous; - gamePly--; + --gamePly; assert(pos_is_ok()); } -/// Position::do_castle() is a helper used to do/undo a castling move. This +/// Position::do_castling() is a helper used to do/undo a castling move. This /// is a bit tricky, especially in Chess960. -void Position::do_castle(Square kfrom, Square kto, Square rfrom, Square rto) { +void Position::do_castling(Square kfrom, Square kto, Square rfrom, Square rto) { - Color us = sideToMove; - Bitboard k_from_to_bb = SquareBB[kfrom] ^ SquareBB[kto]; - Bitboard r_from_to_bb = SquareBB[rfrom] ^ SquareBB[rto]; - byTypeBB[KING] ^= k_from_to_bb; - byTypeBB[ROOK] ^= r_from_to_bb; - byTypeBB[ALL_PIECES] ^= k_from_to_bb ^ r_from_to_bb; - byColorBB[us] ^= k_from_to_bb ^ r_from_to_bb; - - // Could be from == to, so first set NO_PIECE then KING and ROOK - board[kfrom] = board[rfrom] = NO_PIECE; - board[kto] = make_piece(us, KING); - board[rto] = make_piece(us, ROOK); - - // Could be kfrom == rto, so use a 'tmp' variable - int tmp = index[kfrom]; - index[rto] = index[rfrom]; - index[kto] = tmp; - pieceList[us][KING][index[kto]] = kto; - pieceList[us][ROOK][index[rto]] = rto; + // Remove both pieces first since squares could overlap in Chess960 + remove_piece(kfrom, sideToMove, KING); + remove_piece(rfrom, sideToMove, ROOK); + board[kfrom] = board[rfrom] = NO_PIECE; // Since remove_piece doesn't do it for us + put_piece(kto, sideToMove, KING); + put_piece(rto, sideToMove, ROOK); } @@ -1097,7 +932,7 @@ void Position::do_null_move(StateInfo& newSt) { assert(!checkers()); - memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here + std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here newSt.previous = st; st = &newSt; @@ -1111,7 +946,7 @@ void Position::do_null_move(StateInfo& newSt) { st->key ^= Zobrist::side; prefetch((char*)TT.first_entry(st->key)); - st->rule50++; + ++st->rule50; st->pliesFromNull = 0; sideToMove = ~sideToMove; @@ -1129,29 +964,27 @@ 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. There are three versions of -/// this function: One which takes a destination square as input, one takes a -/// move, and one which takes a 'from' and a 'to' square. The function does -/// not yet understand promotions captures. +/// 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)); // 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 (PieceValue[MG][piece_on(to_sq(m))] >= PieceValue[MG][piece_moved(m)]) - return 1; + if (PieceValue[MG][moved_piece(m)] <= PieceValue[MG][piece_on(to_sq(m))]) + return VALUE_KNOWN_WIN; return see(m); } -int Position::see(Move m) 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; @@ -1159,36 +992,31 @@ int Position::see(Move m) const { from = from_sq(m); to = to_sq(m); - captured = type_of(piece_on(to)); + swapList[0] = PieceValue[MG][piece_on(to)]; + stm = color_of(piece_on(from)); occupied = pieces() ^ from; - // Handle en passant moves + // Castling moves are implemented as king capturing the rook so cannot be + // 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 VALUE_ZERO; + if (type_of(m) == ENPASSANT) { - Square capQq = to - pawn_push(sideToMove); - - assert(!captured); - assert(type_of(piece_on(capQq)) == PAWN); - - // Remove the captured pawn - occupied ^= capQq; - captured = PAWN; + occupied ^= to - pawn_push(stm); // Remove the captured pawn + swapList[0] = PieceValue[MG][PAWN]; } - else if (type_of(m) == CASTLE) - // Castle moves are implemented as king capturing the rook so cannot be - // handled correctly. Simply return 0 that is always the correct value - // unless the rook is ends up under attack. - return 0; // Find all attackers to the destination square, with the moving piece // removed, but possibly an X-ray attacker added behind it. - attackers = attackers_to(to, occupied); + attackers = attackers_to(to, occupied) & occupied; // If the opponent has no attackers we are finished - stm = ~color_of(piece_on(from)); + stm = ~stm; stmAttackers = attackers & pieces(stm); if (!stmAttackers) - return PieceValue[MG][captured]; + return swapList[0]; // The destination square is defended, which makes things rather more // difficult to compute. We proceed by building up a "swap list" containing @@ -1196,7 +1024,6 @@ int Position::see(Move m) const { // destination square, where the sides alternately capture, and always // capture with the least valuable piece. After each capture, we look for // new X-ray attacks from behind the capturing piece. - swapList[0] = PieceValue[MG][captured]; captured = type_of(piece_on(from)); do { @@ -1204,30 +1031,29 @@ int Position::see(Move m) const { // Add the new entry to the swap list swapList[slIndex] = -swapList[slIndex - 1] + PieceValue[MG][captured]; - slIndex++; - // Locate and remove from 'occupied' the next least valuable attacker - captured = next_attacker(byTypeBB, to, stmAttackers, occupied, attackers); - - attackers &= occupied; // Remove the just found attacker - stm = ~stm; - stmAttackers = attackers & pieces(stm); + // Locate and remove the next least valuable attacker + captured = min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); + // Stop before processing a king capture if (captured == KING) { - // Stop before processing a king capture - if (stmAttackers) - swapList[slIndex++] = QueenValueMg * 16; + if (stmAttackers == attackers) + ++slIndex; break; } + stm = ~stm; + stmAttackers = attackers & pieces(stm); + ++slIndex; + } 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. while (--slIndex) - swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]); + swapList[slIndex - 1] = std::min(-swapList[slIndex], swapList[slIndex - 1]); return swapList[0]; } @@ -1238,102 +1064,71 @@ int Position::see(Move m) const { void Position::clear() { - memset(this, 0, sizeof(Position)); + std::memset(this, 0, sizeof(Position)); startState.epSquare = SQ_NONE; st = &startState; - 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 (int i = 0; i < PIECE_TYPE_NB; ++i) + for (int j = 0; j < 16; ++j) + pieceList[WHITE][i][j] = pieceList[BLACK][i][j] = SQ_NONE; } -/// Position::put_piece() puts a piece on the given square of the board, -/// updating the board array, pieces list, bitboards, and piece counts. +/// Position::compute_keys() computes the hash keys of the position, pawns and +/// material configuration. The hash keys are usually updated incrementally as +/// moves are made and unmade. The function is only used when a new position is +/// set up, and to verify the correctness of the keys when running in debug mode. -void Position::put_piece(Piece p, Square s) { +void Position::compute_keys(StateInfo* si) const { - Color c = color_of(p); - PieceType pt = type_of(p); - - board[s] = p; - index[s] = pieceCount[c][pt]++; - pieceList[c][pt][index[s]] = s; - - byTypeBB[ALL_PIECES] |= s; - byTypeBB[pt] |= s; - byColorBB[c] |= s; -} - - -/// Position::compute_key() computes the hash key of the position. The hash -/// 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::castle[st->castleRights]; + si->key = si->pawnKey = si->materialKey = 0; for (Bitboard b = pieces(); b; ) { Square s = pop_lsb(&b); - k ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s]; + si->key ^= Zobrist::psq[color_of(piece_on(s))][type_of(piece_on(s))][s]; } if (ep_square() != SQ_NONE) - k ^= Zobrist::enpassant[file_of(ep_square())]; + si->key ^= Zobrist::enpassant[file_of(ep_square())]; if (sideToMove == BLACK) - k ^= Zobrist::side; - - return k; -} - - -/// 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 -/// up, and to verify the correctness of the pawn hash key when running in -/// debug mode. - -Key Position::compute_pawn_key() const { + si->key ^= Zobrist::side; - Key k = 0; + si->key ^= Zobrist::castling[st->castlingRights]; for (Bitboard b = pieces(PAWN); b; ) { Square s = pop_lsb(&b); - k ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s]; + si->pawnKey ^= Zobrist::psq[color_of(piece_on(s))][PAWN][s]; } - return k; + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) + for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt) + si->materialKey ^= Zobrist::psq[c][pt][cnt]; } -/// 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 -/// up, and to verify the correctness of the material hash key when running in -/// debug mode. +/// Position::compute_non_pawn_material() computes the total non-pawn middlegame +/// material value for each side. Material values are updated incrementally during +/// the search. This function is only used when initializing a new Position object. -Key Position::compute_material_key() const { +void Position::compute_non_pawn_material(StateInfo* si) const { - Key k = 0; + si->npMaterial[WHITE] = si->npMaterial[BLACK] = VALUE_ZERO; - for (Color c = WHITE; c <= BLACK; c++) - for (PieceType pt = PAWN; pt <= QUEEN; pt++) - for (int cnt = 0; cnt < piece_count(c, pt); cnt++) - k ^= Zobrist::psq[c][pt][cnt]; - - return k; + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt) + si->npMaterial[c] += pieceCount[c][pt] * PieceValue[MG][pt]; } -/// 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 { Score score = SCORE_ZERO; @@ -1341,118 +1136,78 @@ 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; } -/// 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. - -Value Position::compute_non_pawn_material(Color c) const { +/// Position::is_draw() tests whether the position is drawn by material, 50 moves +/// rule or repetition. It does not detect stalemates. - Value value = VALUE_ZERO; - - for (PieceType pt = KNIGHT; pt <= QUEEN; pt++) - value += piece_count(c, pt) * PieceValue[MG][pt]; - - return value; -} - - -/// 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. -template 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; - // Draw by repetition? - if (!SkipRepetition) + StateInfo* stp = st; + for (int i = 2, e = std::min(st->rule50, st->pliesFromNull); i <= e; i += 2) { - int i = 4, e = std::min(st->rule50, st->pliesFromNull); - - if (i <= e) - { - StateInfo* stp = st->previous->previous; - - do { - stp = stp->previous->previous; + stp = stp->previous->previous; - if (stp->key == st->key) - return true; - - i += 2; - - } while (i <= e); - } + if (stp->key == st->key) + return true; // Draw at first repetition } return false; } -// Explicit template instantiations -template bool Position::is_draw() const; -template 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)); +} void Position::flip() { - const Position pos(*this); + string f, token; + std::stringstream ss(fen()); - clear(); + for (Rank rank = RANK_8; rank >= RANK_1; --rank) // Piece placement + { + std::getline(ss, token, rank > RANK_1 ? '/' : ' '); + f.insert(0, token + (f.empty() ? " " : "/")); + } - sideToMove = ~pos.side_to_move(); - thisThread = pos.this_thread(); - nodes = pos.nodes_searched(); - chess960 = pos.is_chess960(); - gamePly = pos.game_ply(); + ss >> token; // Active color + f += (token == "w" ? "B " : "W "); // Will be lowercased later - for (Square s = SQ_A1; s <= SQ_H8; s++) - if (!pos.is_empty(s)) - put_piece(Piece(pos.piece_on(s) ^ 8), ~s); + ss >> token; // Castling availability + f += token + " "; - if (pos.can_castle(WHITE_OO)) - set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, KING_SIDE)); - if (pos.can_castle(WHITE_OOO)) - set_castle_right(BLACK, ~pos.castle_rook_square(WHITE, QUEEN_SIDE)); - if (pos.can_castle(BLACK_OO)) - set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, KING_SIDE)); - if (pos.can_castle(BLACK_OOO)) - set_castle_right(WHITE, ~pos.castle_rook_square(BLACK, QUEEN_SIDE)); + std::transform(f.begin(), f.end(), f.begin(), toggle_case); - if (pos.st->epSquare != SQ_NONE) - st->epSquare = ~pos.st->epSquare; + ss >> token; // En passant square + f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3")); - st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); + std::getline(ss, token); // Half and full moves + f += token; - st->key = compute_key(); - st->pawnKey = compute_pawn_key(); - st->materialKey = compute_material_key(); - st->psqScore = compute_psq_score(); - st->npMaterial[WHITE] = compute_non_pawn_material(WHITE); - st->npMaterial[BLACK] = compute_non_pawn_material(BLACK); + set(f, is_chess960(), this_thread()); assert(pos_is_ok()); } -/// 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 { @@ -1462,22 +1217,18 @@ bool Position::pos_is_ok(int* failedStep) const { // What features of the position should be verified? const bool all = false; - const bool debugBitboards = all || false; - const bool debugKingCount = all || false; - const bool debugKingCapture = all || false; - const bool debugCheckerCount = all || false; - const bool debugKey = all || false; - const bool debugMaterialKey = all || false; - const bool debugPawnKey = all || false; - const bool debugIncrementalEval = all || false; - const bool debugNonPawnMaterial = all || false; - const bool debugPieceCounts = all || false; - const bool debugPieceList = all || false; - const bool debugCastleSquares = all || false; - - *step = 1; - - if (sideToMove != WHITE && sideToMove != BLACK) + const bool testBitboards = all || false; + const bool testKingCount = all || false; + const bool testKingCapture = all || false; + const bool testCheckerCount = all || false; + const bool testKeys = all || false; + const bool testIncrementalEval = all || false; + const bool testNonPawnMaterial = all || false; + const bool testPieceCounts = all || false; + const bool testPieceList = all || false; + const bool testCastlingSquares = all || false; + + if (*step = 1, sideToMove != WHITE && sideToMove != BLACK) return false; if ((*step)++, piece_on(king_square(WHITE)) != W_KING) @@ -1486,26 +1237,19 @@ bool Position::pos_is_ok(int* failedStep) const { if ((*step)++, piece_on(king_square(BLACK)) != B_KING) return false; - if ((*step)++, debugKingCount) - { - int kingCount[COLOR_NB] = {}; - - for (Square s = SQ_A1; s <= SQ_H8; s++) - if (type_of(piece_on(s)) == KING) - kingCount[color_of(piece_on(s))]++; - - if (kingCount[0] != 1 || kingCount[1] != 1) + if ((*step)++, testKingCount) + if ( std::count(board, board + SQUARE_NB, W_KING) != 1 + || std::count(board, board + SQUARE_NB, B_KING) != 1) return false; - } - if ((*step)++, debugKingCapture) + if ((*step)++, testKingCapture) if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove)) return false; - if ((*step)++, debugCheckerCount && popcount(st->checkersBB) > 2) + if ((*step)++, testCheckerCount && popcount(st->checkersBB) > 2) return false; - if ((*step)++, debugBitboards) + if ((*step)++, testBitboards) { // The intersection of the white and black pieces must be empty if (pieces(WHITE) & pieces(BLACK)) @@ -1517,8 +1261,8 @@ bool Position::pos_is_ok(int* failedStep) const { return false; // Separate piece type bitboards must have empty intersections - for (PieceType p1 = PAWN; p1 <= KING; p1++) - for (PieceType p2 = PAWN; p2 <= KING; p2++) + for (PieceType p1 = PAWN; p1 <= KING; ++p1) + for (PieceType p2 = PAWN; p2 <= KING; ++p2) if (p1 != p2 && (pieces(p1) & pieces(p2))) return false; } @@ -1526,57 +1270,50 @@ bool Position::pos_is_ok(int* failedStep) const { if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6) return false; - if ((*step)++, debugKey && st->key != compute_key()) - return false; - - if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key()) - return false; - - if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key()) - return false; - - if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score()) - return false; + if ((*step)++, testKeys) + { + StateInfo si; + compute_keys(&si); + if (st->key != si.key || st->pawnKey != si.pawnKey || st->materialKey != si.materialKey) + return false; + } - if ((*step)++, debugNonPawnMaterial) + if ((*step)++, testNonPawnMaterial) { - if ( st->npMaterial[WHITE] != compute_non_pawn_material(WHITE) - || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK)) + StateInfo si; + compute_non_pawn_material(&si); + if ( st->npMaterial[WHITE] != si.npMaterial[WHITE] + || st->npMaterial[BLACK] != si.npMaterial[BLACK]) return false; } - if ((*step)++, debugPieceCounts) - for (Color c = WHITE; c <= BLACK; c++) - for (PieceType pt = PAWN; pt <= KING; pt++) + if ((*step)++, testIncrementalEval && st->psq != compute_psq_score()) + return false; + + if ((*step)++, testPieceCounts) + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) if (pieceCount[c][pt] != popcount(pieces(c, pt))) return false; - if ((*step)++, debugPieceList) - for (Color c = WHITE; c <= BLACK; c++) - for (PieceType pt = PAWN; pt <= KING; pt++) - for (int i = 0; i < pieceCount[c][pt]; i++) - { - if (piece_on(piece_list(c, pt)[i]) != make_piece(c, pt)) + if ((*step)++, testPieceList) + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) + for (int i = 0; i < pieceCount[c][pt]; ++i) + if ( board[pieceList[c][pt][i]] != make_piece(c, pt) + || index[pieceList[c][pt][i]] != i) return false; - if (index[piece_list(c, pt)[i]] != i) - return false; - } - - if ((*step)++, debugCastleSquares) - for (Color c = WHITE; c <= BLACK; c++) + if ((*step)++, testCastlingSquares) + for (Color c = WHITE; c <= BLACK; ++c) for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) { - CastleRight cr = make_castle_right(c, s); - - if (!can_castle(cr)) + if (!can_castle(c | s)) continue; - if ((castleRightsMask[king_square(c)] & cr) != cr) - return false; - - if ( piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK) - || castleRightsMask[castleRookSquare[c][s]] != cr) + 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; }