Bonus for restricting opponent's piece moves

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 51883 W: 11297 L: 10915 D: 29671
http://tests.stockfishchess.org/tests/view/5bf1e2ee0ebc595e0ae3cacd

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 15859 W: 2752 L: 2565 D: 10542
http://tests.stockfishchess.org/tests/view/5bf337980ebc5902bcecbf62

Notes:

(1) The bonus value has not been carefully tested, so it may be possible
to find slightly better values.

(2) Plan is to now try adding similar restriction for pawns. I wanted to
include that as part of this pull request, but I was advised to do it as
two separate pull requests. STC is currently running here, but may not add
enough value to pass green.

Bench: 3679086

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index c7b9f894bf0b9a6f3e034eb90a815972b26becd7..f2126512413f576417faaed3bb08db28419afb3d 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -162,6 +162,7 @@ namespace {
   constexpr Score MinorBehindPawn    = S( 16,  0);
   constexpr Score Overload           = S( 12,  6);
   constexpr Score PawnlessFlank      = S( 18, 94);
   constexpr Score MinorBehindPawn    = S( 16,  0);
   constexpr Score Overload           = S( 12,  6);
   constexpr Score PawnlessFlank      = S( 18, 94);

+  constexpr Score RestrictedPiece    = S(  7,  6);

   constexpr Score RookOnPawn         = S( 10, 28);
   constexpr Score SliderOnQueen      = S( 49, 21);
   constexpr Score ThreatByKing       = S( 21, 84);
   constexpr Score RookOnPawn         = S( 10, 28);
   constexpr Score SliderOnQueen      = S( 49, 21);
   constexpr Score ThreatByKing       = S( 21, 84);


@@ -508,7 +509,7 @@ namespace {
     constexpr Direction Up       = (Us == WHITE ? NORTH   : SOUTH);
     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
 
     constexpr Direction Up       = (Us == WHITE ? NORTH   : SOUTH);
     constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
 

-    Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
+    Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe, restricted;

     Score score = SCORE_ZERO;
 
     // Non-pawn enemies
     Score score = SCORE_ZERO;
 
     // Non-pawn enemies


@@ -558,6 +559,13 @@ namespace {
         score += Overload * popcount(b);
     }
 
         score += Overload * popcount(b);
     }
 

+    // Bonus for restricting their piece moves
+    restricted =   attackedBy[Them][ALL_PIECES]
+                & ~attackedBy[Them][PAWN]
+                & ~attackedBy2[Them]
+                &  attackedBy[Us][ALL_PIECES];
+    score += RestrictedPiece * popcount(restricted);
+

     // Bonus for enemy unopposed weak pawns
     if (pos.pieces(Us, ROOK, QUEEN))
         score += WeakUnopposedPawn * pe->weak_unopposed(Them);
     // Bonus for enemy unopposed weak pawns
     if (pos.pieces(Us, ROOK, QUEEN))
         score += WeakUnopposedPawn * pe->weak_unopposed(Them);

diff --git a/src/pawns.cpp b/src/pawns.cpp
index e6d1c9b0e7f48493802dea43356723d97b85b6fb..7d39a4a08bde360f2299f3cc231817e0d749ac07 100644 (file)
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -221,7 +221,7 @@ Value Entry::evaluate_shelter(const Position& pos, Square ksq) {
 
       int d = std::min(f, ~f);
       safety += ShelterStrength[d][ourRank];
 
       int d = std::min(f, ~f);
       safety += ShelterStrength[d][ourRank];

-      safety -= (ourRank && (ourRank == theirRank - 1)) ? 66 * (theirRank == RANK_3) 
+      safety -= (ourRank && (ourRank == theirRank - 1)) ? 66 * (theirRank == RANK_3)

                                                         : UnblockedStorm[d][theirRank];
   }
 
                                                         : UnblockedStorm[d][theirRank];
   }
 

diff --git a/src/search.cpp b/src/search.cpp
index ec443bef92d090b9b92176a4b15fccdd0ababd7d..08bf90f89845673b79b8197c40e17bab2eccc119 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -85,10 +85,10 @@ namespace {
     return d > 17 ? 0 : 29 * d * d + 138 * d - 134;
   }
 
     return d > 17 ? 0 : 29 * d * d + 138 * d - 134;
   }
 

-  // Add a small random component to draw evaluations to keep search dynamic 
+  // Add a small random component to draw evaluations to keep search dynamic

   // and to avoid 3fold-blindness.
   Value value_draw(Depth depth, Thread* thisThread) {
   // and to avoid 3fold-blindness.
   Value value_draw(Depth depth, Thread* thisThread) {

-    return depth < 4 ? VALUE_DRAW 
+    return depth < 4 ? VALUE_DRAW

                      : VALUE_DRAW + Value(2 * (thisThread->nodes.load(std::memory_order_relaxed) % 2) - 1);
   }
 
                      : VALUE_DRAW + Value(2 * (thisThread->nodes.load(std::memory_order_relaxed) % 2) - 1);
   }
 


@@ -599,7 +599,7 @@ namespace {
         if (   Threads.stop.load(std::memory_order_relaxed)
             || pos.is_draw(ss->ply)
             || ss->ply >= MAX_PLY)
         if (   Threads.stop.load(std::memory_order_relaxed)
             || pos.is_draw(ss->ply)
             || ss->ply >= MAX_PLY)

-            return (ss->ply >= MAX_PLY && !inCheck) ? evaluate(pos) 
+            return (ss->ply >= MAX_PLY && !inCheck) ? evaluate(pos)

                                                     : value_draw(depth, pos.this_thread());
 
         // Step 3. Mate distance pruning. Even if we mate at the next move our score
                                                     : value_draw(depth, pos.this_thread());
 
         // Step 3. Mate distance pruning. Even if we mate at the next move our score