Retire attackedBy[] access functions

[stockfish] / src / evaluate.cpp

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 6bdf423598c6d7bf0504947e2edb3b0cf7fa2838..0a68387ebcdf4c629d6f58477e6e304345a34391 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -652,10 +652,10 @@ namespace {
 
         // Find the attacked squares around the king which has no defenders
         // apart from the king itself
-        undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING);
-        undefended &= ~(  ei.attacked_by(Us, PAWN)   | ei.attacked_by(Us, KNIGHT)
-                        | ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK)
-                        | ei.attacked_by(Us, QUEEN));
+        undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
+        undefended &= ~(  ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
+                        | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
+                        | ei.attackedBy[Us][QUEEN]);
 
         // Initialize the 'attackUnits' variable, which is used later on as an
         // index to the KingDangerTable[] array. The initial value is based on
@@ -669,39 +669,39 @@ namespace {
 
         // Analyse enemy's safe queen contact checks. First find undefended
         // squares around the king attacked by enemy queen...
-        b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
+        b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces_of_color(Them);
         if (b)
         {
             // ...then remove squares not supported by another enemy piece
-            b &= (  ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
-                  | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
+            b &= (  ei.attackedBy[Them][PAWN]   | ei.attackedBy[Them][KNIGHT]
+                  | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
             if (b)
                 attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
         }
 
         // Analyse enemy's safe distance checks for sliders and knights
-        safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
+        safe = ~(pos.pieces_of_color(Them) | ei.attackedBy[Us][0]);
 
         b1 = pos.attacks_from<ROOK>(ksq) & safe;
         b2 = pos.attacks_from<BISHOP>(ksq) & safe;
 
         // Enemy queen safe checks
-        b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
+        b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
         if (b)
             attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
 
         // Enemy rooks safe checks
-        b = b1 & ei.attacked_by(Them, ROOK);
+        b = b1 & ei.attackedBy[Them][ROOK];
         if (b)
             attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
 
         // Enemy bishops safe checks
-        b = b2 & ei.attacked_by(Them, BISHOP);
+        b = b2 & ei.attackedBy[Them][BISHOP];
         if (b)
             attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
 
         // Enemy knights safe checks
-        b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
+        b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
         if (b)
             attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
 
@@ -709,14 +709,14 @@ namespace {
         attackUnits = Min(99, Max(0, attackUnits));
 
         // Finally, extract the king danger score from the KingDangerTable[]
-        // array and subtract the score from evaluation. Set also ei.kingDanger[]
+        // array and subtract the score from evaluation. Set also ei.margin[]
         // value that will be used for pruning because this value can sometimes
         // be very big, and so capturing a single attacking piece can therefore
         // result in a score change far bigger than the value of the captured piece.
         ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
-        ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);
+        ei.margin[Us] = mg_value(KingDangerTable[Us][attackUnits]);
     } else
-        ei.kingDanger[Us] = VALUE_ZERO;
+        ei.margin[Us] = VALUE_ZERO;
   }
 
 
@@ -727,11 +727,14 @@ namespace {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
+    Score bonus = SCORE_ZERO;
     Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
     Bitboard b = ei.pi->passed_pawns(Us);
 
-    while (b)
-    {
+    if (!b)
+        return;
+
+    do {
         Square s = pop_1st_bit(&b);
 
         assert(pos.pawn_is_passed(Us, s));
@@ -756,7 +759,7 @@ namespace {
             if (pos.square_is_empty(blockSq))
             {
                 squaresToQueen = squares_in_front_of(Us, s);
-                defendedSquares = squaresToQueen & ei.attacked_by(Us);
+                defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
 
                 // If there is an enemy rook or queen attacking the pawn from behind,
                 // add all X-ray attacks by the rook or queen. Otherwise consider only
@@ -765,7 +768,7 @@ namespace {
                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
                     unsafeSquares = squaresToQueen;
                 else
-                    unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
+                    unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces_of_color(Them));
 
                 // If there aren't enemy attacks or pieces along the path to queen give
                 // huge bonus. Even bigger if we protect the pawn's path.
@@ -806,11 +809,12 @@ namespace {
             else if (pos.pieces(ROOK, QUEEN, Them))
                 ebonus -= ebonus / 4;
         }
+        bonus += make_score(mbonus, ebonus);
 
-        // Add the scores for this pawn to the middle game and endgame eval
-        ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), Weights[PassedPawns]);
+    } while (b);
 
-    } // while
+    // Add the scores to the middle game and endgame eval
+    ei.value += Sign[Us] * apply_weight(bonus, Weights[PassedPawns]);
   }
 
 
@@ -830,8 +834,8 @@ namespace {
     // pawn, or if it is undefended and attacked by an enemy piece.
     Bitboard safe =   SpaceMask[Us]
                    & ~pos.pieces(PAWN, Us)
-                   & ~ei.attacked_by(Them, PAWN)
-                   & (ei.attacked_by(Us) | ~ei.attacked_by(Them));
+                   & ~ei.attackedBy[Them][PAWN]
+                   & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
 
     // Find all squares which are at most three squares behind some friendly pawn
     Bitboard behind = pos.pieces(PAWN, Us);