Space inflate pawns.cpp
authorMarco Costalba <mcostalba@gmail.com>
Tue, 9 Dec 2008 15:46:10 +0000 (16:46 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Tue, 9 Dec 2008 23:14:15 +0000 (00:14 +0100)
Hopefully no functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/pawns.cpp
src/pawns.h

index 6fdd5c130ea57b372d574ee0cd2b6b744d3c412d..965d1ea387f47352fb5cb5773219cd6a01ef0c6d 100644 (file)
@@ -86,14 +86,14 @@ namespace {
 
   // Candidate passed pawn bonus by rank, middle game.
   const Value CandidateMidgameBonus[8] = {
-    Value(0), Value(12), Value(12), Value(20),
-    Value(40), Value(90), Value(0), Value(0)
+    Value( 0), Value(12), Value(12), Value(20),
+    Value(40), Value(90), Value( 0), Value( 0)
   };
 
   // Candidate passed pawn bonus by rank, endgame.
   const Value CandidateEndgameBonus[8] = {
-    Value(0), Value(24), Value(24), Value(40),
-    Value(80), Value(180), Value(0), Value(0)
+    Value( 0), Value(24), Value(24), Value(40),
+    Value(80), Value(180), Value(0), Value( 0)
   };
 
   // Evaluate pawn storms?
@@ -101,25 +101,25 @@ namespace {
 
   // Pawn storm tables for positions with opposite castling:
   const int QStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    -22, -22, -22, -13, -4, 0, 0, 0,
-    -4, -9, -9, -9, -4, 0, 0, 0,
+    0,  0,  0,  0, 0, 0, 0, 0,
+  -22,-22,-22,-13,-4, 0, 0, 0,
+   -4, -9, -9, -9,-4, 0, 0, 0,
     9, 18, 22, 18, 9, 0, 0, 0,
-    22, 31, 31, 22, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0
+   22, 31, 31, 22, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
+    0,  0,  0,  0, 0, 0, 0, 0
   };
   
   const int KStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, -4, -13, -22, -27, -27,
-    0, 0, 0, -4, -9, -13, -18, -18,
-    0, 0, 0, 0, 9, 9, 9, 9,
-    0, 0, 0, 0, 9, 18, 27, 27,
-    0, 0, 0, 0, 9, 27, 40, 36,
-    0, 0, 0, 0, 0, 31, 40, 31,
-    0, 0, 0, 0, 0, 0, 0, 0
+    0, 0, 0, 0,  0,  0,  0,  0,
+    0, 0, 0,-4,-13,-22,-27,-27,
+    0, 0, 0,-4, -9,-13,-18,-18,
+    0, 0, 0, 0,  9,  9,  9,  9,
+    0, 0, 0, 0,  9, 18, 27, 27,
+    0, 0, 0, 0,  9, 27, 40, 36,
+    0, 0, 0, 0,  0, 31, 40, 31,
+    0, 0, 0, 0,  0,  0,  0,  0
   };
 
   // Pawn storm open file bonuses by file:
@@ -141,14 +141,16 @@ namespace {
 /// Constructor
 
 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
+
   size = numOfEntries;
   entries = new PawnInfo[size];
-  if(entries == NULL) {
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
-              << " bytes for pawn hash table." << std::endl;
-    exit(EXIT_FAILURE);
+  if (entries == NULL)
+  {
+      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
+                << " bytes for pawn hash table." << std::endl;
+      exit(EXIT_FAILURE);
   }
-  this->clear();
+  clear();
 }
 
 
@@ -173,6 +175,7 @@ void PawnInfoTable::clear() {
 /// the same pawn structure occurs again.
 
 PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
+
   assert(pos.is_ok());
 
   Key key = pos.get_pawn_key();
@@ -181,207 +184,208 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
 
   // If pi->key matches the position's pawn hash key, it means that we 
   // have analysed this pawn structure before, and we can simply return the
-  // information we found the last time instead of recomputing it:
-  if(pi->key == key)
-    return pi;
+  // information we found the last time instead of recomputing it
+  if (pi->key == key)
+      return pi;
 
-  // Clear the PawnInfo object, and set the key:
+  // Clear the PawnInfo object, and set the key
   pi->clear();
   pi->key = key;
 
   Value mgValue[2] = {Value(0), Value(0)};
   Value egValue[2] = {Value(0), Value(0)};
 
-  // Loop through the pawns for both colors:
-  for(Color us = WHITE; us <= BLACK; us++) {
+  // Loop through the pawns for both colors
+  for (Color us = WHITE; us <= BLACK; us++)
+  {
     Color them = opposite_color(us);
     Bitboard ourPawns = pos.pawns(us);
     Bitboard theirPawns = pos.pawns(them);
     Bitboard pawns = ourPawns;
 
-    // Initialize pawn storm scores by giving bonuses for open files:
-    if(EvaluatePawnStorms)
-      for(File f = FILE_A; f <= FILE_H; f++)
-        if(pos.file_is_half_open(us, f)) {
-          pi->ksStormValue[us] += KStormOpenFileBonus[f];
-          pi->qsStormValue[us] += QStormOpenFileBonus[f];
+    // Initialize pawn storm scores by giving bonuses for open files
+    if (EvaluatePawnStorms)
+        for(File f = FILE_A; f <= FILE_H; f++)
+            if(pos.file_is_half_open(us, f))
+            {
+                pi->ksStormValue[us] += KStormOpenFileBonus[f];
+                pi->qsStormValue[us] += QStormOpenFileBonus[f];
+            }
+
+    // Loop through all pawns of the current color and score each pawn
+    while (pawns)
+    {
+        bool passed, doubled, isolated, backward, chain, candidate;
+        Square s = pop_1st_bit(&pawns);
+        File f = square_file(s);
+        Rank r = square_rank(s);
+
+        assert(pos.piece_on(s) == pawn_of_color(us));
+
+        // The file containing the pawn is not half open
+        pi->halfOpenFiles[us] &= ~(1 << f);
+
+        // Passed, isolated or doubled pawn?
+        passed = pos.pawn_is_passed(us, s);
+        isolated = pos.pawn_is_isolated(us, s);
+        doubled = pos.pawn_is_doubled(us, s);
+
+        if (EvaluatePawnStorms)
+        {
+            // We calculate kingside and queenside pawn storm scores
+            // for both colors. These are used when evaluating middle
+            // game positions with opposite side castling.
+            //
+            // Each pawn is given a base score given by a piece square table
+            // (KStormTable[] or QStormTable[]). This score is increased if
+            // there are enemy pawns on adjacent files in front of the pawn.
+            // This is because we want to be able to open files against the
+            // enemy king, and to avoid blocking the pawn structure (e.g. white
+            // pawns on h6, g5, black pawns on h7, g6, f7).
+
+            // Kingside and queenside pawn storms
+            bool outPost = (outpost_mask(us, s) & theirPawns);
+            bool passed = (passed_pawn_mask(us, s) & theirPawns);
+            int KBonus = KStormTable[relative_square(us, s)];
+            int QBonus = QStormTable[relative_square(us, s)];
+
+            switch (f) {
+
+            case FILE_A:
+                QBonus += passed * QBonus / 4;
+                break;
+
+            case FILE_B:
+                QBonus += passed * (QBonus / 2 + QBonus / 4);
+                break;
+
+            case FILE_C:
+                QBonus += passed * QBonus / 2;
+                break;
+
+            case FILE_F:
+                KBonus += outPost * KBonus / 4;
+                break;
+
+            case FILE_G:
+                KBonus += outPost * (KBonus / 2 + KBonus / 4);
+                break;
+
+            case FILE_H:
+                KBonus += outPost * KBonus / 2;
+                break;
+
+            default:
+                break;
+            }
+            pi->ksStormValue[us] += KBonus;
+            pi->qsStormValue[us] += QBonus;
         }
 
-    // Loop through all pawns of the current color and score each pawn:
-    while(pawns) {
-      Square s = pop_1st_bit(&pawns);
-      File f = square_file(s);
-      Rank r = square_rank(s);
-      bool passed, doubled, isolated, backward, chain, candidate;
-      int bonus;
-
-      assert(pos.piece_on(s) == pawn_of_color(us));
-
-      // The file containing the pawn is not half open:
-      pi->halfOpenFiles[us] &= ~(1 << f);
+        // Member of a pawn chain (but not the backward one)? We could speed up
+        // the test a little by introducing an array of masks indexed by color
+        // and square for doing the test, but because everything is hashed,
+        // it probably won't make any noticable difference.
+        chain =  ourPawns
+               & neighboring_files_bb(f)
+               & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
 
-      // Passed, isolated or doubled pawn?
-      passed = pos.pawn_is_passed(us, s);
-      isolated = pos.pawn_is_isolated(us, s);
-      doubled = pos.pawn_is_doubled(us, s);
-
-      if(EvaluatePawnStorms) {
-        // We calculate kingside and queenside pawn storm
-        // scores for both colors.  These are used when evaluating
-        // middle game positions with opposite side castling.
+        // Test for backward pawn
         //
-        // Each pawn is given a base score given by a piece square table
-        // (KStormTable[] or QStormTable[]).  This score is increased if
-        // there are enemy pawns on adjacent files in front of the pawn.
-        // This is because we want to be able to open files against the
-        // enemy king, and to avoid blocking the pawn structure (e.g. white
-        // pawns on h6, g5, black pawns on h7, g6, f7).
-        
-        // Kingside pawn storms:
-        bonus = KStormTable[relative_square(us, s)];
-        if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
-          switch(f) {
-
-          case FILE_F:
-            bonus += bonus / 4;
-            break;
-
-          case FILE_G:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_H:
-            bonus += bonus / 2;
-            break;
-
-          default:
-            break;
-          }
+        // If the pawn is passed, isolated, or member of a pawn chain
+        // it cannot be backward. If can capture an enemy pawn or if
+        // there are friendly pawns behind on neighboring files it cannot
+        // be backward either.
+        if (   passed
+            || isolated
+            || chain
+            || (pos.pawn_attacks(us, s) & theirPawns)
+            || (ourPawns & in_front_bb(them, r) & neighboring_files_bb(f)))
+            backward = false;
+        else
+        {
+            // We now know that there are no friendly pawns beside or behind this
+            // pawn on neighboring files. We now check whether the pawn is
+            // backward by looking in the forward direction on the neighboring
+            // files, and seeing whether we meet a friendly or an enemy pawn first.
+            Bitboard b;
+            if (us == WHITE)
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
+                backward = (b | (b << 8)) & theirPawns;
+            }
+            else
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
+                backward = (b | (b >> 8)) & theirPawns;
+            }
         }
-        pi->ksStormValue[us] += bonus;
-
-        // Queenside pawn storms:
-        bonus = QStormTable[relative_square(us, s)];
-        if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
-          switch(f) {
 
-          case FILE_A:
-            bonus += bonus / 2;
-            break;
-
-          case FILE_B:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_C:
-            bonus += bonus / 2;
-            break;
+        // Test for candidate passed pawn
+        candidate =    !passed
+                     && pos.file_is_half_open(them, f)
+                     && (  count_1s_max_15(neighboring_files_bb(f) & (in_front_bb(them, r) | rank_bb(r)) & ourPawns)
+                         - count_1s_max_15(neighboring_files_bb(f) &  in_front_bb(us, r)                 & theirPawns)
+                         >= 0);
+
+        // In order to prevent doubled passed pawns from receiving a too big
+        // bonus, only the frontmost passed pawn on each file is considered as
+        // a true passed pawn.
+        if (passed && (ourPawns & squares_in_front_of(us, s)))
+        {
+            // candidate = true;
+            passed = false;
+        }
 
-          default:
-            break;
-          }
+        // Score this pawn
+        Value mv = Value(0), ev = Value(0);
+        if (isolated)
+        {
+            mv -= IsolatedPawnMidgamePenalty[f];
+            ev -= IsolatedPawnEndgamePenalty[f];
+            if (pos.file_is_half_open(them, f))
+            {
+                mv -= IsolatedPawnMidgamePenalty[f] / 2;
+                ev -= IsolatedPawnEndgamePenalty[f] / 2;
+            }
         }
-        pi->qsStormValue[us] += bonus;
-      }
-      
-      // Member of a pawn chain?  We could speed up the test a little by 
-      // introducing an array of masks indexed by color and square for doing
-      // the test, but because everything is hashed, it probably won't make
-      // any noticable difference.
-      chain = (us == WHITE)?
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
-
-
-      // Test for backward pawn.
-
-      // If the pawn is isolated, passed, or member of a pawn chain, it cannot
-      // be backward:
-      if(passed || isolated || chain)
-        backward = false;
-      // If the pawn can capture an enemy pawn, it's not backward:
-      else if(pos.pawn_attacks(us, s) & theirPawns)
-        backward = false;
-      // Check for friendly pawns behind on neighboring files:
-      else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
-        backward = false;
-      else {
-        // We now know that there is no friendly pawns beside or behind this
-        // pawn on neighboring files.  We now check whether the pawn is
-        // backward by looking in the forward direction on the neighboring
-        // files, and seeing whether we meet a friendly or an enemy pawn first.
-        Bitboard b;
-        if(us == WHITE) {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
-          backward = (b | (b << 8)) & theirPawns;
+        if (doubled)
+        {
+            mv -= DoubledPawnMidgamePenalty[f];
+            ev -= DoubledPawnEndgamePenalty[f];
         }
-        else {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
-          backward = (b | (b >> 8)) & theirPawns;
+        if (backward)
+        {
+            mv -= BackwardPawnMidgamePenalty[f];
+            ev -= BackwardPawnEndgamePenalty[f];
+            if (pos.file_is_half_open(them, f))
+            {
+                mv -= BackwardPawnMidgamePenalty[f] / 2;
+                ev -= BackwardPawnEndgamePenalty[f] / 2;
+            }
         }
-      }
-
-      // Test for candidate passed pawn.
-      candidate =
-        (!passed && pos.file_is_half_open(them, f) &&
-         count_1s_max_15(neighboring_files_bb(f)
-                         & (in_front_bb(them, r) | rank_bb(r))
-                         & ourPawns)
-         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
-                           & theirPawns)
-         >= 0);
-
-      // In order to prevent doubled passed pawns from receiving a too big
-      // bonus, only the frontmost passed pawn on each file is considered as
-      // a true passed pawn.
-      if(passed && (ourPawns & squares_in_front_of(us, s))) {
-        // candidate = true;
-        passed = false;
-      }
-
-      // Score this pawn:
-      Value mv = Value(0), ev = Value(0);
-      if(isolated) {
-        mv -= IsolatedPawnMidgamePenalty[f];
-        ev -= IsolatedPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= IsolatedPawnMidgamePenalty[f] / 2;
-          ev -= IsolatedPawnEndgamePenalty[f] / 2;
+        if (chain)
+        {
+            mv += ChainMidgameBonus[f];
+            ev += ChainEndgameBonus[f];
         }
-      }
-      if(doubled)  {
-        mv -= DoubledPawnMidgamePenalty[f];
-        ev -= DoubledPawnEndgamePenalty[f];
-      }
-      if(backward)  {
-        mv -= BackwardPawnMidgamePenalty[f];
-        ev -= BackwardPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= BackwardPawnMidgamePenalty[f] / 2;
-          ev -= BackwardPawnEndgamePenalty[f] / 2;
+        if (candidate)
+        {
+            mv += CandidateMidgameBonus[relative_rank(us, s)];
+            ev += CandidateEndgameBonus[relative_rank(us, s)];
         }
-      }
-      if(chain) {
-        mv += ChainMidgameBonus[f];
-        ev += ChainEndgameBonus[f];
-      }
-      if(candidate) {
-        mv += CandidateMidgameBonus[relative_rank(us, s)];
-        ev += CandidateEndgameBonus[relative_rank(us, s)];
-      }
-
-      mgValue[us] += mv;
-      egValue[us] += ev;
+
+        mgValue[us] += mv;
+        egValue[us] += ev;
         
-      // If the pawn is passed, set the square of the pawn in the passedPawns
-      // bitboard:
-      if(passed)
-        set_bit(&(pi->passedPawns), s);
-    }
-  }
+        // If the pawn is passed, set the square of the pawn in the passedPawns
+        // bitboard
+        if (passed)
+            set_bit(&(pi->passedPawns), s);
+    } // while(pawns)
+  } // for(colors)
 
   pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
   pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
-
   return pi;
 }
index 95575184c9554279c72793b9787e698244e289dd..01a9d6e93c48acd02495b5404f59a585e933ca71 100644 (file)
@@ -120,10 +120,10 @@ inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
 }
 
 inline void PawnInfo::clear() {
-  mgValue = egValue = 0;
-  passedPawns = EmptyBoardBB;
-  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
-  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
+
+  Key k = key;
+  memset(this, 0, sizeof(PawnInfo));
+  key = k;
   halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
 }