Further streamline connected pawn evaluation

[stockfish] / src / pawns.cpp

diff --git a/src/pawns.cpp b/src/pawns.cpp
index 4d878e2063419a590e3a18a3633c1b75444820fa..d8d8243fc9570ab08b1cb7233544fabd7e8e61cf 100644 (file)
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -49,13 +49,8 @@ namespace {
   { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
     S(33, 31), S(33, 31), S(29, 31), S(20, 28) } };
 
-  // Connected pawn bonus by file and rank (initialized by formula)
-  Score Connected[FILE_NB][RANK_NB];
-
-  // Candidate passed pawn bonus by rank
-  const Score CandidatePassed[RANK_NB] = {
-    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
-    S(34,68), S(83,166), S(0, 0), S( 0, 0) };
+  // Connected pawn bonus by opposed, phalanx flags and rank
+  Score Connected[2][2][RANK_NB];
 
   // Levers bonus by rank
   const Score Lever[RANK_NB] = {
@@ -94,18 +89,17 @@ namespace {
     const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
     const Square Left  = (Us == WHITE ? DELTA_NW : DELTA_SE);
 
-    Bitboard b, p, doubled;
+    Bitboard b, p, doubled, connected;
     Square s;
-    File f;
-    bool passed, isolated, opposed, connected, backward, candidate, unsupported, lever;
+    bool passed, isolated, opposed, phalanx, backward, unsupported, lever;
     Score value = SCORE_ZERO;
     const Square* pl = pos.list<PAWN>(Us);
     const Bitboard* pawnAttacksBB = StepAttacksBB[make_piece(Us, PAWN)];
 
-    Bitboard ourPawns = pos.pieces(Us, PAWN);
+    Bitboard ourPawns   = pos.pieces(Us  , PAWN);
     Bitboard theirPawns = pos.pieces(Them, PAWN);
 
-    e->passedPawns[Us] = e->candidatePawns[Us] = 0;
+    e->passedPawns[Us] = 0;
     e->kingSquares[Us] = SQ_NONE;
     e->semiopenFiles[Us] = 0xFF;
     e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
@@ -117,7 +111,7 @@ namespace {
     {
         assert(pos.piece_on(s) == make_piece(Us, PAWN));
 
-        f = file_of(s);
+        File f = file_of(s);
 
         // This file cannot be semi-open
         e->semiopenFiles[Us] &= ~(1 << f);
@@ -125,12 +119,10 @@ namespace {
         // Previous rank
         p = rank_bb(s - pawn_push(Us));
 
-        // Our rank plus previous one
-        b = rank_bb(s) | p;
-
         // Flag the pawn as passed, isolated, doubled,
         // unsupported or connected (but not the backward one).
-        connected   =   ourPawns   & adjacent_files_bb(f) & b;
+        connected   =   ourPawns   & adjacent_files_bb(f) & (rank_bb(s) | p);
+        phalanx     =   connected  & rank_bb(s);
         unsupported = !(ourPawns   & adjacent_files_bb(f) & p);
         isolated    = !(ourPawns   & adjacent_files_bb(f));
         doubled     =   ourPawns   & forward_bb(Us, s);
@@ -162,14 +154,6 @@ namespace {
 
         assert(opposed | passed | (pawn_attack_span(Us, s) & theirPawns));
 
-        // A not-passed pawn is a candidate to become passed, if it is free to
-        // advance and if the number of friendly pawns beside or behind this
-        // pawn on adjacent files is higher than or equal to the number of
-        // enemy pawns in the forward direction on the adjacent files.
-        candidate =   !(opposed | passed | backward | isolated)
-                   && (b = pawn_attack_span(Them, s + pawn_push(Us)) & ourPawns) != 0
-                   &&  popcount<Max15>(b) >= popcount<Max15>(pawn_attack_span(Us, s) & theirPawns);
-
         // Passed pawns will be properly scored in evaluation because we need
         // full attack info to evaluate passed pawns. Only the frontmost passed
         // pawn on each file is considered a true passed pawn.
@@ -190,27 +174,18 @@ namespace {
             value -= Backward[opposed][f];
 
         if (connected)
-            value += Connected[f][relative_rank(Us, s)];
+            value += Connected[opposed][phalanx][relative_rank(Us, s)];
 
         if (lever)
-           value += Lever[relative_rank(Us, s)];
-
-        if (candidate)
-        {
-            value += CandidatePassed[relative_rank(Us, s)];
-
-            if (!doubled)
-                e->candidatePawns[Us] |= s;
-        }
+            value += Lever[relative_rank(Us, s)];
     }
 
+    b = e->semiopenFiles[Us] ^ 0xFF;
+    e->pawnSpan[Us] = b ? int(msb(b) - lsb(b)) : 0;
+
     // In endgame it's better to have pawns on both wings. So give a bonus according
     // to file distance between left and right outermost pawns.
-    if (pos.count<PAWN>(Us) > 1)
-    {
-        b = e->semiopenFiles[Us] ^ 0xFF;
-        value += PawnsFileSpan * int(msb(b) - lsb(b));
-    }
+    value += PawnsFileSpan * e->pawnSpan[Us];
 
     return value;
   }
@@ -219,21 +194,19 @@ namespace {
 
 namespace Pawns {
 
-/// init() initializes some tables by formula instead of hard-coding their values
-
-void init() {
-
-  const int bonusByFile[] = { 1, 3, 3, 4, 4, 3, 3, 1 };
-
-  for (Rank r = RANK_1; r < RANK_8; ++r)
-      for (File f = FILE_A; f <= FILE_H; ++f)
-      {
-          int bonus = r * (r - 1) * (r - 2) + bonusByFile[f] * (r / 2 + 1);
-          Connected[f][r] = make_score(bonus, bonus);
-      }
+void init()
+{
+  const int c[RANK_NB] = {0, 6, 15, 10, 57, 75, 135, 258};
+
+  for (Rank r = RANK_2; r <= RANK_7; ++r)
+      for (int opposed = false; opposed <= true; ++opposed)
+          for (int phalanx = false; phalanx <= true; ++phalanx)
+          {
+              int bonus = c[r] + (phalanx ? (c[r + 1] - c[r]) / 2 : 0);
+              Connected[opposed][phalanx][r] = make_score(bonus / 2, bonus >> opposed);
+          }
 }
 
-
 /// probe() takes a position as input, computes a Entry object, and returns a
 /// pointer to it. The result is also stored in a hash table, so we don't have
 /// to recompute everything when the same pawn structure occurs again.