#include <fstream>
#include <iostream>
#include <sstream>
+#include <algorithm>
#include "bitcount.h"
#include "movegen.h"
// Convert from fullmove starting from 1 to ply starting from 0,
// handle also common incorrect FEN with fullmove = 0.
- startPosPly = Max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
+ startPosPly = std::max(2 * (startPosPly - 1), 0) + int(sideToMove == BLACK);
st->key = compute_key();
st->pawnKey = compute_pawn_key();
/// 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<bool FindPinned>
Bitboard Position::hidden_checkers() const {
return result;
}
+// Explicit template instantiations
+template Bitboard Position::hidden_checkers<true>() const;
+template Bitboard Position::hidden_checkers<false>() const;
-/// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the side to move.
-
-Bitboard Position::pinned_pieces() const {
-
- return hidden_checkers<true>();
-}
-
-
-/// Position:discovered_check_candidates() returns a bitboard containing all
-/// pieces for the side to move which are candidates for giving a discovered
-/// check.
-
-Bitboard Position::discovered_check_candidates() const {
- return hidden_checkers<false>();
-}
-
-/// Position::attackers_to() computes a bitboard of all pieces which attacks a
+/// Position::attackers_to() computes a bitboard of all pieces which attack a
/// given square. Slider attacks use occ bitboard as occupancy.
Bitboard Position::attackers_to(Square s, Bitboard occ) const {
| (attacks_from<KING>(s) & pieces(KING));
}
+
/// 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.
assert(square_is_ok(s));
Bitboard occ, xray;
- Square f = move_from(m), t = move_to(m);
+ Square from = move_from(m);
+ Square to = move_to(m);
+ Piece piece = piece_on(from);
+
+ assert(!square_is_empty(from));
- assert(!square_is_empty(f));
+ // Update occupancy as if the piece is moving
+ occ = occupied_squares();
+ do_move_bb(&occ, make_move_bb(from, to));
- if (bit_is_set(attacks_from(piece_on(f), t), s))
+ // The piece moved in 'to' attacks the square 's' ?
+ if (bit_is_set(attacks_from(piece, to, occ), s))
return true;
- // Move the piece and scan for X-ray attacks behind it
- occ = occupied_squares();
- do_move_bb(&occ, make_move_bb(f, t));
- xray = ( (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN))
- |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)))
- & pieces(color_of(piece_on(f)));
+ // Scan for possible X-ray attackers behind the moved piece
+ xray = (rook_attacks_bb(s, occ) & pieces(ROOK, QUEEN, color_of(piece)))
+ |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN, color_of(piece)));
- // If we have attacks we need to verify that are caused by our move
- // and are not already existent ones.
+ // Verify attackers are triggered by our move and not already existing
return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
}
/// Position::move_is_legal() takes a random move and tests whether the move
-/// is legal. This version is not very fast and should be used only
-/// in non time-critical paths.
+/// is legal. This version is not very fast and should be used only in non
+/// time-critical paths.
bool Position::move_is_legal(const Move m) const {
// 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] = Min(-swapList[slIndex], swapList[slIndex-1]);
+ swapList[slIndex-1] = std::min(-swapList[slIndex], swapList[slIndex-1]);
return swapList[0];
}
// Draw by repetition?
if (!SkipRepetition)
{
- int i = 4, e = Min(st->rule50, st->pliesFromNull);
+ int i = 4, e = std::min(st->rule50, st->pliesFromNull);
if (i <= e)
{