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.
*/
char col, row, token;
- size_t p;
+ size_t idx;
Square sq = SQ_A8;
std::istringstream ss(fenStr);
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;
}
}
}
-/// Position::set_castling_flag() is an helper function used to set castling
+/// Position::set_castling_flag() is a helper function used to set castling
/// flags given the corresponding color and the rook starting square.
void Position::set_castling_flag(Color c, Square rfrom) {
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)
if (can_castle(BLACK_OOO))
ss << (chess960 ? file_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;
+ << st->rule50 << " " << 1 + (gamePly - int(sideToMove == BLACK)) / 2;
return ss.str();
}
}
-/// Position:hidden_checkers() returns a bitboard of all pinned / discovery check
+/// Position:hidden_checkers() returns a bitboard of all pinned / discovered check
/// pieces, according to the call parameters. Pinned pieces protect our king and
-/// discovery check pieces attack the enemy king.
+/// discovered check pieces attack the enemy king.
-Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
+Bitboard Position::hidden_checkers(Color c, Color kingColor) const {
Bitboard b, pinners, result = 0;
+ Square ksq = king_square(kingColor);
// 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;
}
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;
return false;
// We have already handled promotion moves, so destination
- // cannot be on the 8/1th rank.
+ // cannot be on the 8th/1st rank.
if (rank_of(to) == RANK_8 || rank_of(to) == RANK_1)
return false;
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;
}
Square to = to_sq(m);
PieceType pt = type_of(piece_on(from));
- // Is there a direct check ?
+ // Is there a direct check?
if (ci.checkSq[pt] & to)
return true;
- // Is there a discovered check ?
+ // Is there a discovered check?
if ( unlikely(ci.dcCandidates)
&& (ci.dcCandidates & from)
&& !aligned(from, to, king_square(~sideToMove)))
return true;
- // Can we skip the ugly special cases ?
+ // Can we skip the ugly special cases?
if (type_of(m) == NORMAL)
return false;
case PROMOTION:
return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
- // En passant capture with check ? We have already handled the case
+ // 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.
++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;
// Update side to move
k ^= Zobrist::side;
- // Increment ply counters.In particular rule50 will be reset to zero later on
+ // 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;
if (ci.checkSq[pt] & to)
st->checkersBB |= to;
- // Discovery checks
+ // Discovered checks
if (ci.dcCandidates && (ci.dcCandidates & from))
{
if (pt != ROOK)
} while (stmAttackers);
// 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
+ // and the last capture, it 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)
}
-/// 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 {
}
-/// 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 when
-/// 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 {
}
-/// 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<LEGAL>(*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;
-
- do {
- stp = stp->previous->previous;
-
- if (stp->key == st->key)
- return true; // Draw after first repetition
-
- i += 2;
+ stp = stp->previous->previous;
- } while (i <= e);
+ if (stp->key == st->key)
+ return true; // Draw at first repetition
}
return false;
projects / stockfish / blobdiff