Add more detailed pawn shelter/storm evaluation

src/bitboard.cpp

@@ -58,6 +58,7 @@ namespace {
   CACHE_LINE_ALIGNMENT
 
   int BSFTable[64];
+  int MS1BTable[256];
   Bitboard RTable[0x19000]; // Storage space for rook attacks
   Bitboard BTable[0x1480];  // Storage space for bishop attacks
 
@@ -140,6 +141,26 @@ Square pop_1st_bit(Bitboard* b) {
 
 #endif // !defined(USE_BSFQ)
 
+#if !defined(USE_BSFQ)
+
+Square last_1(Bitboard b) {
+  int result = 0;
+  if (b > 0xFFFFFFFF) {
+    b >>= 32;
+    result = 32;
+  }
+  if (b > 0xFFFF) {
+    b >>= 16;
+    result += 16;
+  }
+  if (b > 0xFF) {
+    b >>= 8;
+    result += 8;
+  }
+  return Square(result + MS1BTable[b]);
+}
+
+#endif // !defined(USE_BSFQ)
 
 /// bitboards_init() initializes various bitboard arrays. It is called during
 /// program initialization.
@@ -196,6 +217,11 @@ void bitboards_init() {
       else
           BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i;
 
+  MS1BTable[0] = 0;
+  for (int i = 0, k = 1; i < 8; i++)
+    for (int j = 0; j < (1 << i); j++)
+      MS1BTable[k++] = i;
+
   int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
                      {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
 

src/bitboard.h

@@ -214,7 +214,6 @@ inline bool single_bit(Bitboard b) {
   return !(b & (b - 1));
 }
 
-
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
@@ -224,9 +223,15 @@ inline bool single_bit(Bitboard b) {
 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 
 FORCE_INLINE Square first_1(Bitboard b) {
-   unsigned long index;
+  unsigned long index;
-   _BitScanForward64(&index, b);
+  _BitScanForward64(&index, b);
-   return (Square) index;
+  return (Square) index;
+}
+
+FORCE_INLINE Square last_1(Bitboard b) {
+  unsigned long index;
+  _BitScanReverse64(&index, b);
+  return (Square) index;
 }
 #else
 
@@ -235,6 +240,12 @@ FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
   __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
   return (Square) dummy;
 }
+
+FORCE_INLINE Square last_1(Bitboard b) {
+  Bitboard dummy;
+  __asm__("bsrq %1, %0": "=r"(dummy): "rm"(b) );
+  return (Square) dummy;
+}
 #endif
 
 FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
@@ -246,10 +257,20 @@ FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
 #else // if !defined(USE_BSFQ)
 
 extern Square first_1(Bitboard b);
+extern Square last_1(Bitboard b);
 extern Square pop_1st_bit(Bitboard* b);
 
 #endif
 
+// relative_rank() returns the relative rank of the closest bit set on the Bitboard.
+// Only to be used with bitboards that contain a single file.
+
+template<Color Us>
+inline Rank relative_rank(Bitboard b) {
+  Square s = Us == WHITE ?  first_1(b)
+                         : ~last_1(b);
+  return rank_of(s);
+}
 
 extern void print_bitboard(Bitboard b);
 extern void bitboards_init();

src/pawns.cpp

@@ -65,6 +65,19 @@ namespace {
 
   #undef S
 
+  const File ShelterFile[8] = { FILE_B, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_G };
+
+  inline Value score_non_center_file(const Value v) {
+		return Value(v * 7 / 16);
+  }
+
+  typedef Value V;
+  // Arrays are indexed by rank.  Zeroth value is for when no pawn on that file.
+  const Value PawnShelter[8] =  { V(141), V(0), V( 38), V(102), V(128), V(141), V(141), V(141) };
+  const Value PawnStorm[8] =    { V( 26), V(0), V(128), V( 51), V( 26), V(  0), V(  0), V(  0) };
+  // We compute shelter as a penalty for the given color, but shelter is used as a bonus, so we invert it using this as the basis.
+  const Value PawnShelterBasis =  PawnShelter[0] + score_non_center_file(PawnShelter[0]) * 2;
+
   inline Score apply_weight(Score v, Score w) {
     return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
                       (int(eg_value(v)) * eg_value(w)) / 0x100);
@@ -209,27 +222,53 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
   return value;
 }
 
+template<Color Us>
+int computePawnShelter(const Position &pos, Square ksq) {
+  const Color Them          = (Us == WHITE ? BLACK : WHITE);
+  const File kingFile       = ShelterFile[file_of(ksq)];
+  const Bitboard ourPawns   = pos.pieces(PAWN, Us) & in_front_bb(Us, ksq);
+  const Bitboard theirPawns = pos.pieces(PAWN, Them) & (RankBB[rank_of(ksq)] | in_front_bb(Us, ksq));
+
+  int shelter = 0;
+
+  // Compute king shelter and storm values for the file the king is on, as well as the two adjacent files.
+  for (int fileOffset = -1; fileOffset <= 1; fileOffset++) {
+    // Shelter takes full penalty for center file, otherwise it's half penalty
+    Bitboard shelterFile  = ourPawns & FileBB[kingFile + fileOffset];
+    Rank shelterClosest = shelterFile ? relative_rank<Us>(shelterFile)
+                                      : RANK_1;
+
+    shelter += fileOffset == 0 ? PawnShelter[shelterClosest]
+                               : score_non_center_file(PawnShelter[shelterClosest]);
+
+    // Storm takes full penalty, unless there is an enemy pawn blocking us
+    Bitboard stormFile  = theirPawns & FileBB[kingFile + fileOffset];
+    Rank stormClosest   = stormFile ? relative_rank<Us>(stormFile)
+                                    : RANK_1;
+
+    shelter += shelterClosest + 1 == stormClosest ? PawnStorm[stormClosest] / 2
+                                                  : PawnStorm[stormClosest];
+  }
+  
+  return shelter;
+}
 
 /// PawnInfo::updateShelter() calculates and caches king shelter. It is called
 /// only when king square changes, about 20% of total king_shelter() calls.
 template<Color Us>
 Score PawnInfo::updateShelter(const Position& pos, Square ksq) {
-
+  int shelter = 0;
-  const int Shift = (Us == WHITE ? 8 : -8);
-
-  Bitboard pawns;
-  int r, shelter = 0;
 
   if (relative_rank(Us, ksq) <= RANK_4)
   {
-      pawns = pos.pieces(PAWN, Us) & this_and_adjacent_files_bb(file_of(ksq));
+    shelter = computePawnShelter<Us>(pos, ksq);
-      r = ksq & (7 << 3);
+    if (pos.can_castle(Us == WHITE ? WHITE_OO : BLACK_OO))
-      for (int i = 0; i < 3; i++)
+      shelter = std::min(shelter, computePawnShelter<Us>(pos, relative_square(Us, SQ_G1)));
-      {
+    if (pos.can_castle(Us == WHITE ? WHITE_OOO : BLACK_OOO))
-          r += Shift;
+      shelter = std::min(shelter, computePawnShelter<Us>(pos, relative_square(Us, SQ_C1)));
-          shelter += BitCount8Bit[(pawns >> r) & 0xFF] << (6 - i);
+    shelter = PawnShelterBasis - shelter;
-      }
   }
+
   kingSquares[Us] = ksq;
   kingShelters[Us] = make_score(shelter, 0);
   return kingShelters[Us];