X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fevaluate.cpp;h=fd0ef5b22cd558f9873560edc1e45b93b3e0eef1;hb=d9b920acfbc5c8fdc362111d00c962ad654595e6;hp=104a0a6bed5b3ab54018c68bcc641fdfe81e1cbe;hpb=53f882ff1a95d444dd9b3cd0eb39d493d0e6280e;p=stockfish

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 104a0a6b..fd0ef5b2 100644
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -241,6 +241,40 @@ namespace {
   // Bonus for having a mate threat, initialized from UCI options
   int MateThreatBonus;
 
+  // ThreatBonus[][] contains bonus according to which piece type
+  // attacks which one.
+  const Value MidgameThreatBonus[8][8] = {
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0),V(18), V(0),V(37), V(55), V(55), V(0), V(0) }, // KNIGHT attacks
+      { V(0),V(18),V(37), V(0), V(55), V(55), V(0), V(0) }, // BISHOP attacks
+      { V(0), V(9),V(27),V(27),  V(0), V(37), V(0), V(0) }, // ROOK attacks
+      { V(0),V(27),V(27),V(27), V(27),  V(0), V(0), V(0) }, // QUEEN attacks
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }  // not used
+  };
+
+  const Value EndgameThreatBonus[8][8] = {
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0),V(37), V(0),V(47), V(97), V(97), V(0), V(0) }, // KNIGHT attacks
+      { V(0),V(37),V(47), V(0), V(97), V(97), V(0), V(0) }, // BISHOP attacks
+      { V(0),V(27),V(47),V(47),  V(0), V(47), V(0), V(0) }, // ROOK attacks
+      { V(0),V(37),V(37),V(37), V(37),  V(0), V(0), V(0) }, // QUEEN attacks
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }, // not used
+      { V(0), V(0), V(0), V(0),  V(0),  V(0), V(0), V(0) }  // not used
+  };
+
+  // ThreatedByPawnPenalty[] contains a penalty according to which piece
+  // type is attacked by an enemy pawn.
+  const Value MidgameThreatedByPawnPenalty[8] = {
+    V(0), V(0), V(56), V(56), V(76), V(86), V(0), V(0)
+  };
+
+  const Value EndgameThreatedByPawnPenalty[8] = {
+    V(0), V(0), V(70), V(70), V(99), V(118), V(0), V(0)
+  };
+
   // InitKingDanger[] contains bonuses based on the position of the defending
   // king.
   const int InitKingDanger[64] = {
@@ -276,6 +310,9 @@ namespace {
   template<Color Us, bool HasPopCnt>
   void evaluate_king(const Position& pos, EvalInfo& ei);
 
+  template<Color Us>
+  void evaluate_threats(const Position& pos, EvalInfo& ei);
+
   template<Color Us, bool HasPopCnt>
   void evaluate_space(const Position& pos, EvalInfo& ei);
 
@@ -365,6 +402,10 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   evaluate_king<WHITE, HasPopCnt>(pos, ei);
   evaluate_king<BLACK, HasPopCnt>(pos, ei);
 
+  // Evaluate tactical threats, we need full attack info
+  evaluate_threats<WHITE>(pos, ei);
+  evaluate_threats<BLACK>(pos, ei);
+
   // Evaluate passed pawns. We evaluate passed pawns for both sides at once,
   // because we need to know which side promotes first in positions where
   // both sides have an unstoppable passed pawn. To be called after all attacks
@@ -531,13 +572,12 @@ namespace {
   // evaluate_mobility() computes mobility and attacks for every piece
 
   template<PieceType Piece, Color Us, bool HasPopCnt>
-  int evaluate_mobility(const Position& pos, Bitboard b, EvalInfo& ei) {
+  int evaluate_mobility(Bitboard b, Bitboard mob_area, EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
-    static const int lastIndex[] = { 0, 0, 8, 15, 15, 31 };
 
     // Update attack info
     ei.attackedBy[Us][Piece] |= b;
@@ -552,22 +592,9 @@ namespace {
             ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
     }
 
-    // Remove squares protected by enemy pawns or occupied by our pieces
-    b &= ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
-
-    // The squares occupied by enemy pieces (not defended by pawns) will be
-    // counted two times instead of one. The shift (almost) guarantees that
-    // intersection of the shifted value with b is zero so that after or-ing
-    // the count of 1s bits is increased by the number of affected squares.
-    b |= Us == WHITE ? ((b & pos.pieces_of_color(Them)) >> 1)
-                     : ((b & pos.pieces_of_color(Them)) << 1);
-
     // Mobility
-    int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b)
-                              : count_1s<HasPopCnt>(b));
-
-    if (mob > lastIndex[Piece])
-        mob = lastIndex[Piece];
+    int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(b & mob_area)
+                              : count_1s<HasPopCnt>(b & mob_area));
 
     ei.mgMobility += Sign[Us] * MgBonus[Piece][mob];
     ei.egMobility += Sign[Us] * EgBonus[Piece][mob];
@@ -614,6 +641,9 @@ namespace {
     const Color Them = (Us == WHITE ? BLACK : WHITE);
     const Square* ptr = pos.piece_list_begin(Us, Piece);
 
+    // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
+    const Bitboard mob_area = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
+
     while ((s = *ptr++) != SQ_NONE)
     {
         if (Piece == KNIGHT || Piece == QUEEN)
@@ -626,7 +656,15 @@ namespace {
             assert(false);
 
         // Attacks and mobility
-        mob = evaluate_mobility<Piece, Us, HasPopCnt>(pos, b, ei);
+        mob = evaluate_mobility<Piece, Us, HasPopCnt>(b, mob_area, ei);
+
+        // Decrease score if we are attacked by an enemy pawn. Remaining part
+        // of threat evaluation must be done later when we have full attack info.
+        if (bit_is_set(ei.attackedBy[Them][PAWN], s))
+        {
+            ei.mgValue -= Sign[Us] * MidgameThreatedByPawnPenalty[Piece];
+            ei.egValue -= Sign[Us] * EndgameThreatedByPawnPenalty[Piece];
+        }
 
         // Bishop and knight outposts squares
         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
@@ -703,6 +741,44 @@ namespace {
   }
 
 
+  // evaluate_threats<>() assigns bonuses according to the type of attacking piece
+  // and the type of attacked one.
+
+  template<Color Us>
+  void evaluate_threats(const Position& pos, EvalInfo& ei) {
+
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+    Bitboard b;
+    Value mgBonus = Value(0);
+    Value egBonus = Value(0);
+
+    // Enemy pieces not defended by a pawn and under our attack
+    Bitboard weakEnemies =  pos.pieces_of_color(Them)
+                          & ~ei.attackedBy[Them][PAWN]
+                          & ei.attackedBy[Us][0];
+    if (!weakEnemies)
+        return;
+
+    // Add bonus according to type of attacked enemy pieces and to the
+    // type of attacking piece, from knights to queens. Kings are not
+    // considered because are already special handled in king evaluation.
+    for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
+    {
+        b = ei.attackedBy[Us][pt1] & weakEnemies;
+        if (b)
+            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
+                if (b & pos.pieces(pt2))
+                {
+                    mgBonus += MidgameThreatBonus[pt1][pt2];
+                    egBonus += EndgameThreatBonus[pt1][pt2];
+                }
+    }
+    ei.mgValue += Sign[Us] * mgBonus;
+    ei.egValue += Sign[Us] * egBonus;
+  }
+
+
   // evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
   // pieces of a given color.