X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fpawns.cpp;h=861c421f172dcc80f8865322e208948d8c4d1a1b;hb=1fd020a8ba98a95775639cdebd19e3592b767eb3;hp=3d99bfc68645a3e327554eef3fc2e067755a1297;hpb=3e4dfb49a747be902d25ae06783f98ba29fb5030;p=stockfish

diff --git a/src/pawns.cpp b/src/pawns.cpp
index 3d99bfc6..861c421f 100644
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -30,40 +30,38 @@ namespace {
   #define S(mg, eg) make_score(mg, eg)
 
   // Doubled pawn penalty by opposed flag and file
-  const Score DoubledPawnPenalty[2][FILE_NB] = {
+  const Score Doubled[2][FILE_NB] = {
   { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
     S(23, 48), S(23, 48), S(20, 48), S(13, 43) },
   { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
     S(23, 48), S(23, 48), S(20, 48), S(13, 43) }};
 
   // Isolated pawn penalty by opposed flag and file
-  const Score IsolatedPawnPenalty[2][FILE_NB] = {
+  const Score Isolated[2][FILE_NB] = {
   { S(37, 45), S(54, 52), S(60, 52), S(60, 52),
     S(60, 52), S(60, 52), S(54, 52), S(37, 45) },
   { S(25, 30), S(36, 35), S(40, 35), S(40, 35),
     S(40, 35), S(40, 35), S(36, 35), S(25, 30) }};
 
   // Backward pawn penalty by opposed flag and file
-  const Score BackwardPawnPenalty[2][FILE_NB] = {
+  const Score Backward[2][FILE_NB] = {
   { S(30, 42), S(43, 46), S(49, 46), S(49, 46),
     S(49, 46), S(49, 46), S(43, 46), S(30, 42) },
   { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
     S(33, 31), S(33, 31), S(29, 31), S(20, 28) }};
 
   // Pawn chain membership bonus by file
-  const Score ChainBonus[FILE_NB] = {
+  const Score ChainMember[FILE_NB] = {
     S(11,-1), S(13,-1), S(13,-1), S(14,-1),
     S(14,-1), S(13,-1), S(13,-1), S(11,-1)
   };
 
   // Candidate passed pawn bonus by rank
-  const Score CandidateBonus[RANK_NB] = {
+  const Score CandidatePassed[RANK_NB] = {
     S( 0, 0), S( 6, 13), S(6,13), S(14,29),
     S(34,68), S(83,166), S(0, 0), S( 0, 0)
   };
 
-  const Score PawnStructureWeight = S(233, 201);
-
   // Weakness of our pawn shelter in front of the king indexed by [king pawn][rank]
   const Value ShelterWeakness[2][RANK_NB] =
   { { V(141), V(0), V(38), V(102), V(128), V(141), V(141) },
@@ -86,6 +84,7 @@ namespace {
                        Bitboard theirPawns, Pawns::Entry* e) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
+    const Square  Up = (Us == WHITE ? DELTA_N : DELTA_S);
 
     Bitboard b;
     Square s;
@@ -103,8 +102,8 @@ namespace {
         f = file_of(s);
         r = rank_of(s);
 
-        // This file cannot be half open
-        e->halfOpenFiles[Us] &= ~(1 << f);
+        // This file cannot be semi-open
+        e->semiopenFiles[Us] &= ~(1 << f);
 
         // Our rank plus previous one. Used for chain detection
         b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
@@ -140,7 +139,7 @@ namespace {
 
             // The friendly pawn needs to be at least two ranks closer than the
             // enemy pawn in order to help the potentially backward pawn advance.
-            backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
+            backward = (b | shift_bb<Up>(b)) & theirPawns;
         }
 
         assert(opposed | passed | (attack_span_mask(Us, s) & theirPawns));
@@ -161,26 +160,26 @@ namespace {
 
         // Score this pawn
         if (isolated)
-            value -= IsolatedPawnPenalty[opposed][f];
+            value -= Isolated[opposed][f];
 
         if (doubled)
-            value -= DoubledPawnPenalty[opposed][f];
+            value -= Doubled[opposed][f];
 
         if (backward)
-            value -= BackwardPawnPenalty[opposed][f];
+            value -= Backward[opposed][f];
 
         if (chain)
-            value += ChainBonus[f];
+            value += ChainMember[f];
 
         if (candidate)
-            value += CandidateBonus[relative_rank(Us, s)];
+            value += CandidatePassed[relative_rank(Us, s)];
     }
 
-    e->pawnsOnWhiteSquaresCount[Us]   = popcount<Max15>(ourPawns   & WhiteSquares);
-    e->pawnsOnWhiteSquaresCount[Them] = popcount<Max15>(theirPawns & WhiteSquares);
+    e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & BlackSquares);
+    e->pawnsOnSquares[Us][WHITE] = pos.piece_count(Us, PAWN) - e->pawnsOnSquares[Us][BLACK];
 
-    e->pawnsOnBlackSquaresCount[Us]   = popcount<Max15>(ourPawns   & BlackSquares);
-    e->pawnsOnBlackSquaresCount[Them] = popcount<Max15>(theirPawns & BlackSquares); 
+    e->pawnsOnSquares[Them][BLACK] = popcount<Max15>(theirPawns & BlackSquares);
+    e->pawnsOnSquares[Them][WHITE] = pos.piece_count(Them, PAWN) - e->pawnsOnSquares[Them][BLACK];
 
     return value;
   }
@@ -206,18 +205,15 @@ Entry* probe(const Position& pos, Table& entries) {
   e->key = key;
   e->passedPawns[WHITE] = e->passedPawns[BLACK] = 0;
   e->kingSquares[WHITE] = e->kingSquares[BLACK] = SQ_NONE;
-  e->halfOpenFiles[WHITE] = e->halfOpenFiles[BLACK] = 0xFF;
+  e->semiopenFiles[WHITE] = e->semiopenFiles[BLACK] = 0xFF;
 
   Bitboard wPawns = pos.pieces(WHITE, PAWN);
   Bitboard bPawns = pos.pieces(BLACK, PAWN);
-  e->pawnAttacks[WHITE] = ((wPawns & ~FileHBB) << 9) | ((wPawns & ~FileABB) << 7);
-  e->pawnAttacks[BLACK] = ((bPawns & ~FileHBB) >> 7) | ((bPawns & ~FileABB) >> 9);
+  e->pawnAttacks[WHITE] = shift_bb<DELTA_NE>(wPawns) | shift_bb<DELTA_NW>(wPawns);
+  e->pawnAttacks[BLACK] = shift_bb<DELTA_SE>(bPawns) | shift_bb<DELTA_SW>(bPawns);
 
   e->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, e)
             - evaluate_pawns<BLACK>(pos, bPawns, wPawns, e);
-
-  e->value = apply_weight(e->value, PawnStructureWeight);
-
   return e;
 }