X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fevaluate.cpp;h=12329fcdceef82a7872aa2f43af3c8dfd1344e2f;hp=3e396af3032d6e11c2329d15763853f0f4f85b8f;hb=d11426c7779b45a5f91f260ecb9e0c4c1e964e2b;hpb=9d5d69e435443cf768be7fdde76070e776db120f

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 3e396af3..12329fcd 100644
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -52,6 +52,7 @@ namespace {
   int WeightPassedPawnsMidgame   = 0x100;
   int WeightPassedPawnsEndgame   = 0x100;
   int WeightKingSafety[2] = { 0x100, 0x100 };
+  int WeightSpace;
 
   // Internal evaluation weights.  These are applied on top of the evaluation
   // weights read from UCI parameters.  The purpose is to be able to change
@@ -63,8 +64,9 @@ namespace {
   const int WeightPawnStructureEndgameInternal = 0x100;
   const int WeightPassedPawnsMidgameInternal   = 0x100;
   const int WeightPassedPawnsEndgameInternal   = 0x100;
-  const int WeightKingSafetyInternal           = 0x100;
-  const int WeightKingOppSafetyInternal        = 0x100;
+  const int WeightKingSafetyInternal           = 0x110;
+  const int WeightKingOppSafetyInternal        = 0x110;
+  const int WeightSpaceInternal                = 0x30;
 
   // Visually better to define tables constants
   typedef Value V;
@@ -203,6 +205,19 @@ namespace {
     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
   };
 
+  // The SpaceMask[color] contains area of the board which is consdered by
+  // the space evaluation.  In the middle game, each side is given a bonus
+  // based on how many squares inside this area are safe and available for
+  // friendly minor pieces.
+  const Bitboard SpaceMask[2] = {
+    (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
+    (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
+    (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
+    (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
+    (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
+    (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
+  };
+
   /// King safety constants and variables.  The king safety scores are taken
   /// from the array SafetyTable[].  Various little "meta-bonuses" measuring
   /// the strength of the attack are added up into an integer, which is used
@@ -215,8 +230,7 @@ namespace {
   const int KnightAttackWeight = 2;
 
   // Bonuses for safe checks for each piece type.
-  int QueenContactCheckBonus = 4;
-  int RookContactCheckBonus  = 2;
+  int QueenContactCheckBonus = 3;
   int QueenCheckBonus        = 2;
   int RookCheckBonus         = 1;
   int BishopCheckBonus       = 1;
@@ -246,18 +260,18 @@ namespace {
   // in init_safety().
   Value SafetyTable[100];
 
-  // Pawn and material hash tables, indexed by the current thread id:
+  // Pawn and material hash tables, indexed by the current thread id
   PawnInfoTable *PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
   MaterialInfoTable *MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
-  // Sizes of pawn and material hash tables:
+  // Sizes of pawn and material hash tables
   const int PawnTableSize = 16384;
   const int MaterialTableSize = 1024;
 
   // Array which gives the number of nonzero bits in an 8-bit integer:
   uint8_t BitCount8Bit[256];
 
-  // Function prototypes:
+  // Function prototypes
   void evaluate_knight(const Position &p, Square s, Color us, EvalInfo &ei);
   void evaluate_bishop(const Position &p, Square s, Color us, EvalInfo &ei);
   void evaluate_rook(const Position &p, Square s, Color us, EvalInfo &ei);
@@ -270,6 +284,7 @@ namespace {
   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
                                     EvalInfo &ei);
 
+  void evaluate_space(const Position &p, Color us, EvalInfo &ei);
   inline Value apply_weight(Value v, int w);
   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 
@@ -407,6 +422,13 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
 
         ei.mgValue += ei.pi->kingside_storm_value(WHITE)
                     - ei.pi->queenside_storm_value(BLACK);
+
+    // Evaluate space for both sides
+    if (ei.mi->space_weight() > 0)
+    {
+        evaluate_space(pos, WHITE, ei);
+        evaluate_space(pos, BLACK, ei);
+    }
   }
 
   // Mobility
@@ -414,7 +436,7 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
 
   // If we don't already have an unusual scale factor, check for opposite
-  // colored bishop endgames, and use a lower scale for those:
+  // colored bishop endgames, and use a lower scale for those
   if (   phase < PHASE_MIDGAME
       && pos.opposite_colored_bishops()
       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
@@ -527,6 +549,7 @@ void read_weights(Color us) {
 
   WeightKingSafety[us]   = weight_option("Cowardice", WeightKingSafetyInternal);
   WeightKingSafety[them] = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
+  WeightSpace = weight_option("Space", WeightSpaceInternal);
 
   init_safety();
 }
@@ -613,7 +636,6 @@ namespace {
 
   void evaluate_rook(const Position &p, Square s, Color us, EvalInfo &ei) {
 
-    //Bitboard b = p.rook_attacks(s);
     Bitboard b = rook_attacks_bb(s, p.occupied_squares() & ~p.rooks_and_queens(us));
     ei.attackedBy[us][ROOK] |= b;
 
@@ -744,14 +766,14 @@ namespace {
       Bitboard occ = p.occupied_squares(), b, b2;
 
       // Initialize the 'attackUnits' variable, which is used later on as an
-      // index to the SafetyTable[] array.  The initial is based on the number
-      // and types of the attacking pieces, the number of attacked and
+      // index to the SafetyTable[] array.  The initial value is based on the
+      // number and types of the attacking pieces, the number of attacked and
       // undefended squares around the king, the square of the king, and the
       // quality of the pawn shelter.
       int attackUnits =
             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
           + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
-          + InitKingDanger[relative_square(us, s)] - shelter / 32;
+          + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
 
       // Analyse safe queen contact checks
       b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
@@ -797,25 +819,8 @@ namespace {
           }
         }
       }
-      // Analyse safe rook contact checks:
-      if (RookContactCheckBonus)
-      {
-          b = undefended & ei.attacked_by(them, ROOK) & ~p.pieces_of_color(them);
-          if (b)
-          {
-              Bitboard attackedByOthers =
-                    ei.attacked_by(them, PAWN)   | ei.attacked_by(them, KNIGHT)
-                  | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, QUEEN);
-
-              b &= attackedByOthers;
-              if (b)
-              {
-                  int count = count_1s_max_15(b);
-                  attackUnits += (RookContactCheckBonus * count * (sente? 2 : 1));
-              }
-          }
-      }
-      // Analyse safe distance checks:
+
+      // Analyse safe distance checks
       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
       {
           b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
@@ -931,6 +936,13 @@ namespace {
           b2 = squares_in_front_of(us, s);
           b3 = b2 & ei.attacked_by(them);
           b4 = b2 & ei.attacked_by(us);
+
+          // If there is an enemy rook or queen attacking the pawn from behind,
+          // add all X-ray attacks by the rook or queen.
+          if(bit_is_set(ei.attacked_by(them,ROOK)|ei.attacked_by(them,QUEEN),s)
+             && squares_behind(us, s) & pos.rooks_and_queens(them))
+            b3 = b2;
+
           if((b2 & pos.pieces_of_color(them)) == EmptyBoardBB) {
             // There are no enemy pieces in the pawn's path!  Are any of the
             // squares in the pawn's path attacked by the enemy?
@@ -1101,14 +1113,54 @@ namespace {
   }
 
 
-  // apply_weight applies an evaluation weight to a value.
+  // evaluate_space() computes the space evaluation for a given side. The
+  // space evaluation is a simple bonus based on the number of safe squares
+  // available for minor pieces on the central four files on ranks 2--4. Safe
+  // squares one, two or three squares behind a friendly pawn are counted
+  // twice. Finally, the space bonus is scaled by a weight taken from the
+  // material hash table.
+
+  void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
+
+    Color them = opposite_color(us);
+
+    // Find the safe squares for our pieces inside the area defined by
+    // SpaceMask[us].  A square is unsafe it is attacked by an enemy
+    // pawn, or if it is undefended and attacked by an enemy piece.
+
+    Bitboard safeSquares =
+      SpaceMask[us] & ~pos.pawns(us) & ~ei.attacked_by(them, PAWN)
+      & ~(~ei.attacked_by(us) & ei.attacked_by(them));
+
+    // Find all squares which are at most three squares behind some friendly
+    // pawn.
+    Bitboard behindFriendlyPawns = pos.pawns(us);
+    if(us == WHITE) {
+      behindFriendlyPawns |= (behindFriendlyPawns >> 8);
+      behindFriendlyPawns |= (behindFriendlyPawns >> 16);
+    }
+    else {
+      behindFriendlyPawns |= (behindFriendlyPawns << 8);
+      behindFriendlyPawns |= (behindFriendlyPawns << 16);
+    }
+
+    int space =
+      count_1s_max_15(safeSquares)
+      + count_1s_max_15(behindFriendlyPawns & safeSquares);
+
+    ei.mgValue += Sign[us] *
+      apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
+  }
+
+
+  // apply_weight() applies an evaluation weight to a value
 
   inline Value apply_weight(Value v, int w) {
     return (v*w) / 0x100;
   }
 
 
-  // scale_by_game_phase interpolates between a middle game and an endgame
+  // scale_by_game_phase() interpolates between a middle game and an endgame
   // score, based on game phase.  It also scales the return value by a
   // ScaleFactor array.
 
@@ -1156,7 +1208,6 @@ namespace {
   void init_safety() {
 
     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
-    RookContactCheckBonus  = get_option_value_int("Rook Contact Check Bonus");
     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");