result += Value(square_distance(bksq, nsq) * 32);
// Bonus for restricting the knight's mobility
- result += Value((8 - count_1s_max_15(pos.piece_attacks_from<KNIGHT>(nsq))) * 8);
+ result += Value((8 - count_1s_max_15(pos.attacks_from<KNIGHT>(nsq))) * 8);
return (strongerSide == pos.side_to_move() ? result : -result);
}
&& relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4
&& (pos.pieces(ROOK, weakerSide) & relative_rank_bb(weakerSide, RANK_3))
&& (pos.pieces(PAWN, weakerSide) & relative_rank_bb(weakerSide, RANK_2))
- && (pos.piece_attacks_from<KING>(kingSq) & pos.pieces(PAWN, weakerSide)))
+ && (pos.attacks_from<KING>(kingSq) & pos.pieces(PAWN, weakerSide)))
{
Square rsq = pos.piece_list(weakerSide, ROOK, 0);
- if (pos.pawn_attacks_from(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
+ if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
return ScaleFactor(0);
}
return SCALE_FACTOR_NONE;
Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
if (ray & pos.pieces(KING, weakerSide))
return ScaleFactor(0);
- if( (pos.piece_attacks_from<BISHOP>(weakerBishopSq) & ray)
+ if( (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
&& square_distance(weakerBishopSq, pawnSq) >= 3)
return ScaleFactor(0);
}
if ( ksq == blockSq1
&& square_color(ksq) != square_color(wbsq)
&& ( bbsq == blockSq2
- || (pos.piece_attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
+ || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
|| rank_distance(r1, r2) >= 2))
return ScaleFactor(0);
else if ( ksq == blockSq2
&& square_color(ksq) != square_color(wbsq)
&& ( bbsq == blockSq1
- || (pos.piece_attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
+ || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
return ScaleFactor(0);
else
return SCALE_FACTOR_NONE;
ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
// Initialize king attack bitboards and king attack zones for both sides
- ei.attackedBy[WHITE][KING] = pos.piece_attacks_from<KING>(pos.king_square(WHITE));
- ei.attackedBy[BLACK][KING] = pos.piece_attacks_from<KING>(pos.king_square(BLACK));
+ ei.attackedBy[WHITE][KING] = pos.attacks_from<KING>(pos.king_square(WHITE));
+ ei.attackedBy[BLACK][KING] = pos.attacks_from<KING>(pos.king_square(BLACK));
ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
// Increase bonus if supported by pawn, especially if the opponent has
// no minor piece which can exchange the outpost piece
- if (bonus && (p.pawn_attacks_from(s, them) & p.pieces(PAWN, us)))
+ if (bonus && (p.attacks_from<PAWN>(s, them) & p.pieces(PAWN, us)))
{
if ( p.pieces(KNIGHT, them) == EmptyBoardBB
&& (SquaresByColorBB[square_color(s)] & p.pieces(BISHOP, them)) == EmptyBoardBB)
s = pos.piece_list(us, Piece, i);
if (Piece == KNIGHT || Piece == QUEEN)
- b = pos.piece_attacks_from<Piece>(s);
+ b = pos.attacks_from<Piece>(s);
else if (Piece == BISHOP)
b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.pieces(QUEEN, us));
else if (Piece == ROOK)
if (QueenContactMates && !p.is_check())
{
Bitboard escapeSquares =
- p.piece_attacks_from<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
+ p.attacks_from<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
while (b)
{
for (int i = 0; i < p.piece_count(them, QUEEN); i++)
{
from = p.piece_list(them, QUEEN, i);
- if ( bit_is_set(p.piece_attacks_from<QUEEN>(from), to)
+ if ( bit_is_set(p.attacks_from<QUEEN>(from), to)
&& !bit_is_set(p.pinned_pieces(them), from)
&& !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(ROOK, QUEEN, us))
&& !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.pieces(BISHOP, QUEEN, us)))
// Analyse safe distance checks
if (QueenCheckBonus > 0 || RookCheckBonus > 0)
{
- b = p.piece_attacks_from<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.attacks_from<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
}
if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
{
- b = p.piece_attacks_from<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.attacks_from<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
}
if (KnightCheckBonus > 0)
{
- b = p.piece_attacks_from<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
+ b = p.attacks_from<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
// Knight checks
b2 = b & ei.attacked_by(them, KNIGHT);
b2 = pos.pieces(PAWN, us) & neighboring_files_bb(s);
if (b2 & rank_bb(s))
ebonus += Value(r * 20);
- else if (pos.pawn_attacks_from(s, them) & b2)
+ else if (pos.attacks_from<PAWN>(s, them) & b2)
ebonus += Value(r * 12);
// If the other side has only a king, check whether the pawn is
}
// Generate evasions for king
- Bitboard b1 = pos.piece_attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~checkersAttacks;
+ Bitboard b1 = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~checkersAttacks;
Bitboard enemy = pos.pieces_of_color(them);
while (b1)
{
// Generate captures of the checking piece
// Pawn captures
- b1 = pos.pawn_attacks_from(checksq, them) & pos.pieces(PAWN, us) & ~pinned;
+ b1 = pos.attacks_from<PAWN>(checksq, them) & pos.pieces(PAWN, us) & ~pinned;
while (b1)
{
from = pop_1st_bit(&b1);
}
// Pieces captures
- b1 = ( (pos.piece_attacks_from<KNIGHT>(checksq) & pos.pieces(KNIGHT, us))
- | (pos.piece_attacks_from<BISHOP>(checksq) & pos.pieces(BISHOP, QUEEN, us))
- | (pos.piece_attacks_from<ROOK>(checksq) & pos.pieces(ROOK, QUEEN, us)) ) & ~pinned;
+ b1 = ( (pos.attacks_from<KNIGHT>(checksq) & pos.pieces(KNIGHT, us))
+ | (pos.attacks_from<BISHOP>(checksq) & pos.pieces(BISHOP, QUEEN, us))
+ | (pos.attacks_from<ROOK>(checksq) & pos.pieces(ROOK, QUEEN, us)) ) & ~pinned;
while (b1)
{
if (pos.ep_square() != SQ_NONE && (checkers & pos.pieces(PAWN, them)))
{
to = pos.ep_square();
- b1 = pos.pawn_attacks_from(to, them) & pos.pieces(PAWN, us);
+ b1 = pos.attacks_from<PAWN>(to, them) & pos.pieces(PAWN, us);
// The checking pawn cannot be a discovered (bishop) check candidate
// otherwise we were in check also before last double push move.
}
// Luckly we can handle all the other pieces in one go
- return ( bit_is_set(pos.piece_attacks_from(pc, from), to)
+ return ( bit_is_set(pos.attacks_from(pc, from), to)
&& pos.pl_move_is_legal(m, pinned)
&& !move_is_promotion(m));
}
for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
{
from = pos.piece_list(us, Piece, i);
- b = pos.piece_attacks_from<Piece>(from) & target;
+ b = pos.attacks_from<Piece>(from) & target;
SERIALIZE_MOVES(b);
}
return mlist;
if (pinned && bit_is_set(pinned, from))
continue;
- b = pos.piece_attacks_from<Piece>(from) & target;
+ b = pos.attacks_from<Piece>(from) & target;
SERIALIZE_MOVES(b);
}
return mlist;
Bitboard b;
Square from = pos.king_square(us);
- b = pos.piece_attacks_from<KING>(from) & target;
+ b = pos.attacks_from<KING>(from) & target;
SERIALIZE_MOVES(b);
return mlist;
}
assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
- Bitboard b1 = pawns & pos.pawn_attacks_from(pos.ep_square(), Them);
+ Bitboard b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
assert(b1 != EmptyBoardBB);
while (b1)
// Direct checks, single pawn pushes
Bitboard empty = pos.empty_squares();
b2 = move_pawns<Us, DELTA_N>(b1) & empty;
- b3 = b2 & pos.pawn_attacks_from(ksq, Them);
+ b3 = b2 & pos.attacks_from<PAWN>(ksq, Them);
SERIALIZE_MOVES_D(b3, -TDELTA_N);
// Direct checks, double pawn pushes
- b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty & pos.pawn_attacks_from(ksq, Them);
+ b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty & pos.attacks_from<PAWN>(ksq, Them);
SERIALIZE_MOVES_D(b3, -TDELTA_N -TDELTA_N);
return mlist;
}
while (b)
{
Square from = pop_1st_bit(&b);
- Bitboard bb = pos.piece_attacks_from<Piece>(from) & pos.empty_squares();
+ Bitboard bb = pos.attacks_from<Piece>(from) & pos.empty_squares();
if (Piece == KING)
bb &= ~QueenPseudoAttacks[ksq];
b = target & ~dc;
if (Piece != KING || b)
{
- Bitboard checkSqs = pos.piece_attacks_from<Piece>(ksq) & pos.empty_squares();
+ Bitboard checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
if (!checkSqs)
return mlist;
|| (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
continue;
- Bitboard bb = pos.piece_attacks_from<Piece>(from) & checkSqs;
+ Bitboard bb = pos.attacks_from<Piece>(from) & checkSqs;
SERIALIZE_MOVES(bb);
}
}
if ( passed
|| isolated
|| chain
- || (pos.pawn_attacks_from(s, us) & theirPawns)
+ || (pos.attacks_from<PAWN>(s, us) & theirPawns)
|| (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
backward = false;
else
// pawn on neighboring files. We now check whether the pawn is
// backward by looking in the forward direction on the neighboring
// files, and seeing whether we meet a friendly or an enemy pawn first.
- Bitboard b = pos.pawn_attacks_from(s, us);
+ Bitboard b = pos.attacks_from<PAWN>(s, us);
if (us == WHITE)
{
for ( ; !(b & (ourPawns | theirPawns)); b <<= 8);
Bitboard Position::attackers_to(Square s) const {
- return (pawn_attacks_from(s, BLACK) & pieces(PAWN, WHITE))
- | (pawn_attacks_from(s, WHITE) & pieces(PAWN, BLACK))
- | (piece_attacks_from<KNIGHT>(s) & pieces(KNIGHT))
- | (piece_attacks_from<ROOK>(s) & pieces(ROOK, QUEEN))
- | (piece_attacks_from<BISHOP>(s) & pieces(BISHOP, QUEEN))
- | (piece_attacks_from<KING>(s) & pieces(KING));
+ return (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
+ | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
+ | (attacks_from<KNIGHT>(s) & pieces(KNIGHT))
+ | (attacks_from<ROOK>(s) & pieces(ROOK, QUEEN))
+ | (attacks_from<BISHOP>(s) & pieces(BISHOP, QUEEN))
+ | (attacks_from<KING>(s) & pieces(KING));
}
-/// Position::piece_attacks_from() computes a bitboard of all attacks
+/// Position::attacks_from() computes a bitboard of all attacks
/// of a given piece put in a given square.
-Bitboard Position::piece_attacks_from(Piece p, Square s) const {
+Bitboard Position::attacks_from(Piece p, Square s) const {
assert(square_is_ok(s));
switch (p)
{
- case WP: return pawn_attacks_from(s, WHITE);
- case BP: return pawn_attacks_from(s, BLACK);
- case WN: case BN: return piece_attacks_from<KNIGHT>(s);
- case WB: case BB: return piece_attacks_from<BISHOP>(s);
- case WR: case BR: return piece_attacks_from<ROOK>(s);
- case WQ: case BQ: return piece_attacks_from<QUEEN>(s);
- case WK: case BK: return piece_attacks_from<KING>(s);
+ case WP: return attacks_from<PAWN>(s, WHITE);
+ case BP: return attacks_from<PAWN>(s, BLACK);
+ case WN: case BN: return attacks_from<KNIGHT>(s);
+ case WB: case BB: return attacks_from<BISHOP>(s);
+ case WR: case BR: return attacks_from<ROOK>(s);
+ case WQ: case BQ: return attacks_from<QUEEN>(s);
+ case WK: case BK: return attacks_from<KING>(s);
default: break;
}
return false;
assert(square_is_occupied(f));
- if (bit_is_set(piece_attacks_from(piece_on(f), t), s))
+ if (bit_is_set(attacks_from(piece_on(f), t), s))
return true;
// Move the piece and scan for X-ray attacks behind it
// If we have attacks we need to verify that are caused by our move
// and are not already existent ones.
- return xray && (xray ^ (xray & piece_attacks_from<QUEEN>(s)));
+ return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
}
{
case PAWN:
- if (bit_is_set(pawn_attacks_from(ksq, them), to)) // Normal check?
+ if (bit_is_set(attacks_from<PAWN>(ksq, them), to)) // Normal check?
return true;
if ( dcCandidates // Discovered check?
switch (move_promotion_piece(m))
{
case KNIGHT:
- return bit_is_set(piece_attacks_from<KNIGHT>(to), ksq);
+ return bit_is_set(attacks_from<KNIGHT>(to), ksq);
case BISHOP:
return bit_is_set(bishop_attacks_bb(to, b), ksq);
case ROOK:
// Test discovered check and normal check according to piece type
case KNIGHT:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || bit_is_set(piece_attacks_from<KNIGHT>(ksq), to);
+ || bit_is_set(attacks_from<KNIGHT>(ksq), to);
case BISHOP:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || (direction_is_diagonal(ksq, to) && bit_is_set(piece_attacks_from<BISHOP>(ksq), to));
+ || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to));
case ROOK:
return (dcCandidates && bit_is_set(dcCandidates, from))
- || (direction_is_straight(ksq, to) && bit_is_set(piece_attacks_from<ROOK>(ksq), to));
+ || (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to));
case QUEEN:
// Discovered checks are impossible!
assert(!bit_is_set(dcCandidates, from));
- return ( (direction_is_straight(ksq, to) && bit_is_set(piece_attacks_from<ROOK>(ksq), to))
- || (direction_is_diagonal(ksq, to) && bit_is_set(piece_attacks_from<BISHOP>(ksq), to)));
+ return ( (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to))
+ || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to)));
case KING:
// Discovered check?
// Direct checks
if ( ( (Bishop && bit_is_set(BishopPseudoAttacks[ksq], to))
|| (Rook && bit_is_set(RookPseudoAttacks[ksq], to)))
- && bit_is_set(piece_attacks_from<Piece>(ksq), to)) // slow, try to early skip
+ && bit_is_set(attacks_from<Piece>(ksq), to)) // slow, try to early skip
set_bit(pCheckersBB, to);
else if ( Piece != KING
&& !Slider
- && bit_is_set(Piece == PAWN ? pawn_attacks_from(ksq, opposite_color(sideToMove))
- : piece_attacks_from<Piece>(ksq), to))
+ && bit_is_set(Piece == PAWN ? attacks_from<PAWN>(ksq, opposite_color(sideToMove))
+ : attacks_from<Piece>(ksq), to))
set_bit(pCheckersBB, to);
// Discovery checks
if (Piece != QUEEN && bit_is_set(dcCandidates, from))
{
if (Piece != ROOK)
- (*pCheckersBB) |= (piece_attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
+ (*pCheckersBB) |= (attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
if (Piece != BISHOP)
- (*pCheckersBB) |= (piece_attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
+ (*pCheckersBB) |= (attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
}
}
// Set en passant square, only if moved pawn can be captured
if (abs(int(to) - int(from)) == 16)
{
- if (pawn_attacks_from(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
+ if (attacks_from<PAWN>(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
{
st->epSquare = Square((int(from) + int(to)) / 2);
key ^= zobEp[st->epSquare];
while (true)
{
clear_bit(&occ, from);
- attackers = (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN))
- | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN))
- | (piece_attacks_from<KNIGHT>(to) & pieces(KNIGHT))
- | (piece_attacks_from<KING>(to) & pieces(KING))
- | (pawn_attacks_from(to, WHITE) & pieces(PAWN, BLACK))
- | (pawn_attacks_from(to, BLACK) & pieces(PAWN, WHITE));
+ attackers = (rook_attacks_bb(to, occ) & pieces(ROOK, QUEEN))
+ | (bishop_attacks_bb(to, occ) & pieces(BISHOP, QUEEN))
+ | (attacks_from<KNIGHT>(to) & pieces(KNIGHT))
+ | (attacks_from<KING>(to) & pieces(KING))
+ | (attacks_from<PAWN>(to, WHITE) & pieces(PAWN, BLACK))
+ | (attacks_from<PAWN>(to, BLACK) & pieces(PAWN, WHITE));
if (from != SQ_NONE)
break;
// Information about attacks to or from a given square
Bitboard attackers_to(Square s) const;
- Bitboard piece_attacks_from(Piece p, Square s) const;
- Bitboard pawn_attacks_from(Square s, Color c) const;
- template<PieceType> Bitboard piece_attacks_from(Square s) const;
+ Bitboard attacks_from(Piece p, Square s) const;
+ template<PieceType> Bitboard attacks_from(Square s) const;
+ template<PieceType> Bitboard attacks_from(Square s, Color c) const;
// Properties of moves
bool pl_move_is_legal(Move m) const;
return relative_square(c, make_square(initialQRFile, RANK_1));
}
-inline Bitboard Position::pawn_attacks_from(Square s, Color c) const {
+template<>
+inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
}
-template<PieceType Piece> // Knight and King
-inline Bitboard Position::piece_attacks_from(Square s) const {
+template<PieceType Piece> // Knight and King and white pawns
+inline Bitboard Position::attacks_from(Square s) const {
return StepAttackBB[Piece][s];
}
template<>
-inline Bitboard Position::piece_attacks_from<PAWN>(Square s) const {
- return StepAttackBB[WP][s] | StepAttackBB[BP][s];
-}
-
-template<>
-inline Bitboard Position::piece_attacks_from<BISHOP>(Square s) const {
+inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
return bishop_attacks_bb(s, occupied_squares());
}
template<>
-inline Bitboard Position::piece_attacks_from<ROOK>(Square s) const {
+inline Bitboard Position::attacks_from<ROOK>(Square s) const {
return rook_attacks_bb(s, occupied_squares());
}
template<>
-inline Bitboard Position::piece_attacks_from<QUEEN>(Square s) const {
- return piece_attacks_from<ROOK>(s) | piece_attacks_from<BISHOP>(s);
+inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
+ return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
}
inline Bitboard Position::checkers() const {
// Case 4: The destination square for m2 is attacked by the moving piece in m1
p = pos.piece_on(t1);
- if (bit_is_set(pos.piece_attacks_from(p, t1), t2))
+ if (bit_is_set(pos.attacks_from(p, t1), t2))
return true;
// Case 5: Discovered check, checking piece is the piece moved in m1