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

 #include "evaluate.h"
 #include "data.h"
-/* last modified 12/31/15 */
+/* last modified 08/03/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Evaluate() is used to evaluate the chess board.  Broadly, it addresses    *
  *   four (4) distinct areas:  (1) material score which is simply a summing of *
  */
 int Evaluate(TREE * RESTRICT tree, int ply, int wtm, int alpha, int beta) {
   PAWN_HASH_ENTRY *ptable;
   PXOR *pxtable;
   int score, side, can_win = 3, phase, lscore, cutoff;
-  int full = 0;
-  uint64_t *etable;
-  uint64_t temp_hashkey;
 /*
  *************************************************************
  *                                                           *
  *  First thing we do is if -DSKILL was passed in to the     *
         burner[j - 1] = burner[j - 1] * burner[j];
     if (TimeCheck(tree, 1))
       abort_search = 1;
+  }
 #endif
-/*
- ************************************************************
- *                                                          *
- *  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   *
- *  hash, if an early (lazy) exit is taken, nothing is      *
- *  stored.                                                 *
- *                                                          *
- ************************************************************
-*/
-  temp_hashkey = (wtm) ? HashKey : ~HashKey;
-  etable = eval_hash_table + (temp_hashkey & eval_hash_mask);
-  if (*etable >> 16 == temp_hashkey >> 16) {
-    score = (*etable & 0xffff) - 32768;
-    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    *
         tree->score_eg = tree->score_eg / 16;
       if (tree->score_eg < DrawScore(1) && !(can_win & 1))
         tree->score_eg = tree->score_eg / 16;
 #if defined(SKILL)
       if (skill < 100)
-        tree->score_eg = (int) // Pierre-Marie Baty -- added type cast
+        tree->score_eg =
-            (skill * tree->score_eg / 100 + ((100 -
+            skill * tree->score_eg / 100 + ((100 -
                 skill) * PAWN_VALUE * (uint64_t) Random32() /
-x100000000ull) / 100);
+x100000000ull) / 100;
 #endif
       return (wtm) ? tree->score_eg : -tree->score_eg;
+    }
+  }
 /*
  */
   if (lscore + cutoff > alpha && lscore - cutoff < beta) {
     tree->tropism[white] = 0;
     tree->tropism[black] = 0;
     for (side = black; side <= white; side++)
+      if (Knights(side))
-      EvaluateKnights(tree, side);
+        EvaluateKnights(tree, side);
     for (side = black; side <= white; side++)
+      if (Bishops(side))
-      EvaluateBishops(tree, side);
+        EvaluateBishops(tree, side);
     for (side = black; side <= white; side++)
+      if (Rooks(side))
-      EvaluateRooks(tree, side);
+        EvaluateRooks(tree, side);
     for (side = black; side <= white; side++)
+      if (Queens(side))
-      EvaluateQueens(tree, side);
+        EvaluateQueens(tree, side);
     for (side = black; side <= white; side++)
       EvaluateKing(tree, ply, side);
-    full = 1;
+  }
 /*
  *************************************************************
  *                                                           *
  *  Caclulate the final score, which is interpolated between *
  */
   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 = (int) // Pierre-Marie Baty -- added type cast
+    score =
-        (skill * score / 100 + ((100 -
+        skill * score / 100 + ((100 -
             skill) * PAWN_VALUE * (uint64_t) Random32() / 0x100000000ull) /
-);
+;
 #endif
-  if (full)
-    *etable = (temp_hashkey & 0xffffffffffff0000) + score + 32768;
   return (wtm) ? score : -score;
+}
 /* last modified 10/19/15 */
 /*
     if (mobility < 0 && (pawn_attacks[enemy][square] & Pawns(side))
         && (File(square) == FILEA || File(square) == FILEH))
       mobility -= 8;
     score_mg += mobility;
     score_eg += mobility;
-/*
- ************************************************************
- *                                                          *
- *  Check for pawns on both wings, which makes a bishop     *
- *  even more valuable against an enemy knight              *
- *                                                          *
- ************************************************************
- */
-    if (tree->all_pawns & mask_fgh && tree->all_pawns & mask_abc) {
-      score_mg += bishop_wing_pawns[mg];
-      score_eg += bishop_wing_pawns[eg];
-    }
 /*
  ************************************************************
  *                                                          *
  *  Adjust the tropism count for this piece.                *
  *                                                          *
  ************************************************************
  */
   if (TotalPieces(side, bishop) > 1) {
     score_mg += bishop_pair[mg];
     score_eg += bishop_pair[eg];
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  Check for pawns on both wings, which makes a bishop     *
+ *  even more valuable against an enemy knight              *
+ *                                                          *
+ ************************************************************
+ */
+  else {
+    if (tree->all_pawns & mask_fgh && tree->all_pawns & mask_abc) {
+      score_mg += bishop_wing_pawns[mg];
+      score_eg += bishop_wing_pawns[eg];
+    }
+  }
   tree->score_mg += sign[side] * score_mg;
   tree->score_eg += sign[side] * score_eg;
+}
  *  edge squares to encourage capture toward the center,    *
  *  the rest are neutral.                                   *
  *                                                          *
  ************************************************************
  */
-    score_mg += pval[mg][side][square];
+    score_mg += pval[side][square];
-    score_eg += pval[eg][side][square];
 /*
  ************************************************************
  *                                                          *
  *  Evaluate isolated pawns, which are penalized based on   *
  *  which file they occupy.                                 *
  *                                                          *
  ************************************************************
  */
     connected = Pawns(side) & mask_pawn_connected[side][square];
     if (connected) {
-      score_mg += pawn_connected[rank][file];
+      score_mg += pawn_connected[mg][rank][file];
-      score_eg += pawn_connected[rank][file];
+      score_eg += pawn_connected[eg][rank][file];
+    }
 /*
  ************************************************************
  *                                                          *
  *  Flag passed pawns for use later when we finally call    *

Subversion Repositories Games.Chess Giants

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