// Find squares attacked by slider checkers, we will
// remove them from king evasions set so to avoid a couple
// of cycles in the slow king evasions legality check loop
- // and to be able to use attacks_to().
+ // and to be able to use attackers_to().
Bitboard checkers = pos.checkers();
Bitboard checkersAttacks = EmptyBoardBB;
Bitboard b = checkers & pos.pieces(BISHOP, QUEEN);
while (b1)
{
to = pop_1st_bit(&b1);
- // Note that we can use attacks_to() only because we
+ // Note that we can use attackers_to() only because we
// have already removed slider checkers.
- if (!pos.attacks_to(to, them))
+ if (!pos.attackers_to(to, them))
(*mlist++).move = make_move(ksq, to);
}
// is occupied or under attack.
for (s = Min(from, g1); s <= Max(from, g1); s++)
if ( (s != from && s != to && !pos.square_is_empty(s))
- || pos.attacks_to(s, them))
+ || pos.attackers_to(s, them))
illegal = true;
// Check if any of the squares between king and rook
for (s = Min(from, c1); s <= Max(from, c1); s++)
if( (s != from && s != to && !pos.square_is_empty(s))
- || pos.attacks_to(s, them))
+ || pos.attackers_to(s, them))
illegal = true;
for (s = Min(to, d1); s <= Max(to, d1); s++)
// It is a bit complicated to correctly handle Chess960
for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
if ( (s != ksq && s != rsq && pos.square_is_occupied(s))
- || pos.attacks_to(s, them))
+ || pos.attackers_to(s, them))
illegal = true;
for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
return hidden_checkers<false>(c);
}
-/// Position::attacks_to() computes a bitboard containing all pieces which
+/// Position::attackers_to() computes a bitboard containing all pieces which
/// attacks a given square.
-Bitboard Position::attacks_to(Square s) const {
+Bitboard Position::attackers_to(Square s) const {
return (pawn_attacks(s, BLACK) & pieces(PAWN, WHITE))
| (pawn_attacks(s, WHITE) & pieces(PAWN, BLACK))
/// Position::find_checkers() computes the checkersBB bitboard, which
/// contains a nonzero bit for each checking piece (0, 1 or 2). It
-/// currently works by calling Position::attacks_to, which is probably
+/// currently works by calling Position::attackers_to, which is probably
/// inefficient. Consider rewriting this function to use the last move
/// played, like in non-bitboard versions of Glaurung.
void Position::find_checkers() {
Color us = side_to_move();
- st->checkersBB = attacks_to(king_square(us), opposite_color(us));
+ st->checkersBB = attackers_to(king_square(us), opposite_color(us));
}
// If the moving piece is a king, check whether the destination
// square is attacked by the opponent.
if (type_of_piece_on(from) == KING)
- return !attacks_to(move_to(m), opposite_color(us));
+ return !attackers_to(move_to(m), opposite_color(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.
// Update checkers bitboard, piece must be already moved
if (ep | pm)
- st->checkersBB = attacks_to(king_square(them), us);
+ st->checkersBB = attackers_to(king_square(them), us);
else
{
st->checkersBB = EmptyBoardBB;
st->rule50 = 0;
// Update checkers BB
- st->checkersBB = attacks_to(king_square(them), us);
+ st->checkersBB = attackers_to(king_square(them), us);
// Finish
sideToMove = opposite_color(sideToMove);
Color us = side_to_move();
Color them = opposite_color(us);
Square ksq = king_square(them);
- if (attacks_to(ksq, us))
+ if (attackers_to(ksq, us))
return false;
}
Square piece_list(Color c, PieceType pt, int index) const;
// Attack information to a given square
- Bitboard attacks_to(Square s) const;
- Bitboard attacks_to(Square s, Color c) const;
+ Bitboard attackers_to(Square s) const;
+ Bitboard attackers_to(Square s, Color c) const;
template<PieceType> Bitboard piece_attacks(Square s) const;
Bitboard pawn_attacks(Square s, Color c) const;
return bit_is_set(piece_attacks<Piece>(f), t);
}
-inline Bitboard Position::attacks_to(Square s, Color c) const {
+inline Bitboard Position::attackers_to(Square s, Color c) const {
- return attacks_to(s) & pieces_of_color(c);
+ return attackers_to(s) & pieces_of_color(c);
}
inline bool Position::pawn_is_passed(Color c, Square s) const {
n = Slowdown;
for (i = 0; i < n; i++) {
Square s = Square(i&63);
- if (count_1s(pos.attacks_to(s)) > 63)
- std::cout << "This can't happen, but I put this string here anyway, in order to prevent the compiler from optimizing away the useless computation." << std::endl;
+ if (count_1s(pos.attackers_to(s)) > 63)
+ std::cout << "This can't happen, but I put this string here anyway, in order to "
+ "prevent the compiler from optimizing away the useless computation." << std::endl;
}
}