From 91de6b0f37516462658f6e38db430813aa9e7ed8 Mon Sep 17 00:00:00 2001
From: lucasart <lucas.braesch@gmail.com>
Date: Sun, 12 Oct 2014 20:03:49 +0100
Subject: [PATCH]  Further streamline connected pawn evaluation

Make even more clear what are the terms that
contribute to evaluate connected pawns, and
completely separate them from the weights
that are now fully looked up in a table.

For future tuning makes sense to init the table with
a formula instead of hard-code it. This allows to
reduce problem space cardinality and makes tuning
easier.

And fix a MSVC warning while there:
warning C4804: '>>' : unsafe use of type 'bool' in operation

No functional change.
---
 src/main.cpp  |  1 +
 src/pawns.cpp | 38 ++++++++++++++++++++++----------------
 src/pawns.h   |  1 +
 3 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index f2d26814..9fbe6350 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -37,6 +37,7 @@ int main(int argc, char* argv[]) {
   Bitbases::init_kpk();
   Search::init();
   Eval::init();
+  Pawns::init();
   Threads.init();
   TT.resize(Options["Hash"]);
 
diff --git a/src/pawns.cpp b/src/pawns.cpp
index 4693e158..d8d8243f 100644
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -49,8 +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 bonus by rank
-  const int Connected[RANK_NB] = {0, 6, 15, 10, 57, 75, 135, 258};
+  // Connected pawn bonus by opposed, phalanx flags and rank
+  Score Connected[2][2][RANK_NB];
 
   // Levers bonus by rank
   const Score Lever[RANK_NB] = {
@@ -89,9 +89,9 @@ 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;
-    bool passed, isolated, opposed, connected, backward, 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)];
@@ -111,7 +111,6 @@ namespace {
     {
         assert(pos.piece_on(s) == make_piece(Us, PAWN));
 
-        Rank r = rank_of(s), rr = relative_rank(Us, s);
         File f = file_of(s);
 
         // This file cannot be semi-open
@@ -120,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);
@@ -176,15 +173,11 @@ namespace {
         if (backward)
             value -= Backward[opposed][f];
 
-        if (connected) {
-            int bonus = Connected[rr];
-            if (ourPawns & adjacent_files_bb(f) & rank_bb(r))
-                bonus += (Connected[rr+1] - Connected[rr]) / 2;
-            value += make_score(bonus / 2, bonus >> opposed);
-        }
+        if (connected)
+            value += Connected[opposed][phalanx][relative_rank(Us, s)];
 
         if (lever)
-            value += Lever[rr];
+            value += Lever[relative_rank(Us, s)];
     }
 
     b = e->semiopenFiles[Us] ^ 0xFF;
@@ -201,6 +194,19 @@ namespace {
 
 namespace Pawns {
 
+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.
diff --git a/src/pawns.h b/src/pawns.h
index f24fb75a..5803e36c 100644
--- a/src/pawns.h
+++ b/src/pawns.h
@@ -79,6 +79,7 @@ struct Entry {
 
 typedef HashTable<Entry, 16384> Table;
 
+void init();
 Entry* probe(const Position& pos, Table& entries);
 
 } // namespace Pawns
-- 
2.39.2