Retire attackedBy[] access functions

Currently are used by evaluation itself and the
whole EvalInfo will be removed from global visibility
by next patch, so no reason to use them.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index da4860fe1ce25b26ae89d44fa97b6392a4ae23ba..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);
 
@@ -759,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
@@ -768,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.
@@ -834,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);

diff --git a/src/evaluate.h b/src/evaluate.h
index 0a37cd7c35b7e4c2dc4517d52bccaea9828d1afe..6a8ef7f16244dd181da636989dc3b9ff7c6bffc9 100644 (file)
--- a/src/evaluate.h
+++ b/src/evaluate.h
@@ -42,14 +42,19 @@
 /// contents to make intelligent search decisions.
 ///
 /// At the moment, this is not utilized very much: The only part of the
-/// EvalInfo object which is used by the search is futilityMargin.
+/// EvalInfo object which is used by the search is margin.
 class Position;
 
 struct EvalInfo {
 
-  // Middle game and endgame evaluations
+  // Middle and end game position's static evaluations
   Score value;
 
+  // margin[color] stores the evaluation margins we should consider for
+  // the given position. This is a kind of uncertainty estimation and
+  // typically is used by the search for pruning decisions.
+  Value margin[2];
+
   // Pointers to material and pawn hash table entries
   MaterialInfo* mi;
   PawnInfo* pi;
@@ -58,8 +63,6 @@ struct EvalInfo {
   // attacked by a given color and piece type, attackedBy[color][0] contains
   // all squares attacked by the given color.
   Bitboard attackedBy[2][8];
-  Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
-  Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
 
   // kingZone[color] is the zone around the enemy king which is considered
   // by the king safety evaluation. This consists of the squares directly
@@ -86,9 +89,6 @@ struct EvalInfo {
   // king is on g8 and there's a white knight on g5, this knight adds
   // 2 to kingAdjacentZoneAttacksCount[BLACK].
   int kingAdjacentZoneAttacksCount[2];
-
-  // Value of the score margin we should consider for the given color
-  Value margin[2];
 };