Two steps slider threats on queen

Allow a potential slider threat from a square currently occupied
by a harmless attacker, just as the recent "knight on queen" patch.
Also from not completely safe squares, use the mobilityArea instead
of excluding all pawns for both SlidersOnQueen and KnightOnQueen

We now compute the potential sliders threat on queen only if opponent
has one queen.

Run as SPRT [0,4] since it is some kind of simplification but maybe
not clearly one.

STC:
http://tests.stockfishchess.org/tests/view/5aa1ddf10ebc590297cb63d8
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 22997 W: 4817 L: 4570 D: 13610

LTC:
http://tests.stockfishchess.org/tests/view/5aa1fe6b0ebc590297cb63e5
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 11926 W: 1891 L: 1705 D: 8330

After this patch is committed, we may try to:

• re-introduce some "threat by queen" bonus to make Stockfish's queen
  more aggressive (attacking aspect)

• introduce a concept of "queen overload" to force the opponent queen
  into passivity and protecting duties (defensive aspect)

• more generally, re-tune the queen mobility array since patches in the
  last three months have affected a lot the location/activity of queens.

Closes https://github.com/official-stockfish/Stockfish/pull/1473

bench: 5788691

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 1e5c588a31eb8a357bdf4e54591e8484cc97f1df..56c975945d13d4713a7648db702446dfd6a8568a 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -172,10 +172,10 @@ namespace {
   const Score MinorBehindPawn   = S( 16,  0);
   const Score PawnlessFlank     = S( 20, 80);
   const Score RookOnPawn        = S(  8, 24);
+  const Score SliderOnQueen     = S( 42, 21);
   const Score ThreatByPawnPush  = S( 47, 26);
   const Score ThreatByRank      = S( 16,  3);
   const Score ThreatBySafePawn  = S(175,168);
-  const Score ThreatOnQueen     = S( 42, 21);
   const Score TrappedBishopA1H1 = S( 50, 50);
   const Score TrappedRook       = S( 92,  0);
   const Score WeakQueen         = S( 50, 10);
@@ -211,7 +211,7 @@ namespace {
 
     // attackedBy[color][piece type] is a bitboard representing all squares
     // attacked by a given color and piece type. Special "piece types" which
-    // are also calculated are QUEEN_DIAGONAL and ALL_PIECES.
+    // is also calculated is ALL_PIECES.
     Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
 
     // attackedBy2[color] are the squares attacked by 2 pieces of a given color,
@@ -297,9 +297,6 @@ namespace {
 
     attackedBy[Us][Pt] = 0;
 
-    if (Pt == QUEEN)
-        attackedBy[Us][QUEEN_DIAGONAL] = 0;
-
     while ((s = *pl++) != SQ_NONE)
     {
         // Find attacked squares, including x-ray attacks for bishops and rooks
@@ -314,9 +311,6 @@ namespace {
         attackedBy[Us][Pt] |= b;
         attackedBy[Us][ALL_PIECES] |= b;
 
-        if (Pt == QUEEN)
-            attackedBy[Us][QUEEN_DIAGONAL] |= b & PseudoAttacks[BISHOP][s];
-
         if (b & kingRing[Them])
         {
             kingAttackersCount[Us]++;
@@ -589,22 +583,20 @@ namespace {
 
     score += ThreatByPawnPush * popcount(b);
 
-    // Bonus for safe slider threats on the next move toward enemy queen
-    safeThreats = ~pos.pieces(Us) & ~attackedBy2[Them] & attackedBy2[Us];
-    b =  (attackedBy[Us][BISHOP] & attackedBy[Them][QUEEN_DIAGONAL])
-       | (attackedBy[Us][ROOK  ] & attackedBy[Them][QUEEN] & ~attackedBy[Them][QUEEN_DIAGONAL]);
-
-    score += ThreatOnQueen * popcount(b & safeThreats);
-
-    // Bonus for knight threats on the next moves against enemy queen
+    // Bonus for threats on the next moves against enemy queen
     if (pos.count<QUEEN>(Them) == 1)
     {
-        b =   pos.attacks_from<KNIGHT>(pos.square<QUEEN>(Them))
-           &  attackedBy[Us][KNIGHT]
-           & ~pos.pieces(Us, PAWN, KING)
-           & ~stronglyProtected;
+        Square s = pos.square<QUEEN>(Them);
+        safeThreats = mobilityArea[Us] & ~stronglyProtected;
+
+        b = attackedBy[Us][KNIGHT] & pos.attacks_from<KNIGHT>(s);
+
+        score += KnightOnQueen * popcount(b & safeThreats);
+
+        b =  (attackedBy[Us][BISHOP] & pos.attacks_from<BISHOP>(s))
+           | (attackedBy[Us][ROOK  ] & pos.attacks_from<ROOK  >(s));
 
-        score += KnightOnQueen * popcount(b);
+        score += SliderOnQueen * popcount(b & safeThreats & attackedBy2[Us]);
     }
 
     if (T)

diff --git a/src/types.h b/src/types.h
index 009a933afcce059e17b55dcca5da86959e65821e..3415a6208abde95b2a5ac7009c856a5c962ed646 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -195,7 +195,6 @@ enum Value : int {
 enum PieceType {
   NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
   ALL_PIECES = 0,
-  QUEEN_DIAGONAL = 7,
   PIECE_TYPE_NB = 8
 };