Rename piece_attacks_from() in attacks_from()
authorMarco Costalba <mcostalba@gmail.com>
Sun, 20 Sep 2009 13:23:46 +0000 (14:23 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Sun, 20 Sep 2009 13:55:28 +0000 (14:55 +0100)
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>
src/endgame.cpp
src/evaluate.cpp
src/movegen.cpp
src/pawns.cpp
src/position.cpp
src/position.h
src/search.cpp

index 94bed094c49f7f043d1c9ede847c825b505bb880..5e1f5a0d1d44e2b520b63cb01b121ae7902ce98f 100644 (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;
index 2a4536b7fa43331a38c9497a96fd0c282fe8a970..5c56ed66178b75233106961c7261843668e554fc 100644 (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
index ed09d44b7a82c7b63d93c49fb1af9068e7b35a06..07c99bf441d996081cb941342f0f3525929e6878 100644 (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);
         }
     }
index c32fbdec7dfa7d639f85d129df851d52fe569535..f06b1283d418a529e8196150a5de85e8b934bd02 100644 (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);
index 9b9ca22ac78bed0120b8a2a62f8d0f18e4de3e2a..96b455f1249801cf9b6435ec72b0ea2b2f30b5ba 100644 (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;
index c9088438a23f9bc7be5561a6f17ae5f258109dd5..a051ec382f49fe15a0d3ee55238e97a48c1158ac 100644 (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 {
index 55b2e92c883fcae9cf6b0362c102a174f5dd3127..41f679a2e791a73a4e39a7a1b3cefb5767775da7 100644 (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