WebSVN – Games.Chess Giants – Diff – //engine-crafty/evaluate.c

 #include "chess.h"
+#include "evaluate.h"
 #include "data.h"
-/* last modified 02/23/14 */
+/* last modified 12/31/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Evaluate() is used to evaluate the chess board.  Broadly, it addresses    *
  *   four (4) distinct areas:  (1) material score which is simply a summing of *
  *   piece types multiplied by piece values;  (2) pawn scoring which considers *
  *   placement of pawns and also evaluates passed pawns, particularly in end-  *
  *   game situations;  (3) piece scoring which evaluates the placement of each *
  *   piece as well as things like piece mobility;  (4) king safety which       *
- *   considers the pawn shelter around the king along with material present to *
+ *   considers the pawn shelter around the king and enemy pieces and how close *
- *   facilitate an attack.                                                     *
+ *   they are to assist in a king-side attack.                                 *
  *                                                                             *
  *******************************************************************************
  */
 int Evaluate(TREE * RESTRICT tree, int ply, int wtm, int alpha, int beta) {
   PAWN_HASH_ENTRY *ptable;
   PXOR *pxtable;
-  int score, side, majors, minors, can_win = 3;
+  int score, side, can_win = 3, phase, lscore, cutoff;
+  int full = 0;
+  uint64_t *etable;
-  int phase, lscore, cutoff;
+  uint64_t temp_hashkey;
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
+ *  First thing we do is if -DSKILL was passed in to the     *
+ *  compiler, we burn some time to slow the search down,     *
- *  Initialize.                                                       *
+ *  then we fall into the normal evaluation code.            *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
-  cutoff = (TotalPieces(white, occupied) && TotalPieces(black, occupied))
-      ? KNIGHT_VALUE : ROOK_VALUE;
-  lscore = (wtm) ? Material : -Material;
-  if (lscore + cutoff < alpha || lscore - cutoff > beta)
-    return lscore;
-  tree->dangerous[white] = (Queens(white) && TotalPieces(white, occupied) > 9)
-      || (TotalPieces(white, rook) > 1 && TotalPieces(white, occupied) > 15);
-  tree->dangerous[black] = (Queens(black) && TotalPieces(black, occupied) > 9)
-      || (TotalPieces(black, rook) > 1 && TotalPieces(black, occupied) > 15);
-  tree->evaluations++;
-  tree->score_mg = 0;
-  tree->score_eg = 0;
-  EvaluateMaterial(tree, wtm);
 #if defined(SKILL)
   if (skill < 100) {
     int i, j;
-    for (i = 0; i < burnc[skill / 10]; i++)
+    for (i = 0; i < burnc[skill / 10] && !abort_search; i++)
-      for (j = 1; j < 10; j++)
+      for (j = 1; j < 10 && !abort_search; j++)
         burner[j - 1] = burner[j - 1] * burner[j];
+    if (TimeCheck(tree, 1))
+      abort_search = 1;
+  }
 #endif
-/*
- **********************************************************************
- *                                                                    *
- *  Check for draws due to insufficient material and adjust the score *
- *  as necessary.  This code also handles a special endgame case      *
- *  where one side has only a lone king, and the king has no legal    *
- *  moves.  This has been shown to break a few evaluation terms such  *
- *  as bishop + wrong color rook pawn.  If this case is detected, a   *
- *  drawscore is returned.                                            *
- *                                                                    *
- **********************************************************************
- */
-  if (TotalPieces(white, occupied) < 13 && TotalPieces(black, occupied) < 13)
-    do {
 /*
  ************************************************************
  *                                                          *
+ *  Next we check to see if this position has been handled  *
+ *  before.  If so, we can skip the work saved in the eval  *
+ *  hash table and just return the score found there.  Note *
+ *  that we only store FULL evaluations in the evaluation   *
- *  If neither side has any pieces, and both sides have     *
+ *  hash, if an early (lazy) exit is taken, nothing is      *
- *  non-rookpawns, then either side can win.                *
+ *  stored.                                                 *
  *                                                          *
  ************************************************************
- */
+*/
-      if (TotalPieces(white, occupied) == 0 &&
+  temp_hashkey = (wtm) ? HashKey : ~HashKey;
-          TotalPieces(black, occupied) == 0 && (Pawns(white) & not_rook_pawns
+  etable = eval_hash_table + (temp_hashkey & eval_hash_mask);
+  if (*etable >> 16 == temp_hashkey >> 16) {
-              && Pawns(black) & not_rook_pawns))
+    score = (*etable & 0xffff) - 32768;
-        break;
+    return (wtm) ? score : -score;
+  }
 /*
- ************************************************************
+ *************************************************************
- *                                                          *
+ *                                                           *
+ *  First lazy cutoff attempt.  If the material score is way *
+ *  below alpha or way above beta (way above means so far    *
+ *  above it is very unlikely the positional score can bring *
- *  If one side is an exchange up, but has no pawns, then   *
+ *  the total score back into the alpha / beta window) then  *
+ *  we take what is known as a "lazy evaluation exit" and    *
+ *  avoid the computational cost of a full evaluation in a   *
- *  that side can not possibly win.                         *
+ *  position where one side is way ahead or behind.          *
- *                                                          *
+ *                                                           *
- ************************************************************
+ *************************************************************
  */
-      majors = TotalMajors(white) - TotalMajors(black);
-      if (Abs(majors) == 1) {
-        minors = TotalMinors(white) - TotalMinors(black);
+  cutoff = (TotalPieces(white, occupied) && TotalPieces(black, occupied))
-        if (majors == -minors) {
+      ? KNIGHT_VALUE : ROOK_VALUE;
-          if (TotalPieces(black, pawn) == 0)
-            can_win &= 1;
+  lscore = MaterialSTM(wtm);
-          if (TotalPieces(white, pawn) == 0)
-            can_win &= 2;
+  if (lscore + cutoff < alpha)
-        }
+    return alpha;
-        if (can_win == 0)
+  if (lscore - cutoff > beta)
-          break;
+    return beta;
-      }
 /*
- ************************************************************
+ *************************************************************
+ *                                                           *
+ *  Check for draws where one side seems to be ahead, but    *
+ *  has no actual winning chances.  One simple example is a  *
+ *  king, bishop and rook pawn, with the wrong colored       *
+ *  bishop and the enemy king too close to the promotion     *
+ *  square.                                                  *
- *                                                          *
+ *                                                           *
+ *  The variable "can_win" uses 2 bits.  If White can        *
+ *  actually win in this position, bit 1 is set.  If Black   *
+ *  can actually win in this position, bit 0 is set.  If     *
+ *  both sides can win, both bits are set.  This is used     *
- *  check several special cases, such as bishop + the wrong *
+ *  later to drag the score closer to a draw score if the    *
+ *  side with the better score can't actually win.           *
- *  rook pawn and adjust can_win accordingly.               *
+ *                                                           *
+ *  Note that we only set these bits in minimal material     *
+ *  positions (both sides have < 13 points of material       *
+ *  total).  Otherwise we assume normal scoring should       *
+ *  apply.                                                   *
- *                                                          *
+ *                                                           *
- ************************************************************
+ *************************************************************
  */
+  tree->evaluations++;
+  tree->score_mg = 0;
+  tree->score_eg = 0;
-      if (!EvaluateWinningChances(tree, white, wtm))
+  EvaluateMaterial(tree, wtm);
+  if (TotalPieces(white, occupied) < 13 && TotalPieces(black, occupied) < 13)
-        can_win &= 2;
+    for (side = black; side <= white; side++)
-      if (!EvaluateWinningChances(tree, black, wtm))
+      if (!EvaluateWinningChances(tree, side, wtm))
-        can_win &= 1;
+        can_win ^= (1 << side);
-    } while (0);
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
- *  Determine if this position should be evaluated to force mate      *
+ *  Determine if this position should be evaluated to force  *
- *  (neither side has pawns) or if it should be evaluated normally.   *
+ *  mate (neither side has pawns) or if it should be         *
+ *  evaluated normally.                                      *
- *                                                                    *
+ *                                                           *
- *  Note the special case of no pawns, one side is ahead in total     *
+ *  Note the special case of no pawns, one side is ahead in  *
- *  material, but the game is a hopeless draw.  KRN vs KR is one      *
+ *  total material, but the game is a hopeless draw.  KRN vs *
- *  example.  If EvaluateWinningChances() determines that the side    *
+ *  KR is one example.  If EvaluateWinningChances()          *
+ *  determines that the side with extra material can not     *
- *  with extra material can not win, the score is pulled closer to a  *
+ *  win, the score is pulled closer to a draw although it    *
- *  draw although it can not collapse completely to the drawscore as  *
+ *  can not collapse completely to the drawscore as it is    *
- *  it is possible to lose KRB vs KR if the KR side lets the king get *
+ *  possible to lose KRB vs KR if the KR side lets the king  *
- *  trapped on the edge of the board.                                 *
+ *  get trapped on the edge of the board.                    *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   tree->all_pawns = Pawns(black) | Pawns(white);
   if (!tree->all_pawns) {
     if (TotalPieces(white, occupied) > 3 || TotalPieces(black, occupied) > 3) {
       if (Material > 0)
         EvaluateMate(tree, white);
       else if (Material < 0)
         EvaluateMate(tree, black);
-      if (tree->score_eg > DrawScore(1) && !(can_win & 1))
+      if (tree->score_eg > DrawScore(1) && !(can_win & 2))
-        tree->score_eg = tree->score_eg / 4;
+        tree->score_eg = tree->score_eg / 16;
-      if (tree->score_eg < DrawScore(1) && !(can_win & 2))
+      if (tree->score_eg < DrawScore(1) && !(can_win & 1))
-        tree->score_eg = tree->score_eg / 4;
+        tree->score_eg = tree->score_eg / 16;
 #if defined(SKILL)
       if (skill < 100)
-        tree->score_eg =
+        tree->score_eg = (int) // Pierre-Marie Baty -- added type cast
-            (int) (skill * tree->score_eg / 100 + ((100 -
+            (skill * tree->score_eg / 100 + ((100 -
                 skill) * PAWN_VALUE * (uint64_t) Random32() /
-x100000000ull) / 100); // Pierre-Marie Baty -- added type cast
+x100000000ull) / 100);
 #endif
       return (wtm) ? tree->score_eg : -tree->score_eg;
+    }
+  }
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
- *  Now evaluate pawns.  If the pawn hash signature has not changed   *
+ *  Now evaluate pawns.  If the pawn hash signature has not  *
- *  from the last entry to Evaluate() then we already have everything *
+ *  changed from the last entry to Evaluate() then we        *
- *  we need in the pawn hash entry.  In this case, we do not need to  *
+ *  already have everything we need in the pawn hash entry.  *
+ *  In this case, we do not need to call EvaluatePawns() at  *
- *  call EvaluatePawns() at all.  EvaluatePawns() does all of the     *
+ *  all.  EvaluatePawns() does all of the analysis for       *
- *  analysis for information specifically regarding only pawns.  In   *
+ *  information specifically regarding only pawns.  In many  *
- *  many cases, it merely records the presence/absence of positional  *
+ *  cases, it merely records the presence/absence of         *
- *  pawn features because those features also depends on pieces.      *
+ *  positional pawn features because those features also     *
+ *  depends on pieces.                                       *
+ *                                                           *
- *  Note that anything put into EvaluatePawns() can only consider the *
+ *  Note that anything put into EvaluatePawns() can only     *
- *  placement of pawns.  Kings or other pieces can not influence the  *
+ *  consider the placement of pawns.  Kings or other pieces  *
+ *  can not influence the score because those pieces are not *
- *  score because those pieces are not hashed into the pawn hash      *
+ *  hashed into the pawn hash signature.  Violating this     *
- *  signature.  Violating this principle leads to lots of very        *
+ *  principle leads to lots of very difficult and            *
- *  difficult and challenging debugging problems.                     *
+ *  challenging debugging problems.                          *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   else {
     if (PawnHashKey == tree->pawn_score.key) {
       tree->score_mg += tree->pawn_score.score_mg;
       tree->score_eg += tree->pawn_score.score_eg;
+    }
 /*
- ************************************************************
+ *************************************************************
- *                                                          *
+ *                                                           *
- *  First check to see if this position has been handled    *
+ *  First check to see if this position has been handled     *
- *  before.  If so, we can skip the work saved in the pawn  *
+ *  before.  If so, we can skip the work saved in the pawn   *
- *  hash table.                                             *
+ *  hash table.                                              *
- *                                                          *
+ *                                                           *
- ************************************************************
+ *************************************************************
  */
     else {
       ptable = pawn_hash_table + (PawnHashKey & pawn_hash_mask);
       pxtable = (PXOR *) & (tree->pawn_score);
       tree->pawn_score = *ptable;
-      tree->pawn_score.key ^=
-          pxtable->entry[1] ^ pxtable->entry[2] ^ pxtable->entry[3];
+      tree->pawn_score.key ^= pxtable->entry[1] ^ pxtable->entry[2];
       if (tree->pawn_score.key != PawnHashKey) {
         tree->pawn_score.key = PawnHashKey;
         tree->pawn_score.score_mg = 0;
         tree->pawn_score.score_eg = 0;
         for (side = black; side <= white; side++)
           EvaluatePawns(tree, side);
         ptable->key =
-            pxtable->entry[0] ^ pxtable->entry[1] ^ pxtable->
+            pxtable->entry[0] ^ pxtable->entry[1] ^ pxtable->entry[2];
-            entry[2] ^ pxtable->entry[3];
-        memcpy((char *) ptable + 8, (char *) &(tree->pawn_score) + 8, 20);
+        memcpy((char *) ptable + 8, (char *) &(tree->pawn_score) + 8,
+            sizeof(PAWN_HASH_ENTRY) - 8);
+      }
       tree->score_mg += tree->pawn_score.score_mg;
       tree->score_eg += tree->pawn_score.score_eg;
+    }
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
- *  If there are any passed pawns, first call EvaluatePassedPawns()   *
+ *  If there are any passed pawns, first call                *
- *  to evaluate them.  Then, if one side has a passed pawn and the    *
+ *  EvaluatePassedPawns() to evaluate them.  Then, if one    *
+ *  side has a passed pawn and the other side has no pieces, *
- *  other side has no pieces, call EvaluatePassedPawnRaces() to see   *
+ *  call EvaluatePassedPawnRaces() to see if the passed pawn *
- *  if the passed pawn can be stopped from promoting.                 *
+ *  can be stopped from promoting.                           *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
     if (tree->pawn_score.passed[black] || tree->pawn_score.passed[white]) {
       for (side = black; side <= white; side++)
         if (tree->pawn_score.passed[side])
           EvaluatePassedPawns(tree, side, wtm);
               tree->pawn_score.passed[white]))
         EvaluatePassedPawnRaces(tree, wtm);
+    }
+  }
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
- *  Call EvaluateDevelopment() to evaluate development.  Note that we *
+ *  Call EvaluateCastling() to evaluate castling potential.  *
- *  only do this when either side has not castled at the root.        *
+ *   Note we  only do this when that side has not castled at *
+ *  the root.                                                *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   for (side = black; side <= white; side++)
+    if (Castle(1, side) > 0)
-    EvaluateDevelopment(tree, ply, side);
+      EvaluateCastling(tree, ply, side);
 /*
- **********************************************************************
+ *************************************************************
+ *                                                           *
+ *  The "dangerous" flag simply indicates whether that side  *
+ *  has enough material to whip up a mating attack if the    *
+ *  other side is careless (Q + minor or better, or RR + two *
+ *  minors or better).                                       *
- *                                                                    *
+ *                                                           *
+ *************************************************************
+ */
+  tree->dangerous[white] = (Queens(white) && TotalPieces(white, occupied) > 9)
+      || (TotalPieces(white, rook) > 1 && TotalPieces(white, occupied) > 15);
+  tree->dangerous[black] = (Queens(black) && TotalPieces(black, occupied) > 9)
+      || (TotalPieces(black, rook) > 1 && TotalPieces(black, occupied) > 15);
+/*
+ *************************************************************
+ *                                                           *
+ *  Second lazy evaluation test.  We have computed the large *
+ *  positional scores (except for king safety).  If the      *
+ *  score is too far outside the alpha/beta window, we skip  *
+ *  the piece scoring which is the most expensive of all the *
+ *  evaluation terms, and simply use what we have at this    *
- *  Then evaluate pieces.                                             *
+ *  point.                                                   *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   phase =
       Min(62, TotalPieces(white, occupied) + TotalPieces(black, occupied));
   score = ((tree->score_mg * phase) + (tree->score_eg * (62 - phase))) / 62;
   lscore = (wtm) ? score : -score;
+  int w_mat = (2 * TotalPieces(white, rook)) + TotalPieces(white,
-  cutoff = (tree->dangerous[white]
+      knight) + TotalPieces(white, bishop);
+  int b_mat = (2 * TotalPieces(black, rook)) + TotalPieces(black,
+      knight) + TotalPieces(black, bishop);
+  cutoff = 72 + (w_mat + b_mat) * 8 + abs(w_mat - b_mat) * 16;
-      || tree->dangerous[black]) ? 114 + phase : 102;
+  if (tree->dangerous[white] || tree->dangerous[black])
+    cutoff += 35;
+/*
+ *************************************************************
+ *                                                           *
+ *  Then evaluate pieces if the lazy eval test fails.        *
+ *                                                           *
+ *  Note:  We MUST evaluate kings last, since their scoring  *
+ *  depends on the tropism scores computed by the other      *
+ *  piece evaluators.  Do NOT try to collapse the following  *
+ *  loops into one loop.  That will break things since it    *
+ *  would violate the kings last rule.  More importantly     *
+ *  there is no benefit as the loops below are unrolled by   *
+ *  the compiler anyway.                                     *
+ *                                                           *
+ *************************************************************
+ */
   if (lscore + cutoff > alpha && lscore - cutoff < beta) {
     tree->tropism[white] = 0;
     tree->tropism[black] = 0;
     for (side = black; side <= white; side++)
       EvaluateKnights(tree, side);
     for (side = black; side <= white; side++)
       EvaluateRooks(tree, side);
     for (side = black; side <= white; side++)
       EvaluateQueens(tree, side);
     for (side = black; side <= white; side++)
-      EvaluateKings(tree, ply, side);
+      EvaluateKing(tree, ply, side);
+    full = 1;
+  }
 /*
- **********************************************************************
+ *************************************************************
+ *                                                           *
+ *  Caclulate the final score, which is interpolated between *
+ *  the middlegame score and endgame score based on the      *
+ *  material left on the board.                              *
- *                                                                    *
+ *                                                           *
- *  Adjust the score if the game is drawish but one side appears to   *
+ *  Adjust the score if one side can't win, but the score    *
- *  be significantly better according to the computed score.          *
+ *  actually favors that side significantly.                 *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   score = ((tree->score_mg * phase) + (tree->score_eg * (62 - phase))) / 62;
   score = EvaluateDraws(tree, ply, can_win, score);
 #if defined(SKILL)
   if (skill < 100)
-    score =
+    score = (int) // Pierre-Marie Baty -- added type cast
-        (int) (skill * score / 100 + ((100 -
+        (skill * score / 100 + ((100 -
             skill) * PAWN_VALUE * (uint64_t) Random32() / 0x100000000ull) /
-); // Pierre-Marie Baty -- added type cast
+);
 #endif
+  if (full)
+    *etable = (temp_hashkey & 0xffffffffffff0000) + score + 32768;
   return (wtm) ? score : -score;
+}
-/* last modified 02/23/14 */
+/* last modified 10/19/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *  EvaluateBishops() is used to evaluate bishops.                             *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateBishops(TREE * RESTRICT tree, int side) {
   uint64_t temp, moves;
-  int square, t, mobility;
+  int square, special, i, mobility;
-  int score_eg = 0, score_mg = 0, enemy = Flip(side);
+  int score_eg = 0, score_mg = 0, enemy = Flip(side), tpawns;
 /*
  ************************************************************
  *                                                          *
  *  First, locate each bishop and add in its piece/square   *
- *  score.                                                  *
+ *  table score.                                            *
  *                                                          *
  ************************************************************
  */
   for (temp = Bishops(side); temp; temp &= temp - 1) {
     square = LSB(temp);
  *  driven off by an enemy pawn, and which is supported by  *
  *  a friendly pawn.                                        *
  *                                                          *
  *  If the enemy has NO minor to take this bishop, then     *
  *  increase the bonus.                                     *
- *                                                          *
- *  Note that the bishop_outpost array is overloaded to     *
- *  serve a dual prupose.  A negative value is used to flag *
- *  squares A7 and H7 to test for a trapped bishop.  This   *
- *  is done for speed.                                      *
  *                                                          *
  ************************************************************
  */
-    t = bishop_outpost[side][square];
+    special = bishop_outpost[side][square];
-    if (t) {
+    if (special) {
-      if (t > 0) {
-        if (!(mask_no_pattacks[enemy][square] & Pawns(enemy))) {
+      if (!(mask_pattacks[enemy][square] & Pawns(enemy))) {
-          if (pawn_attacks[enemy][square] & Pawns(side)) {
+        if (pawn_attacks[enemy][square] & Pawns(side)) {
-            t += t / 2;
+          special += special / 2;
-            if (!Knights(enemy) && !(Color(square) & Bishops(enemy)))
+          if (!Knights(enemy) && !(Color(square) & Bishops(enemy)))
-              t += bishop_outpost[side][square];
+            special += bishop_outpost[side][square];
-          }
-          score_eg += t;
-          score_mg += t;
+        }
+        score_eg += special;
+        score_mg += special;
+      }
+    }
 /*
  ************************************************************
  *                                                          *
+ *  Next we count the number of friendly pawns on the same  *
- *  Check to see if the bishop is trapped at a7 or h7 with  *
+ *  color squares as the bishop.  This is a bad thing since *
+ *  it restricts the bishop's ability to move.  We only do  *
- *  a pawn at b6 or g6 that has trapped the bishop.         *
+ *  this if there is only one bishop for this side.         *
  *                                                          *
  ************************************************************
  */
-      else {
-        if (square == sqflip[side][A7]) {
+    if (TotalPieces(side, bishop) == 1) {
-          if (SetMask(sqflip[side][B6]) & Pawns(enemy)) {
-            score_eg -= bishop_trapped;
+      if (dark_squares & SetMask(square))
-            score_mg -= bishop_trapped;
+        tpawns = PopCnt(dark_squares & Pawns(side));
-          }
+      else
-        } else if (square == sqflip[side][H7]) {
-          if (SetMask(sqflip[side][G6]) & Pawns(enemy)) {
+        tpawns = PopCnt(~dark_squares & Pawns(side));
-            score_eg -= bishop_trapped;
+      score_mg -= tpawns * bishop_pawns_on_color[mg];
-            score_mg -= bishop_trapped;
+      score_eg -= tpawns * bishop_pawns_on_color[eg];
-          }
-        }
-      }
+    }
 /*
  ************************************************************
  *                                                          *
- *  Mobility counts the number of squares the piece         *
+ *  Mobility counts the number of squares the bishop        *
- *  attacks, and weighs each square according to            *
+ *  attacks, excluding squares with friendly pieces, and    *
- *  centralization.                                         *
+ *  weighs each square according to centralization.         *
  *                                                          *
  ************************************************************
  */
     mobility = BishopMobility(square, OccupiedSquares);
     if (mobility < 0 && (pawn_attacks[enemy][square] & Pawns(side))
  *  even more valuable against an enemy knight              *
  *                                                          *
  ************************************************************
  */
     if (tree->all_pawns & mask_fgh && tree->all_pawns & mask_abc) {
-      score_mg += bishop_with_wing_pawns[mg];
+      score_mg += bishop_wing_pawns[mg];
-      score_eg += bishop_with_wing_pawns[eg];
+      score_eg += bishop_wing_pawns[eg];
+    }
 /*
  ************************************************************
  *                                                          *
  *  Adjust the tropism count for this piece.                *
  *                                                          *
  ************************************************************
  */
     if (tree->dangerous[side]) {
       moves = king_attacks[KingSQ(enemy)];
-      t = ((bishop_attacks[square] & moves)
+      i = ((bishop_attacks[square] & moves) &&
-          && ((BishopAttacks(square,
-                      OccupiedSquares & ~(Queens(side)))) & moves)) ? 1 :
+          ((BishopAttacks(square, OccupiedSquares & ~Queens(side))) & moves))
-          Distance(square, KingSQ(enemy));
+          ? 1 : Distance(square, KingSQ(enemy));
-      tree->tropism[side] += king_tropism_b[t];
+      tree->tropism[side] += king_tropism_b[i];
+    }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  Add a bonus if this side has a pair of bishops, which   *
+ *  can become very strong in open positions.               *
+ *                                                          *
+ ************************************************************
+ */
+  if (TotalPieces(side, bishop) > 1) {
+    score_mg += bishop_pair[mg];
+    score_eg += bishop_pair[eg];
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
- *   EvaluateDevelopment() is used to encourage the program to develop its     *
+ *   EvaluateCastling() is called when "side" has not castled at the root.     *
- *   pieces before moving its queen.  Standard developmental principles are    *
+ *   Its main purpose is to determine if it has either castled somewhere in    *
- *   applied.  They include:  (1) don't move the queen until minor pieces are  *
+ *   the tree, or else has lost all (or some) castling rights, which reduces   *
- *   developed;  (2) advance the center pawns as soon as possible;  (3) don't  *
- *   move the king unless its a castling move.                                 *
+ *   options significantly.                                                    *
  *                                                                             *
  *******************************************************************************
  */
-void EvaluateDevelopment(TREE * RESTRICT tree, int ply, int side) {
+void EvaluateCastling(TREE * RESTRICT tree, int ply, int side) {
-  int score_mg = 0;
-  int enemy = Flip(side);
+  int enemy = Flip(side), oq, score_mg = 0;;
 /*
  ************************************************************
  *                                                          *
+ *  If the king castled during the search, we are done and  *
+ *  we leave it to EvaluateKing() to figure out how safe it *
- *  First, some "thematic" things, which includes don't     *
+ *  is.  If it has not castled, we give a significant       *
+ *  penalty if the king moves since that loses all castling *
+ *  rights, otherwise we give a smaller penalty for moving  *
+ *  a rook and giving up castling rights to that side of    *
+ *  the board.  The penalty is always increased if the      *
+ *  opponent has a queen since the position is much more    *
- *  block the c-pawn in queen-pawn openings.                *
+ *  dangerous.                                              *
  *                                                          *
  ************************************************************
  */
-  if (!(SetMask(sqflip[side][E4]) & Pawns(side))
-      && SetMask(sqflip[side][D4]) & Pawns(side)
-      && SetMask(sqflip[side][C2]) & Pawns(side)
-      && SetMask(sqflip[side][C3]) & (Knights(side) | Bishops(side)))
-    score_mg -= development_thematic;
-/*
- ************************************************************
- *                                                          *
- *  If the king hasn't moved at the beginning of the        *
- *  search, but it has moved somewhere in the current       *
- *  search path, make *sure* it's a castle move or else     *
- *  penalize the loss of castling privilege.                *
- *                                                          *
- ************************************************************
- */
-  if (Castle(1, side) > 0) {
-    int oq = (Queens(enemy)) ? 3 : 1;
+  oq = (Queens(enemy)) ? 3 : 1;
-    if (Castle(ply, side) != Castle(1, side)) {
+  if (Castle(ply, side) != Castle(1, side)) {
-      if (Castle(ply, side) == 0)
+    if (Castle(ply, side) == 0)
-        score_mg -= oq * development_losing_castle;
+      score_mg -= oq * development_losing_castle;
-      else if (Castle(ply, side) > 0)
+    else if (Castle(ply, side) > 0)
-        score_mg -= (oq * development_losing_castle) / 2;
+      score_mg -= (oq * development_losing_castle) / 2;
-    } else
+  } else
-      score_mg -= oq * development_not_castled;
+    score_mg -= oq * development_not_castled;
-  }
-/*
- ************************************************************
- *                                                          *
- *  Check for an undeveloped knight/rook combo              *
- *                                                          *
- ************************************************************
- */
-  if (PcOnSq(sqflip[side][B1]) == pieces[side][knight]
-      && PcOnSq(sqflip[side][A1]) == pieces[side][rook])
-    score_mg -= undeveloped_piece;
-  if (PcOnSq(sqflip[side][G1]) == pieces[side][knight]
-      && PcOnSq(sqflip[side][H1]) == pieces[side][rook])
-    score_mg -= undeveloped_piece;
   tree->score_mg += sign[side] * score_mg;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateDraws() is used to adjust the score based on whether the side     *
  *   that appears to be better according the computed score can actually win   *
 int EvaluateDraws(TREE * RESTRICT tree, int ply, int can_win, int score) {
 /*
  ************************************************************
  *                                                          *
  *  If the ending has only bishops of opposite colors, the  *
- *  score is pulled closer to a draw.  If the score says    *
+ *  score is pulled closer to a draw.                       *
- *  one side is winning, but that side doesn't have enough  *
- *  material to win, the score is also pulled closer to a   *
- *  draw.                                                   *
  *                                                          *
  *  If this is a pure BOC ending, it is very drawish unless *
  *  one side has at least 4 pawns.  More pawns makes it     *
  *  harder for a bishop and king to stop them all from      *
  *  advancing.                                              *
+ *                                                          *
+ *  If the following are both true:                         *
+ *                                                          *
+ *    black and white have less than a queen left (pieces   *
+ *    only).                                                *
+ *                                                          *
+ *    both have one bishop and they are opposite colored.   *
+ *                                                          *
+ *  then either                                             *
+ *                                                          *
+ *    (a) both have just one bishop, both have less than 4  *
+ *    pawns or one side has only one more pawn than the     *
+ *    other side then score is divided by 2 with draw score *
+ *    added in; or                                          *
+ *                                                          *
+ *    (b) pieces are equal, then score is reduced by 25%    *
+ *    with draw score added in.                             *
  *                                                          *
  ************************************************************
  */
   if (TotalPieces(white, occupied) <= 8 && TotalPieces(black, occupied) <= 8) {
     if (TotalPieces(white, bishop) == 1 && TotalPieces(black, bishop) == 1)
           score = score / 2 + DrawScore(1);
         else if (TotalPieces(white, occupied) == TotalPieces(black, occupied))
           score = 3 * score / 4 + DrawScore(1);
+      }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  Final score adjustment.  If the score says white is     *
+ *  better, but can_win says white can not win, or if the   *
+ *  score says black is better, but can_win says black can  *
+ *  not win, then we divide the score by 16, and then add   *
+ *  in the draw score.  If the can_win says neither side    *
+ *  can win, we just set the score to draw score and exit.  *
+ *                                                          *
+ ************************************************************
+ */
   if (can_win != 3) {
+    if (can_win & 1) {
-    if (can_win != 1 && score > DrawScore(1))
+      if (score > DrawScore(1))
-      score = score / 4 + DrawScore(1);
+        score = score / 16 + DrawScore(1);
+    } else if (can_win & 2) {
-    else if (can_win != 2 && score < DrawScore(1))
+      if (score < DrawScore(1))
-      score = score / 4 + DrawScore(1);
+        score = score / 16 + DrawScore(1);
+    } else
+      score = DrawScore(1);
+  }
 /*
  ************************************************************
  *                                                          *
  *  If we are running into the 50-move rule, then start     *
  *  to its correct value a bit more smoothly.               *
  *                                                          *
  ************************************************************
  */
   if (Reversible(ply) > 80) {
-    int iscale = 101 - Reversible(ply);
+    int closeness = 101 - Reversible(ply);
-    score = DrawScore(1) + score * iscale / 20;
+    score = DrawScore(1) + score * closeness / 20;
+  }
   return score;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateHasOpposition() is used to determine if one king stands in        *
  *   "opposition" to the other.  If the kings are opposed on the same file or  *
   if (!(file_distance & 1) && !(rank_distance & 1))
     return 1;
   return 0;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
- *   EvaluateKings() is used to evaluate kings.                                *
+ *   EvaluateKing() is used to evaluate a king.                                *
  *                                                                             *
  *******************************************************************************
  */
-void EvaluateKings(TREE * RESTRICT tree, int ply, int side) {
+void EvaluateKing(TREE * RESTRICT tree, int ply, int side) {
   int score_eg = 0, score_mg = 0, defects;
   int ksq = KingSQ(side), enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  *  First, check for where the king should be if this is an *
- *  endgame.  Ie with pawns on one wing, the king needs to  *
+ *  endgame.  The basic idea is to centralize unless the    *
- *  be on that wing.  With pawns on both wings, the king    *
- *  belongs in the center.                                  *
+ *  king is needed to deal with a passed enemy pawn.        *
  *                                                          *
  ************************************************************
  */
-  if (tree->all_pawns) {
-    if (tree->all_pawns & mask_efgh && tree->all_pawns & mask_abcd)
-      score_eg += kval_n[side][ksq];
+  score_eg += kval[side][ksq];
-    else if (tree->all_pawns & mask_efgh)
-      score_eg += kval_k[side][ksq];
-    else
-      score_eg += kval_q[side][ksq];
-  }
 /*
  ************************************************************
  *                                                          *
  *  Do castle scoring, if the king has castled, the pawns   *
  *  in front are important.  If not castled yet, the pawns  *
  ************************************************************
  */
   if (tree->dangerous[enemy]) {
     defects = 0;
     if (Castle(ply, side) <= 0) {
-      if (File(ksq) >= FILEE) {
-        if (File(ksq) > FILEE)
+      if (File(ksq) > FILEE)
-          defects = tree->pawn_score.defects_k[side];
+        defects = tree->pawn_score.defects_k[side];
-        else
-          defects = tree->pawn_score.defects_e[side];
-      } else {
-        if (File(ksq) < FILED)
+      else if (File(ksq) < FILED)
-          defects = tree->pawn_score.defects_q[side];
+        defects = tree->pawn_score.defects_q[side];
-        else
+      else
-          defects = tree->pawn_score.defects_d[side];
+        defects = tree->pawn_score.defects_m[side];
-      }
     } else {
       if (Castle(ply, side) == 3)
         defects =
             Min(Min(tree->pawn_score.defects_k[side],
-                tree->pawn_score.defects_e[side]),
+                tree->pawn_score.defects_m[side]),
             tree->pawn_score.defects_q[side]);
       else if (Castle(ply, side) == 1)
         defects =
             Min(tree->pawn_score.defects_k[side],
-            tree->pawn_score.defects_e[side]);
+            tree->pawn_score.defects_m[side]);
       else
         defects =
             Min(tree->pawn_score.defects_q[side],
-            tree->pawn_score.defects_e[side]);
+            tree->pawn_score.defects_m[side]);
       if (defects < 3)
         defects = 3;
+    }
 /*
  ************************************************************
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateKingsFile computes defects for a file, based on whether the file  *
  *   is open or half-open.  If there are friendly pawns still on the file,     *
  *   they are penalized for advancing in front of the king.                    *
  *                                                                             *
  *******************************************************************************
  */
-int EvaluateKingsFile(TREE * RESTRICT tree, int whichfile, int side) {
+int EvaluateKingsFile(TREE * RESTRICT tree, int side, int first, int last) {
-  int defects = 0, file;
-  int enemy = Flip(side);
+  int defects = 0, file, enemy = Flip(side);
-  for (file = whichfile - 1; file <= whichfile + 1; file++)
+  for (file = first; file <= last; file++)
     if (!(file_mask[file] & tree->all_pawns))
       defects += open_file[file];
     else {
       if (!(file_mask[file] & Pawns(enemy)))
         defects += half_open_file[file] / 2;
       else
         defects +=
-            pawn_defects[side][Rank(Advanced(enemy,
+            pawn_defects[side][Rank(MostAdvanced(enemy,
                     file_mask[file] & Pawns(enemy)))];
       if (!(file_mask[file] & Pawns(side)))
         defects += half_open_file[file];
       else if (!(Pawns(side) & SetMask(sqflip[side][A2] + file))) {
         defects++;
+      }
+    }
   return defects;
+}
-/* last modified 02/23/14 */
+/* last modified 10/19/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateKnights() is used to evaluate knights.                            *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateKnights(TREE * RESTRICT tree, int side) {
   uint64_t temp;
-  int square, t, score_eg = 0, score_mg = 0;
+  int square, special, i, score_eg = 0, score_mg = 0, enemy = Flip(side);
-  int enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  *  First fold in centralization score from the piece/      *
  *  If the enemy has NO minor to take this knight, then     *
  *  increase the bonus.                                     *
  *                                                          *
  ************************************************************
  */
-    t = knight_outpost[side][square];
+    special = knight_outpost[side][square];
-    if (t && !(mask_no_pattacks[enemy][square] & Pawns(enemy))) {
+    if (special && !(mask_pattacks[enemy][square] & Pawns(enemy))) {
       if (pawn_attacks[enemy][square] & Pawns(side)) {
-        t += t / 2;
+        special += special / 2;
         if (!Knights(enemy) && !(Color(square) & Bishops(enemy)))
-          t += knight_outpost[side][square];
+          special += knight_outpost[side][square];
+      }
-      score_eg += t;
+      score_eg += special;
-      score_mg += t;
+      score_mg += special;
+    }
-/*
- ************************************************************
- *                                                          *
- *  Mobility counts the number of squares the piece         *
- *  attacks, including squares with friendly pieces, and    *
- *  weighs each square according to centralization.         *
- *                                                          *
- ************************************************************
- */
-    score_mg += knight_mobility_table[square];
-    score_eg += knight_mobility_table[square];
 /*
  ************************************************************
  *                                                          *
  *  Adjust the tropism count for this piece.                *
  *                                                          *
  ************************************************************
  */
     if (tree->dangerous[side]) {
-      t = Distance(square, KingSQ(enemy));
+      i = Distance(square, KingSQ(enemy));
-      tree->tropism[side] += king_tropism_n[t];
+      tree->tropism[side] += king_tropism_n[i];
+    }
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 03/30/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateMate() is used to evaluate positions where neither side has pawns *
  *   and one side has enough material to force checkmate.  It simply trys to   *
  *   where mates are easier to find.                                           *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateMate(TREE * RESTRICT tree, int side) {
-  int mate_score = 0;
-  int enemy = Flip(side);
+  int mate_score = 0, enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
- *  If one side has a bishop+knight and the other side has  *
+ *  If the winning side has a bishop + knight and the other *
- *  no pieces or pawns, then use the special bishop_knight  *
+ *  side has no pieces or pawns, then use the special       *
- *  scoring board for the losing king to force it to the    *
+ *  bishop_knight scoring board for the losing king to      *
- *  right corner for mate.                                  *
+ *  force it to the right corner for mate.                  *
  *                                                          *
  ************************************************************
  */
-  if (!TotalPieces(enemy, occupied) && TotalMinors(side) == 2 &&
+  if (!TotalPieces(enemy, occupied) && TotalPieces(side, bishop) == 1 &&
-      TotalPieces(side, bishop) == 1) {
+      TotalPieces(side, knight) == 1) {
     if (dark_squares & Bishops(side))
       mate_score = b_n_mate_dark_squares[KingSQ(enemy)];
     else
       mate_score = b_n_mate_light_squares[KingSQ(enemy)];
+  }
 /*
  ************************************************************
  *                                                          *
- *  If one side is winning, force the enemy king to the     *
+ *  The winning side has to force the losing king to the    *
  *  edge of the board.                                      *
  *                                                          *
  ************************************************************
  */
-  else {
+  else
     mate_score = mate[KingSQ(enemy)];
+/*
+ ************************************************************
+ *                                                          *
-    mate_score -=
+ *  And for either, it is important to bring the winning    *
+ *  king to help force mate.                                *
-        (Distance(KingSQ(side), KingSQ(enemy)) - 3) * king_king_tropism;
+ *                                                          *
+ ************************************************************
-  }
+ */
-  tree->score_mg += sign[side] * mate_score;
+  mate_score -= Distance(KingSQ(side), KingSQ(enemy)) * king_king_tropism;
   tree->score_eg += sign[side] * mate_score;
+}
-/* last modified 02/23/14 */
+/* last modified 10/19/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *  EvaluateMaterial() is used to evaluate material on the board.  It really   *
  *  accomplishes detecting cases where one side has made a 'bad trade' as the  *
  *  comments below show.                                                       *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateMaterial(TREE * RESTRICT tree, int wtm) {
-  int score_mg, score_eg, majors, minors, imbal;
+  int score_mg, score_eg, majors, minors;
-  static int bon[17] =
-      { 0, 40, 40, 35, 30, 24, 16, 12, 10, 8, 7, 6, 5, 4, 3, 2, 1 };
 /*
- **********************************************************************
+ *************************************************************
- *                                                                    *
+ *                                                           *
- *  We start with the raw Material balance for the current position,  *
+ *  We start with the raw Material balance for the current   *
- *  then adjust this with a small bonus for the side on move.         *
+ *  position, then adjust this with a small bonus for the    *
+ *  side on move.                                            *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
   score_mg = Material + ((wtm) ? wtm_bonus[mg] : -wtm_bonus[mg]);
   score_eg = Material + ((wtm) ? wtm_bonus[eg] : -wtm_bonus[eg]);
 /*
- **********************************************************************
+ *************************************************************
+ *                                                           *
+ *  test 1.  if Majors or Minors are not balanced, then if   *
+ *  one side is only an exchange up or down, we give a       *
+ *  penalty to the side that is an exchange down, but not as *
+ *  big a penalty as the bad trade case below.               *
- *                                                                    *
+ *                                                           *
- *  If Majors or Minors are not balanced, then apply the appropriate  *
+ *  test 2.  if Majors or Minors are not balanced, then if   *
+ *  one side has more piece material points than the other   *
+ *  (using normal piece values of 3, 3, 5, 9 for N, B, R     *
+ *  and Q) then the side that is behind in piece material    *
- *  bonus/penatly from our imbalance table.                           *
+ *  gets a penalty.                                          *
- *                                                                    *
+ *                                                           *
- **********************************************************************
+ *************************************************************
  */
-  majors = 4 + TotalMajors(white) - TotalMajors(black);
-  minors = 4 + TotalMinors(white) - TotalMinors(black);
-  majors = Max(Min(majors, 8), 0);
-  minors = Max(Min(minors, 8), 0);
-  imbal = imbalance[majors][minors];
-  score_mg += imbal;
-  score_eg += imbal;
+  majors =
-/*
- ************************************************************
- *                                                          *
- *  Add a bonus per side if side has a pair of bishops,     *
+      TotalPieces(white, rook) + 2 * TotalPieces(white,
- *  which can become very strong in open positions.         *
- *                                                          *
+      queen) - TotalPieces(black, rook) - 2 * TotalPieces(black, queen);
- ************************************************************
- */
+  minors =
-  if (TotalPieces(white, bishop) > 1) {
+      TotalPieces(white, knight) + TotalPieces(white,
-    score_mg += bishop_pair[mg];
-    score_eg += bishop_pair[eg];
-  }
-  if (TotalPieces(black, bishop) > 1) {
+      bishop) - TotalPieces(black, knight) - TotalPieces(black, bishop);
-    score_mg -= bishop_pair[mg];
-    score_eg -= bishop_pair[eg];
+  if (majors || minors) {
-  }
-/*
- ************************************************************
- *                                                          *
- *  Check for pawns on both wings, which makes a bishop     *
- *  even more valuable against an enemy knight (knight vs.  *
- *  bishop in endgame)                                      *
- *                                                          *
- ************************************************************
- */
-  if (!imbal && !TotalMajors(white) && TotalMinors(white) == 1) {
+    if (Abs(TotalPieces(white, occupied) - TotalPieces(black, occupied)) != 2
-    imbal = bon[(TotalPieces(white, pawn) + TotalPieces(black, pawn))];
+        && TotalPieces(white, occupied) - TotalPieces(black, occupied) != 0) {
-    if (Bishops(white)) {
-      score_mg += imbal;
+      score_mg +=
-      score_eg += imbal;
+          Sign(TotalPieces(white, occupied) - TotalPieces(black,
-    }
-    if (Bishops(black)) {
+              occupied)) * bad_trade;
-      score_mg -= imbal;
+      score_eg +=
+          Sign(TotalPieces(white, occupied) - TotalPieces(black,
-      score_eg -= imbal;
+              occupied)) * bad_trade;
+    }
+  }
   tree->score_mg += score_mg;
   tree->score_eg += score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 11/27/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluatePassedPawns() is used to evaluate passed pawns and the danger     *
- *   they produce.  This code considers pieces as well, so it has been         *
+ *   they produce.  This code considers pieces as well, so it MUST NOT be done *
- *   separated from the normal EvaluatePawns() code that hashes information    *
+ *   in the normal EvaluatePawns() code since that hashes information based    *
- *   based only on pawn positions.                                             *
+ *   only on the position of pawns.                                            *
+ *                                                                             *
+ *   This is a significant rewrite of passed pawn evaluation, with the primary *
+ *   change being to collect the passed pawn scoring into one place, rather    *
+ *   than have it scattered around all over the place.  One example is the old *
+ *   rook_behind_passed_pawn scoring term that was done in rook scoring.  It   *
+ *   is now done here along with other passed pawn terms such as blockaded and *
+ *   the ability to advance or not.                                            *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluatePassedPawns(TREE * RESTRICT tree, int side, int wtm) {
-  uint64_t behind;
+  uint64_t behind, forward, backward, attacked, defended, thispawn;
-  int file, square, score_mg = 0, score_eg = 0;
+  int file, square, score, score_mg = 0, score_eg = 0, next_sq;
-  int pawns, rank;
+  int pawns, rank, mg_base, eg_base, bonus, enemy = Flip(side);
-  int enemy = Flip(side);
+  uint64_t fsliders = Queens(side) | Rooks(side);
+  uint64_t esliders = Queens(enemy) | Rooks(enemy);
 /*
  ************************************************************
  *                                                          *
+ *  Initialize.  The base value "passed_pawn[rank]" is      *
+ *  almost the "square" of the rank.  That got a bit too    *
+ *  big, so a hand-tuned set of values, one per rank,       *
- *  Initialize.                                             *
+ *  proved to be a better value.                            *
  *                                                          *
  ************************************************************
  */
   for (pawns = tree->pawn_score.passed[side]; pawns; pawns &= pawns - 1) {
     file = LSB8Bit(pawns);
-    square = Advanced(side, Pawns(side) & file_mask[file]);
+    thispawn = Pawns(side) & file_mask[file];
+    if (thispawn) {
+      square = MostAdvanced(side, thispawn);
-    rank = rankflip[side][Rank(square)];
+      rank = rankflip[side][Rank(square)];
+      score = passed_pawn[rank];
 /*
  ************************************************************
  *                                                          *
+ *  For endgame only, we add in a bonus based on how close  *
- *  We have located the most advanced pawn on this file,    *
+ *  our king is to this pawn and a penalty based on how     *
- *  which is the only one that will get any sort of bonus.  *
+ *  close the enemy king is.  We also try to keep our king  *
+ *  ahead of the pawn so it can escort it to promotion.  We *
+ *  only do this for passed pawns whose base score value is *
+ *  greater than zero (ie pawns on ranks 4-7 since those    *
+ *  are the ones threatening to become a major problem.)    *
+ *  Also, if you happen to think that a small bonus for a   *
+ *  passed pawn on the 3rd rank might be useful, consider   *
+ *  speed.  If the 3rd rank score is non-zero, that will    *
+ *  trigger a significant amount of work below.  In testing *
+ *  the additional cost more than offset the gain and so it *
+ *  is basically ignored unless rank > 3.                   *
- *  Add in the MG/EG scores first.                          *
+ *                                                          *
  ************************************************************
  */
+      if (score) {
-    score_mg += passed_pawn_value[mg][rank];
+        mg_base = score * passed_pawn_base[mg];
-    score_eg += passed_pawn_value[eg][rank];
+        eg_base = score * passed_pawn_base[eg];
+        next_sq = square + direction[side];
+        eg_base +=
+            Distance(KingSQ(enemy),
+            next_sq) * 2 * score - Distance(KingSQ(side), next_sq) * score;
+        if (rank < RANK7)
+          eg_base -=
+              Distance(KingSQ(side), next_sq + direction[side]) * score / 2;
 /*
  ************************************************************
  *                                                          *
+ *  If the pawn is not blockaded, we need to see whether it *
+ *  can actually advance or not.  Note that this directly   *
- *  Add in a bonus if the passed pawn is connected with     *
+ *  gives a bonus for blockading a passed pawn since the    *
+ *  mobility evaluation below will not be applied when the  *
- *  another pawn for support.                               *
+ *  pawn is blockaded by any piece.                         *
  *                                                          *
- ************************************************************
- */
-    if (mask_pawn_connected[square] & Pawns(side)) {
+ *  Step one is to determine if the squares in front of the *
-      score_mg += passed_pawn_connected[mg][rank];
-      score_eg += passed_pawn_connected[eg][rank];
+ *  pawn are attacked by the enemy.  If not, we add in a    *
-    }
-/*
- ************************************************************
- *                                                          *
+ *  significant score bonus.  If some are attacked, we look *
- *  See if this pawn is either supported by a friendly rook *
+ *  to see if at least the square directly in front of the  *
- *  from behind, or is attacked by an enemy rook from       *
+ *  pawn is not attacked so that we can advance one square, *
- *  behind.                                                 *
+ *  anyway.  This gets a smaller score bonus.               *
  *                                                          *
  ************************************************************
  */
-    if (Rooks(white) | Rooks(black)) {
+        if (!(OccupiedSquares & SetMask(next_sq))) {
-      behind =
+          bonus = 0;
-          ((side) ? minus8dir[square] : plus8dir[square]) &
+          if (Pawns(side) & pawn_attacks[enemy][next_sq])
-          RookAttacks(square, OccupiedSquares);
+            bonus = passed_pawn_free_advance;
-      if (behind) {
+          else {
-        if (behind & Rooks(side)) {
+            attacked = 0;
-          score_mg += rook_behind_passed_pawn[mg][rank];
+            forward = (side) ? plus8dir[square] : minus8dir[square];
-          score_eg += rook_behind_passed_pawn[eg][rank];
+            backward = (side) ? minus8dir[square] : plus8dir[square];
-        } else if (behind & Rooks(enemy)) {
+            if ((behind = backward & esliders) &&
-          score_mg -= rook_behind_passed_pawn[mg][rank];
+                (FileAttacks(square) & behind))
-          score_eg -= rook_behind_passed_pawn[eg][rank];
+              attacked = forward;
-        }
+            else
+              attacked = Attacked(tree, enemy, forward);
-      }
+            if (!attacked)
-    }
+              bonus = passed_pawn_free_advance;
+            else if (!(attacked & SetMask(next_sq)))
+              bonus = passed_pawn_free_advance_1;
 /*
  ************************************************************
  *                                                          *
- *  If the pawn is blockaded by an enemy piece, it cannot   *
+ *  Step two is to determine if the squares in front of the *
- *  move and is therefore not nearly as valuable as if it   *
+ *  pawn are are defended by the friendly side.  If all are *
- *  were free to advance.  If it is blocked by a friendly   *
+ *  defended (such as with a rook or queen behind the pawn  *
- *  piece, it is penalized 1/2 the normal blockade amount   *
+ *  or the king in front and to one side of the pawn, then  *
+ *  we give a bonus (but smaller than the previous cases).  *
- *  to encourage the blocking piece to move so the pawn can *
+ *  As a last resort, if we at least defend the square in   *
- *  advance.                                                *
+ *  front of the pawn, we give a small bonus.               *
  *                                                          *
  ************************************************************
  */
-    if (OccupiedSquares & ((side) ? plus8dir[square] : minus8dir[square])) {
+            if ((behind = backward & fsliders) &&
-      score_eg -= passed_pawn_obstructed[rank];
+                (FileAttacks(square) & behind))
-      if (SetMask(square + direction[side]) & Occupied(enemy)) {
+              defended = forward;
+            else
-        score_mg -= passed_pawn_blockaded_by_enemy[mg][rank];
+              defended = Attacked(tree, side, forward);
-        score_eg -= passed_pawn_blockaded_by_enemy[eg][rank];
+            if (defended == forward)
-      } else if (SetMask(square + direction[side]) & Occupied(side)) {
+              bonus += passed_pawn_defended;
-        score_mg -= passed_pawn_blockaded_by_friendly[mg][rank];
+            else if (defended & SetMask(next_sq))
-        score_eg -= passed_pawn_blockaded_by_friendly[eg][rank];
+              bonus += passed_pawn_defended_1;
-      }
+          }
 /*
  ************************************************************
  *                                                          *
- *  If the pawn has nothing blocking its progress to the    *
+ *  Fold in the bonus for this pawn and move on to the next *
- *  promotion square, then we give a bonus.  If the pawn is *
- *  outside the square of the enemy king, this bonus is     *
+ *  (if there is one).  Note that the bonus computed above  *
- *  increased, because this makes it more difficult for the *
+ *  is multiplied by the base passed pawn score for this    *
- *  opponent to trade pieces which might let this pawn run. *
+ *  particular rank.                                        *
  *                                                          *
  ************************************************************
  */
+          mg_base += bonus * score;
+          eg_base += bonus * score;
-    } else {
+        }
-      if (!(pawn_race[side][wtm][square] & Kings(enemy)))
+        score_mg += mg_base;
-        score_eg += passed_pawn_far_away[rank];
+        score_eg += eg_base;
-      else
+      } else
-        score_eg += passed_pawn_not_far_away[rank];
+        score_eg += 4;
+    }
-/*
- ************************************************************
- *                                                          *
- *  Add in a bonus based on how close the friendly king is, *
- *  and a penalty based on how close the enemy king is.     *
- *  The bonus/penalty is based on how advanced the pawn is  *
- *  to attract the kings toward the most advanced (and most *
- *  dangerous) passed pawn.                                 *
- *                                                          *
- ************************************************************
- */
-    square += direction[side];
-    score_eg -=
-        (Distance(square, KingSQ(side)) - Distance(square,
-            KingSQ(enemy))) * pp_dist_bonus[rank];
+  }
 /*
  ************************************************************
  *                                                          *
+ *  All pawns done, add score to the two evaluation values  *
- *  Check to see if side has an outside passed pawn.        *
+ *  and return.                                             *
  *                                                          *
  ************************************************************
  */
-  if (tree->pawn_score.passed[side]
-      && is_outside[tree->pawn_score.passed[side]]
-      [tree->pawn_score.all[enemy]]) {
-    score_mg += outside_passed[mg];
-    score_eg += outside_passed[eg];
-  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 11/27/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluatePassedPawnRaces() is used to evaluate passed pawns when one       *
  *   side has passed pawns and the other side (or neither) has pieces.  In     *
- *   such a case, the critical question is can the defending king stop the pawn*
+ *   such a case, the critical question is can the defending king stop the     *
- *   from queening or is it too far away?  If only one side has pawns that can *
+ *   pawn from queening or is it too far away?  If only one side has pawns     *
- *   "run" then the situation is simple.  When both sides have pawns that can  *
+ *   that can "run" then the situation is simple.  When both sides have pawns  *
- *   "run" it becomes more complex as it then becomes necessary to see if      *
+ *   that can "run" it becomes more complex as it then becomes necessary to    *
- *   one side can use a forced king move to stop the other side, while the     *
+ *   see if one side can use a forced king move to stop the other side, while  *
- *   other side doesn't have the same ability to stop ours.                    *
+ *   the other side doesn't have the same ability to stop ours.                *
  *                                                                             *
  *   In the case of king and pawn endings with exactly one pawn, the simple    *
  *   evaluation rules are used:  if the king is two squares in front of the    *
  *   pawn then it is a win, if the king is one one square in front with the    *
  *   opposition, then it is a win,  if the king is on the 6th rank with the    *
  *   pawn blocking promotion.                                                  *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluatePassedPawnRaces(TREE * RESTRICT tree, int wtm) {
-  int file, square;
-  int queen_distance;
-  int pawnsq;
-  uint64_t pawns;
+  uint64_t pawns, thispawn;
-  int passed;
-  int side, enemy;
+  int file, square, queen_distance, pawnsq, passed, side, enemy;
   int queener[2] = { 8, 8 };
-  int forced_km[2] = { 0, 0 };
 /*
  ************************************************************
  *                                                          *
  *  Check to see if side has one pawn and neither side has  *
  *  any pieces.  If so, use the simple pawn evaluation      *
           if (sign[side] * Rank(KingSQ(side)) >
               sign[side] * (Rank(pawnsq) - 1 + 2 * side)) {
             tree->score_eg += sign[side] * pawn_can_promote;
             return;
+          }
-          if (Rank(KingSQ(side)) == rankflip[side][RANK6]) {
+          if (Rank(KingSQ(side)) == rank6[side]) {
             tree->score_eg += sign[side] * pawn_can_promote;
             return;
+          }
 /*
  ************************************************************
  */
     if (TotalPieces(enemy, occupied) == 0 && tree->pawn_score.passed[side]) {
       passed = tree->pawn_score.passed[side];
       for (; passed; passed &= passed - 1) {
         file = LSB8Bit(passed);
-        square = Advanced(side, Pawns(side) & file_mask[file]);
+        thispawn = Pawns(side) & file_mask[file];
-        forced_km[enemy] =
+        if (thispawn) {
-            (pawn_race[side][wtm][square] & Kings(enemy)) !=
+          square = MostAdvanced(side, thispawn);
-            (pawn_race[side][Flip(wtm)][square] & Kings(enemy));
-        if (!(pawn_race[side][wtm][square] & Kings(enemy))) {
+          if (!(pawn_race[side][wtm][square] & Kings(enemy))) {
-          queen_distance = Abs(rankflip[side][RANK8] - Rank(square));
+            queen_distance = Abs(rank8[side] - Rank(square));
-          if (Kings(side) & ((side) ? plus8dir[square] : minus8dir[square])) {
+            if (Kings(side) & ((side) ? plus8dir[square] : minus8dir[square])) {
-            if (file == FILEA || file == FILEH)
+              if (file == FILEA || file == FILEH)
-              queen_distance = 99;
+                queen_distance = 99;
-            queen_distance++;
+              queen_distance++;
+            }
+            if (Rank(square) == rank2[side])
+              queen_distance--;
+            if (queen_distance < queener[side])
+              queener[side] = queen_distance;
+          }
-          if (Rank(square) == rankflip[side][RANK2])
-            queen_distance--;
-          if (queen_distance < queener[side])
-            queener[side] = queen_distance;
+        }
+      }
+    }
+  }
-  if (queener[white] == 8 && queener[black] == 8)
-    return;
 /*
  ************************************************************
  *                                                          *
  *  Now that we know which pawns can outrun the kings for   *
- *  each side, we need to do the following:                 *
+ *  each side, we need to do determine if one side queens   *
- *                                                          *
+ *  before the other.  If so, that side wins.  If they      *
- *    (1) If both sides are forced to move their king to    *
+ *  queen at the same time, then we will have to rely on    *
- *        prevent the opponent from promoting, we let the   *
- *        search resolve this as the depth increases.       *
+ *  the search to handle queening with check or queening    *
- *                                                          *
- *    (2) If white can run while black can not, then white  *
- *        wins, or vice-versa.                              *
- *                                                          *
- *    (3) If white queens and black's king can't stop it    *
- *        no matter who moves first, while black has a pawn *
- *        that white can stop if a king move is made        *
+ *  and attacking the opponent's queening square.           *
- *        immediately, then white wins, and vice-versa.     *
- *                                                          *
- *    (4) Other situations are left to the search to        *
- *        resolve.                                          *
  *                                                          *
  ************************************************************
  */
-  if (forced_km[white] & forced_km[black])
-    return;
-  if (queener[white] < 8 && queener[black] == 8) {
+  if (queener[white] < queener[black])
     tree->score_eg += pawn_can_promote + (5 - queener[white]) * 10;
-    return;
-  } else if (queener[black] < 8 && queener[white] == 8) {
+  else if (queener[black] < queener[white])
-    tree->score_eg += -(pawn_can_promote + (5 - queener[black]) * 10);
-    return;
-  }
-  if (queener[white] < queener[black] && forced_km[white]) {
-    tree->score_eg += pawn_can_promote + (5 - queener[white]) * 10;
-    return;
-  } else if (queener[black] < queener[white] && forced_km[white]) {
-    tree->score_eg += -(pawn_can_promote + (5 - queener[black]) * 10);
+    tree->score_eg -= pawn_can_promote + (5 - queener[black]) * 10;
-    return;
-  }
+}
-/* last modified 02/23/14 */
+/* last modified 11/27/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluatePawns() is used to evaluate pawns.  It evaluates pawns for only   *
  *   one side, and fills in the pawn hash entry information.  It requires two  *
  *   calls to evaluate all pawns on the board.  Comments below indicate the    *
  *   particular pawn structure features that are evaluated.                    *
  *                                                                             *
- *   This procedure also fills in information (without scoring) that other     *
+ *   This procedure also flags which pawns are passed, since this is scored in *
+ *   another part of the evaluation because that includes piece information    *
- *   evaluation procedures use, such as which pawns are passed or candidates,  *
+ *   which can not be used here since the pawn hash signature does not include *
+ *   piece information of any kind.                                            *
- *   which pawns are weak, which files are open, and so forth.                 *
+ *                                                                             *
+ *   Note that a pawn is not penalized for two different reasons.  If it is    *
+ *   isolated, it is not backward.  Etc.  This simplifies evaluation tuning    *
+ *   not to mention eliminating the overlap and interaction that was happening *
+ *   previously when multiple penalties could be applied.                      *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluatePawns(TREE * RESTRICT tree, int side) {
-  uint64_t pawns;
+  uint64_t pawns, attackers, defenders;
-  uint64_t temp;
-  uint64_t p_moves[2];
+  uint64_t doubled, supported, connected, passed, backward;
-  int square, file, rank, score_eg = 0, score_mg = 0;
+  int square, file, rank, score_eg = 0, score_mg = 0, enemy = Flip(side);
-  int defenders, attackers, sq;
+  unsigned int isolated, pawn_files = 0;
-  int enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
- *  Initialize.                                             *
+ *  Loop through all pawns for this side.                   *
  *                                                          *
  ************************************************************
  */
-  tree->pawn_score.all[side] = 0;
   tree->pawn_score.passed[side] = 0;
-/*
- ************************************************************
- *                                                          *
- *  First, determine which squares pawns can reach.         *
- *                                                          *
- ************************************************************
- */
-  p_moves[side] = 0;
-  for (pawns = Pawns(side); pawns; pawns &= pawns - 1) {
-    square = LSB(pawns);
-    tree->pawn_score.all[side] |= 1 << File(square);
-    for (sq = square; sq != File(square) + ((side) ? RANK7 << 3 : RANK2 << 3);
-        sq += direction[side]) {
-      p_moves[side] |= SetMask(sq);
-      if (SetMask(sq + direction[side]) & tree->all_pawns)
-        break;
-      defenders =
-          PopCnt(pawn_attacks[enemy][sq + direction[side]] & Pawns(side));
-      attackers =
-          PopCnt(pawn_attacks[side][sq + direction[side]] & Pawns(enemy));
-      if (attackers - defenders > 0)
-        break;
-    }
-  }
-/*
- ************************************************************
- *                                                          *
- *  Loop through all pawns for this side.                   *
- *                                                          *
- ************************************************************
- */
   for (pawns = Pawns(side); pawns; pawns &= pawns - 1) {
     square = LSB(pawns);
     file = File(square);
     rank = rankflip[side][Rank(square)];
+    pawn_files |= 1 << file;
 /*
  ************************************************************
  *                                                          *
  *  Evaluate pawn advances.  Center pawns are encouraged to *
- *  advance, while wing pawns are pretty much neutral.      *
+ *  occupy central squares, edge pawns are penalized on all *
+ *  edge squares to encourage capture toward the center,    *
- *  This is a simple piece/square value.                    *
+ *  the rest are neutral.                                   *
  *                                                          *
  ************************************************************
  */
     score_mg += pval[mg][side][square];
     score_eg += pval[eg][side][square];
 /*
  ************************************************************
  *                                                          *
- *  Evaluate isolated pawns, which  are penalized based on  *
+ *  Evaluate isolated pawns, which are penalized based on   *
- *  the file, with central isolani being worse than when on *
- *  the wings.                                              *
+ *  which file they occupy.                                 *
  *                                                          *
  ************************************************************
  */
-    if (!(mask_pawn_isolated[square] & Pawns(side))) {
+    isolated = !(Pawns(side) & mask_pawn_isolated[square]);
-      score_mg -= pawn_isolated[mg];
+    if (isolated) {
-      score_eg -= pawn_isolated[eg];
-      if (!(Pawns(enemy) & file_mask[file])) {
-        score_mg -= pawn_isolated[mg] / 2;
+      score_mg -= pawn_isolated[mg][file];
-        score_eg -= pawn_isolated[eg] / 2;
+      score_eg -= pawn_isolated[eg][file];
-      }
+    }
 /*
  ************************************************************
  *                                                          *
- *  Evaluate weak pawns.  Weak pawns are evaluated by the   *
+ *  Evaluate unsupported pawns, which provide a target      *
- *  following rules:  (1) if a pawn is defended by a pawn,  *
+ *  since they are undefended by a pawn.  We exclude pawns  *
- *  it isn't weak;  (2) if a pawn is undefended by a pawn   *
- *  and advances one (or two if it hasn't moved yet) ranks  *
- *  and is defended fewer times than it is attacked, it is  *
- *  weak.  Note that the penalty is greater if the pawn is  *
- *  on an open file.  Note that an isolated pawn is just    *
+ *  that are isolated since they have already been given a  *
- *  another case of a weak pawn, since it can never be      *
- *  defended by a pawn.                                     *
- *                                                          *
+ *  penalty.                                                *
- *  First, test the pawn where it sits to determine if it   *
- *  is defended more times than attacked.  If so, it is not *
- *  weak and we are done.  If it is weak where it sits, can *
- *  it advance one square and become not weak.  If so we    *
- *  are again finished with this pawn.  Otherwise we fall   *
- *  into the next test.                                     *
  *                                                          *
  ************************************************************
  */
-    else {
-      do {
-        attackers = 0;
-        defenders = 0;
-        temp =
-            p_moves[side] & ((side) ? plus8dir[square] : minus8dir[square]);
+    supported = Pawns(side) & pawn_attacks[enemy][square];
-        for (; temp; temp &= temp - 1) {
+    if (!isolated && !supported) {
-          sq = LSB(temp);
+      score_mg += pawn_unsupported[mg];
-          defenders = PopCnt(pawn_attacks[enemy][sq] & Pawns(side));
-          attackers = PopCnt(pawn_attacks[side][sq] & Pawns(enemy));
-          if (defenders && defenders >= attackers)
+      score_eg += pawn_unsupported[eg];
-            break;
-        }
+    }
-        if (defenders && defenders >= attackers)
-          break;
 /*
  ************************************************************
  *                                                          *
+ *  Evaluate doubled pawns.  If there are other pawns on    *
- *  If the pawn can be defended by a pawn, and that pawn    *
+ *  this file in front of this pawn, penalize this pawn.    *
+ *  Note that this will NOT penalize both pawns, just the   *
+ *  most rearward one that is really almost worthless.      *
+ *                                                          *
- *  can safely advance to actually defend this pawn, then   *
+ *  The farther apart two doubled pawns (same file) are,    *
+ *  the less weak they are, so the penalty is reduced as    *
- *  this pawn is not weak.                                  *
+ *  this distance increases.                                *
  *                                                          *
  ************************************************************
  */
-        if (!(pawn_attacks[enemy][square] & p_moves[side])) {
+    doubled = Pawns(side) & ((side) ? plus8dir[square] : minus8dir[square]);
-          score_mg -= pawn_weak[mg];
+    if (doubled) {
-          score_eg -= pawn_weak[eg];
+      score_mg -=
-          if (!(Pawns(enemy) & file_mask[file]))
+          pawn_doubled[mg][file] / RankDistance(square, MostAdvanced(side,
-            score_mg -= pawn_weak[mg] / 2;
+              doubled));
-        }
+      score_eg -=
+          pawn_doubled[eg][file] / RankDistance(square, MostAdvanced(side,
-      } while (0);
+              doubled));
+    }
 /*
  ************************************************************
  *                                                          *
- *  Evaluate doubled pawns.  If there are other pawns on    *
+ *  Test the pawn to see if it is connected to a neighbor   *
- *  this file, penalize this pawn.                          *
+ *  which makes it easier to defend.                        *
  *                                                          *
  ************************************************************
  */
-      if (PopCnt(file_mask[file] & Pawns(side)) > 1) {
+    connected = Pawns(side) & mask_pawn_connected[side][square];
+    if (connected) {
-        score_mg -= doubled_pawn_value[mg];
+      score_mg += pawn_connected[rank][file];
-        score_eg -= doubled_pawn_value[eg];
+      score_eg += pawn_connected[rank][file];
-      }
+    }
 /*
  ************************************************************
  *                                                          *
- *  Test the pawn to see if it is connected with a neighbor *
+ *  Flag passed pawns for use later when we finally call    *
- *  which makes it more mobile.                             *
+ *  EvaluatePassedPawns.                                    *
  *                                                          *
  ************************************************************
  */
-      if (mask_pawn_connected[square] & Pawns(side)) {
+    passed = !(Pawns(enemy) & mask_passed[side][square]);
-        score_mg += pawn_connected[mg];
+    if (passed)
-        score_eg += pawn_connected[eg];
+      tree->pawn_score.passed[side] |= 1 << file;
-      }
-    }
 /*
  ************************************************************
  *                                                          *
+ *  Test the pawn to see if it is backward which makes it a *
- *  Discover and flag passed pawns for use later.           *
+ *  target that ties down pieces to defend it.              *
  *                                                          *
  ************************************************************
  */
+    backward = 0;
+    if (!(passed | isolated | connected | (Pawns(side) &
-    if (!(mask_passed[side][square] & Pawns(enemy)))
+                mask_pattacks[side][square]) | (Pawns(enemy) &
+                PawnAttacks(side, square))))
+      backward = Pawns(enemy) & PawnAttacks(side, square + direction[side]);
+    if (backward) {
+      score_mg -= pawn_backward[mg][file];
-      tree->pawn_score.passed[side] |= 1 << file;
+      score_eg -= pawn_backward[eg][file];
+    }
 /*
  ************************************************************
  *                                                          *
- *  Determine if this pawn is a candidate passer, since we  *
+ *  Determine if this pawn is a candidate passed pawn,      *
- *  now know it isn't passed.  A candidate is a pawn on a   *
+ *  which is a pawn on a file with no enemy pawns in front  *
- *  file with no enemy pawns in front of it, and if it      *
+ *  of it, and if it advances until it contacts an enemy    *
- *  advances until it contacts an enemy pawn, and it is     *
+ *  pawn, and it is defended at least as many times as it   *
- *  defended as many times as it is attacked when it        *
+ *  is attacked when it reaches that pawn, then it will end *
- *  reaches that pawn, then all that is left is to see if   *
- *  it is passed when the attacker(s) get removed.          *
+ *  up passed.                                              *
  *                                                          *
  ************************************************************
  */
-    else if (!(file_mask[File(square)] & Pawns(enemy))
+    if (!(passed | backward | isolated) &&
-        && mask_pawn_isolated[square] & Pawns(side)
-        && !(pawn_attacks[side][square] & Pawns(enemy))) {
+        !(Pawns(enemy) & ((side) ? plus8dir[square] : minus8dir[square]))) {
-      attackers = 1;
-      defenders = 0;
-      for (sq = square;
-          sq != File(square) + ((side) ? RANK7 << 3 : RANK2 << 3);
-          sq += direction[side]) {
-        if (SetMask(sq + direction[side]) & tree->all_pawns)
-          break;
-        defenders = PopCnt(pawn_attacks[enemy][sq] & p_moves[side]);
+      defenders = mask_pattacks[side][square + direction[side]] & Pawns(side);
-        attackers = PopCnt(pawn_attacks[side][sq] & Pawns(enemy));
+      attackers = mask_pattacks[enemy][square] & Pawns(enemy);
-        if (attackers)
-          break;
-      }
-      if (attackers <= defenders) {
+      if (PopCnt(defenders) >= PopCnt(attackers)) {
-        if (!(mask_passed[side][sq + direction[side]] & Pawns(enemy))) {
-          score_mg += passed_pawn_candidate[mg][rank];
+        score_mg += passed_pawn_candidate[mg][rank];
-          score_eg += passed_pawn_candidate[eg][rank];
+        score_eg += passed_pawn_candidate[eg][rank];
-        }
+      }
+    }
+  }
 /*
  ************************************************************
  *                                                          *
- *  Evaluate "hidden" passed pawns.  Simple case is a pawn  *
+ *  Give a bonus for distance between left-most pawn and    *
- *  chain (white) at b5, a6, with a black pawn at a7.       *
+ *  right-most pawn.  The idea is that the wider the gap    *
- *  It appears the b-pawn is backward, with a ram at a6/a7  *
+ *  between the pawns, the harder they are for a lone king  *
+ *  to control in the endgame.  Botvinnik referred to this  *
+ *  concept as "trousers" (pants with two legs, the farther *
- *  but this is misleading, because the pawn at a6 is       *
+ *  the legs are apart, the better for the side with those  *
- *  really passed when white plays b6.                      *
+ *  pawns).                                                 *
  *                                                          *
  ************************************************************
  */
-    if (Rank(square) == ((side) ? RANK6 : RANK3)
-        && SetMask(square + direction[side]) & Pawns(enemy)
-        && ((File(square) < FILEH &&
-                SetMask(square + 9 - 16 * side) & Pawns(side)
-                && !(mask_hidden_right[side][File(square)] & Pawns(enemy)))
+  score_eg += pawn_file_width * (MSB8Bit(pawn_files) - LSB8Bit(pawn_files));
-            || (File(square) > FILEA &&
-                SetMask(square + 7 - 16 * side) & Pawns(side)
-                && !(mask_hidden_left[side][File(square)] & Pawns(enemy))))) {
-      score_mg += passed_pawn_hidden[mg];
-      score_eg += passed_pawn_hidden[eg];
-    }
-  }
 /*
  ************************************************************
  *                                                          *
  *  Evaluate king safety.                                   *
  *                                                          *
- *  This uses the function EvaluateKingsFile() which looks  *
+ *  This uses the function EvaluateKingsFile() and looks at *
- *  at four possible positions for the king, either castled *
+ *  three possible positions for the king, either castled   *
  *  kingside, queenside or else standing on the d or e file *
  *  stuck in the middle.  This essentially is about the     *
  *  pawns in front of the king and what kind of "shelter"   *
  *  they provide for the king during the middlegame.        *
  *                                                          *
  ************************************************************
  */
-  tree->pawn_score.defects_q[side] = EvaluateKingsFile(tree, FILEB, side);
+  tree->pawn_score.defects_q[side] =
+      EvaluateKingsFile(tree, side, FILEA, FILEC);
-  tree->pawn_score.defects_d[side] = EvaluateKingsFile(tree, FILED, side);
+  tree->pawn_score.defects_m[side] =
-  tree->pawn_score.defects_e[side] = EvaluateKingsFile(tree, FILEE, side);
+      EvaluateKingsFile(tree, side, FILEC, FILEF);
-  tree->pawn_score.defects_k[side] = EvaluateKingsFile(tree, FILEG, side);
+  tree->pawn_score.defects_k[side] =
+      EvaluateKingsFile(tree, side, FILEF, FILEH);
+/*
+ ************************************************************
+ *                                                          *
+ *  Done.  Add mg/eg scores to final result (sign-corrected *
+ *  so that black = -, white = +) and return.               *
+ *                                                          *
+ ************************************************************
+ */
   tree->pawn_score.score_mg += sign[side] * score_mg;
   tree->pawn_score.score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 10/19/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateQueens() is used to evaluate queens.                              *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateQueens(TREE * RESTRICT tree, int side) {
   uint64_t temp;
-  int square, t, score_mg = 0, score_eg = 0;
+  int square, i, score_mg = 0, score_eg = 0, enemy = Flip(side);
-  int enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  *  First locate each queen and obtain it's centralization  *
  *  Adjust the tropism count for this piece.                *
  *                                                          *
  ************************************************************
  */
     if (tree->dangerous[side]) {
-      t = KingSQ(enemy);
+      i = KingSQ(enemy);
-      tree->tropism[side] += king_tropism_q[Distance(square, t)];
+      tree->tropism[side] += king_tropism_q[Distance(square, i)];
-      t = 8 - (RankDistance(square, t) + FileDistance(square, t));
+      i = 8 - (RankDistance(square, i) + FileDistance(square, i));
-      score_mg += t;
+      score_mg += i;
-      score_eg += t;
+      score_eg += i;
+    }
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 10/19/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateRooks() is used to evaluate rooks.                                *
  *                                                                             *
  *******************************************************************************
  */
 void EvaluateRooks(TREE * RESTRICT tree, int side) {
   uint64_t temp, moves;
-  int square, rank, fRank, file, i, t, mobility;
+  int square, rank, file, i, mobility, score_mg = 0, score_eg = 0;
-  int score_mg = 0, score_eg = 0;
   int enemy = Flip(side);
 /*
  ************************************************************
  *                                                          *
  */
   for (temp = Rooks(side); temp; temp &= temp - 1) {
     square = LSB(temp);
     file = File(square);
     rank = Rank(square);
-    fRank = rankflip[side][rank];
 /*
  ************************************************************
  *                                                          *
  *  Determine if the rook is on an open file or on a half-  *
  *  open file, either of which increases its ability to     *
       } else {
         score_mg += rook_half_open_file[mg];
         score_eg += rook_half_open_file[eg];
+      }
+    }
+/*
+ ************************************************************
+ *                                                          *
+ *  Mobility counts the number of squares the rook attacks, *
+ *  excluding squares with friendly pieces, and weighs each *
+ *  square according to a complex formula that includes     *
+ *  files as well as total number of squares attacked.      *
+ *                                                          *
+ ************************************************************
+ */
+    mobility = RookMobility(square, OccupiedSquares);
+    score_mg += mobility;
+    score_eg += mobility;
 /*
  ************************************************************
  *                                                          *
  *  Check to see if the king has been forced to move and    *
  *  has trapped a rook at a1/b1/g1/h1, if so, then penalize *
- *  the trapped rook to help extricate it.                  *
+ *  the trapped rook to help extricate it.  We only need to *
+ *  check this if the rooks mobility is very low.           *
  *                                                          *
  ************************************************************
  */
-    if (fRank == RANK1) {
-      if (rank == Rank(KingSQ(side))) {
+    if (mobility < 0 && rank == rank1[side] && rank == Rank(KingSQ(side))) {
-        i = File(KingSQ(side));
+      i = File(KingSQ(side));
-        if (i > FILEE) {
+      if (i > FILEE) {
-          if (file > i) {
+        if (file > i) {
-            score_mg -= rook_trapped;
-            score_eg -= rook_trapped;
-          }
-        } else if (i < FILED && file < i) {
-          score_mg -= rook_trapped;
+          score_mg += mobility * 3;
-          score_eg -= rook_trapped;
+          score_eg += mobility * 3;
+        }
+      } else if (i < FILED && file < i) {
+        score_mg += mobility * 3;
+        score_eg += mobility * 3;
+      }
+    }
 /*
  ************************************************************
  *                                                          *
+ *   finally check to see if any rooks are on the 7th rank, *
+ *   with the opponent having pawns on that rank or the     *
+ *   opponent's king being hemmed in on the 7th/8th rank.   *
- *  Determine if the rook is on the 7th rank.  If so the    *
+ *   If so, we give a bonus for the strong rook.  If there  *
+ *   is another rook or queen on the 7th that is connected  *
+ *   with this one, then the positional advantage is even   *
- *  rook exerts a "cramping" effect that is valuable.       *
+ *   stronger.                                              *
  *                                                          *
  ************************************************************
  */
+    else if (rank == rank7[side] && (Rank(KingSQ(enemy)) == rank8[side]
-    else if (fRank == RANK7) {
+            || Pawns(enemy) & rank_mask[rank])) {
       score_mg += rook_on_7th[mg];
       score_eg += rook_on_7th[eg];
+      if (RankAttacks(square) & (Queens(side) | Rooks(side))) {
+        score_mg += rook_connected_7th[mg];
+        score_eg += rook_connected_7th[eg];
+      }
+    }
-/*
- ************************************************************
- *                                                          *
- *  Mobility counts the number of squares the piece         *
- *  attacks, and weighs each square according to a complex  *
- *  formula that includes files as well as total number of  *
- *  squares attacked.                                       *
- *                                                          *
- *  For efficiency, we use a pre-computed mobility score    *
- *  that is accessed just like a magic attack generation.   *
- *                                                          *
- ************************************************************
- */
-    mobility = RookMobility(square, OccupiedSquares);
-    score_mg += mobility;
-    score_eg += mobility;
 /*
  ************************************************************
  *                                                          *
  *  Adjust the tropism count for this piece.                *
  *                                                          *
  ************************************************************
  */
     if (tree->dangerous[side]) {
       moves = king_attacks[KingSQ(enemy)];
-      t = (rook_attacks[square] & moves &&
+      i = (rook_attacks[square] & moves &&
           RookAttacks(square,
-              OccupiedSquares & ~(Queens(side) | (Rooks(side)))) & moves) ? 1
+              OccupiedSquares & ~(Queens(side) | Rooks(side))) & moves) ? 1 :
-          : Distance(square, KingSQ(enemy));
+          Distance(square, KingSQ(enemy));
-      tree->tropism[side] += king_tropism_r[t];
+      tree->tropism[side] += king_tropism_r[i];
+    }
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
-/* last modified 02/23/14 */
+/* last modified 01/03/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   EvaluateWinningChances() is used to determine if one side has reached a   *
  *   position which can not be won, period, even though side may be ahead in   *
  *   material in some way.                                                     *
  *                                                                             *
  *   Return values:                                                            *
- *        0    ->     side on move can not win.                                *
+ *          0    ->     side on move can not win.                              *
- *        1    ->     side on move can win.                                    *
+ *          1    ->     side on move can win.                                  *
  *                                                                             *
  *******************************************************************************
  */
 int EvaluateWinningChances(TREE * RESTRICT tree, int side, int wtm) {
-  int square, ekd, promote;
+  int square, ekd, promote, majors, minors, enemy = Flip(side);
-  int enemy = Flip(side);
+  if (!Pawns(side)) {
 /*
  ************************************************************
  *                                                          *
  *  If side has a piece and no pawn, it can not possibly    *
  *  win.  If side is a piece ahead, the only way it can win *
  *  board (special case to handle KRB vs KR which can be    *
  *  won if the king gets trapped).                          *
  *                                                          *
  ************************************************************
  */
-  if (TotalPieces(side, pawn) == 0) {
     if (TotalPieces(side, occupied) <= 3)
       return 0;
     if (TotalPieces(side, occupied) - TotalPieces(enemy, occupied) <= 3 &&
         mask_not_edge & Kings(enemy))
       return 0;
+/*
+ ************************************************************
+ *                                                          *
+ *  If one side is an exchange up, but has no pawns, then   *
+ *  that side can not possibly win.                         *
+ *                                                          *
+ ************************************************************
+ */
+    majors =
+        TotalPieces(white, rook) + 2 * TotalPieces(white,
+        queen) - TotalPieces(black, rook) - 2 * TotalPieces(black, queen);
+    if (Abs(majors) == 1) {
+      minors =
+          TotalPieces(black, knight) + TotalPieces(black,
+          bishop) - TotalPieces(white, knight) - TotalPieces(white, bishop);
+      if (majors == minors)
+        return 0;
+    }
+  } else {
+/*
+ ************************************************************
+ *                                                          *
+ *  If neither side has any pieces, and both sides have     *
+ *  non-rookpawns, then either side can win.                *
+ *                                                          *
+ ************************************************************
+ */
+    if (TotalPieces(white, occupied) == 0 && TotalPieces(black, occupied) == 0
+        && Pawns(white) & not_rook_pawns && Pawns(black) & not_rook_pawns)
+      return 1;
+  }
 /*
  ************************************************************
  *                                                          *
  *  If "side" has a pawn, then either the pawn had better   *
- *  not be a rook pawn, or else white had better have the   *
+ *  not be a rook pawn, or else side had better have the    *
  *  right color bishop or any other piece, otherwise it is  *
  *  not winnable if the enemy king can get to the queening  *
  *  square first.                                           *
  *                                                          *
  ************************************************************
  */
-  else if (!(Pawns(side) & not_rook_pawns))
+  if (!(Pawns(side) & not_rook_pawns))
     do {
       if (TotalPieces(side, occupied) > 3 || (TotalPieces(side, occupied) == 3
               && Knights(side)))
         continue;
       if (file_mask[FILEA] & Pawns(side) && file_mask[FILEH] & Pawns(side))
         return 0;
     } while (0);
 /*
  ************************************************************
  *                                                          *
- *  Check to see if this is a KRP vs KR or KQP vs KQ type   *
+ *  Check to see if this is a KRP vs KR ending.  If so, and *
- *  ending.  If so, and the losing king is in front of the  *
+ *  the losing king is in front of the passer, then this is *
- *  passer, then this is a drawish ending.                  *
+ *  a drawish ending.                                       *
  *                                                          *
  ************************************************************
  */
   if (TotalPieces(side, pawn) == 1 && TotalPieces(enemy, pawn) == 0 &&
-      ((TotalPieces(side, occupied) == 5 && TotalPieces(enemy, occupied) == 5)
+      TotalPieces(side, occupied) == 5 && TotalPieces(enemy, occupied) == 5) {
-          || (TotalPieces(side, occupied) == 9 &&
-              TotalPieces(enemy, occupied) == 9))) {
     square = LSB(Pawns(side));
     if (FileDistance(KingSQ(enemy), square) <= 1 &&
         InFront(side, Rank(KingSQ(enemy)), Rank(square)))
       return 0;
+  }
  ************************************************************
  */
   if (TotalPieces(side, occupied) == 6 && !Bishops(side)
       && TotalPieces(enemy, occupied) + TotalPieces(enemy, pawn) == 0)
     return 0;
+/*
+ ************************************************************
+ *                                                          *
+ *  If we make it through all the above tests, then "side"  *
+ *  can win so we return 1.                                 *
+ *                                                          *
+ ************************************************************
+ */
   return 1;
+}
+/*
+ *******************************************************************************
+ *                                                                             *
+ *   InitializeKingSafety() is used to initialize the king safety matrix.      *
+ *   This is set so that the matrix, indexed by king safety pawn structure     *
+ *   index and by king safety piece tropism, combines the two indices to       *
+ *   produce a single score.  As either index rises, the king safety score     *
+ *   tracks along, but as both rise, the king safety score rises much more     *
+ *   quickly.                                                                  *
+ *                                                                             *
+ *******************************************************************************
+ */
+void InitializeKingSafety() {
+  int safety, tropism;
+  for (safety = 0; safety < 16; safety++) {
+    for (tropism = 0; tropism < 16; tropism++) {
+      king_safety[safety][tropism] =
+* ((safety_vector[safety] + 100) * (tropism_vector[tropism] +
+) / 100 - 100) / 100;
+    }
+  }
+}

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/evaluate.c – Rev 33 → 108