kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-11 03:29:14 +00:00
Code Issues Releases Wiki Activity

Rename piece_attacks_from() in attacks_from()

Browse source 
It is in line with attackers_to() and is shorter and
piece is already redundant because is passed as template
parameter anyway.

Integrate also pawn_attacks_from() in the attacks_from()
family so to have an uniform attack info API.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2009-09-20 14:23:46 +01:00
parent dd80b9abaf
commit e4277c06bf
7 changed files with 82 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/endgame.cpp
View file

@ -343,7 +343,7 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) {
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);
}
@ -434,10 +434,10 @@ ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) {
&& 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;
@ -696,7 +696,7 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position &pos) {
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);
}
@ -761,13 +761,13 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) {
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;

20
src/evaluate.cpp
View file

@ -342,8 +342,8 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
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);
@ -590,7 +590,7 @@ namespace {
// 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)
@ -620,7 +620,7 @@ namespace {
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)
@ -773,7 +773,7 @@ namespace {
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)
{
@ -785,7 +785,7 @@ namespace {
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)))
@ -801,7 +801,7 @@ namespace {
// 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);
@ -815,7 +815,7 @@ namespace {
}
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);
@ -829,7 +829,7 @@ namespace {
}
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);
@ -954,7 +954,7 @@ namespace {
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

32
src/movegen.cpp
View file

@ -253,7 +253,7 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
}
// 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)
{
@ -276,7 +276,7 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
// 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);
@ -291,9 +291,9 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
}
// 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)
{
@ -327,7 +327,7 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
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.
@ -558,7 +558,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
}
// 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));
}
@ -599,7 +599,7 @@ namespace {
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;
@ -617,7 +617,7 @@ namespace {
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;
@ -629,7 +629,7 @@ namespace {
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;
}
@ -701,7 +701,7 @@ namespace {
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)
@ -820,11 +820,11 @@ namespace {
// 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;
}
@ -840,7 +840,7 @@ namespace {
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];
@ -851,7 +851,7 @@ namespace {
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;
@ -863,7 +863,7 @@ namespace {
|| (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);
}
}

4
src/pawns.cpp
View file

@ -303,7 +303,7 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
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
@ -312,7 +312,7 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
// 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);

72
src/position.cpp
View file

@ -384,30 +384,30 @@ Bitboard Position::discovered_check_candidates(Color c) const {
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;
@ -426,7 +426,7 @@ bool Position::move_attacks_square(Move m, Square s) const {
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
@ -439,7 +439,7 @@ bool Position::move_attacks_square(Move m, Square s) const {
// 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)));
}
@ -547,7 +547,7 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
{
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?
@ -563,7 +563,7 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
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:
@ -593,21 +593,21 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
// 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?
@ -661,23 +661,23 @@ inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square
// 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()));
}
}
@ -806,7 +806,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
// 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];
@ -1358,12 +1358,12 @@ int Position::see(Square from, Square to) const {
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;

26
src/position.h
View file

@ -196,9 +196,9 @@ public:
// 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;
@ -431,33 +431,29 @@ inline Square Position::initial_qr_square(Color c) 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 {

2
src/search.cpp
View file

@ -2182,7 +2182,7 @@ namespace {
// 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