X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=d54794bbc8712205a066cf977da4f692b3cb4c02;hp=978f6622d3f142a178cf2c92a59ea07bdb9d76bd;hb=7733dadfd7c8781e3bde3cc4e21751fa44ab6ed8;hpb=cf4c28ff86ac76c1d04701e2aa88493d31643db6

diff --git a/src/search.cpp b/src/search.cpp
index 978f6622..d54794bb 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -52,7 +52,7 @@ using std::endl;
 
 namespace {
 
-  /// Types
+  // Types
   enum NodeType { NonPV, PV };
 
   // Set to true to force running with one thread.
@@ -76,12 +76,9 @@ namespace {
     int active_threads() const { return ActiveThreads; }
     void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
     void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
-    void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }
 
     void resetNodeCounters();
-    void resetBetaCounters();
     int64_t nodes_searched() const;
-    void get_beta_counters(Color us, int64_t& our, int64_t& their) const;
     bool available_thread_exists(int master) const;
     bool thread_is_available(int slave, int master) const;
     bool thread_should_stop(int threadID) const;
@@ -117,7 +114,7 @@ namespace {
 
   struct RootMove {
 
-    RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
+    RootMove() : mp_score(0), nodes(0) {}
 
     // RootMove::operator<() is the comparison function used when
     // sorting the moves. A move m1 is considered to be better
@@ -125,12 +122,13 @@ namespace {
     // have equal score but m1 has the higher beta cut-off count.
     bool operator<(const RootMove& m) const {
 
-        return score != m.score ? score < m.score : theirBeta <= m.theirBeta;
+        return score != m.score ? score < m.score : mp_score <= m.mp_score;
     }
 
     Move move;
     Value score;
-    int64_t nodes, cumulativeNodes, ourBeta, theirBeta;
+    int mp_score;
+    int64_t nodes;
     Move pv[PLY_MAX_PLUS_2];
   };
 
@@ -143,49 +141,57 @@ namespace {
   public:
     RootMoveList(Position& pos, Move searchMoves[]);
 
+    Move move(int moveNum) const { return moves[moveNum].move; }
+    Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
     int move_count() const { return count; }
-    Move get_move(int moveNum) const { return moves[moveNum].move; }
-    Value get_move_score(int moveNum) const { return moves[moveNum].score; }
+    Value move_score(int moveNum) const { return moves[moveNum].score; }
+    int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; }
+    void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
     void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
-    Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
-    int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
 
-    void set_move_nodes(int moveNum, int64_t nodes);
-    void set_beta_counters(int moveNum, int64_t our, int64_t their);
     void set_move_pv(int moveNum, const Move pv[]);
+    void score_moves(const Position& pos);
     void sort();
     void sort_multipv(int n);
 
   private:
-    static const int MaxRootMoves = 500;
-    RootMove moves[MaxRootMoves];
+    RootMove moves[MOVES_MAX];
     int count;
   };
 
 
+  // When formatting a move for std::cout we must know if we are in Chess960
+  // or not. To keep using the handy operator<<() on the move the trick is to
+  // embed this flag in the stream itself. Function-like named enum set960 is
+  // used as a custom manipulator and the stream internal general-purpose array,
+  // accessed through ios_base::iword(), is used to pass the flag to the move's
+  // operator<<() that will use it to properly format castling moves.
+  enum set960 {};
+
+  std::ostream& operator<< (std::ostream& os, const set960& m) {
+
+    os.iword(0) = int(m);
+    return os;
+  }
+
+
   /// Adjustments
 
   // Step 6. Razoring
 
   // Maximum depth for razoring
-  const Depth RazorDepth = 4 * OnePly;
+  const Depth RazorDepth = 4 * ONE_PLY;
 
   // Dynamic razoring margin based on depth
   inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
 
-  // Step 8. Null move search with verification search
-
-  // Null move margin. A null move search will not be done if the static
-  // evaluation of the position is more than NullMoveMargin below beta.
-  const Value NullMoveMargin = Value(0x200);
-
   // Maximum depth for use of dynamic threat detection when null move fails low
-  const Depth ThreatDepth = 5 * OnePly;
+  const Depth ThreatDepth = 5 * ONE_PLY;
 
   // Step 9. Internal iterative deepening
 
   // Minimum depth for use of internal iterative deepening
-  const Depth IIDDepth[2] = { 8 * OnePly /* non-PV */, 5 * OnePly /* PV */};
+  const Depth IIDDepth[2] = { 8 * ONE_PLY /* non-PV */, 5 * ONE_PLY /* PV */};
 
   // At Non-PV nodes we do an internal iterative deepening search
   // when the static evaluation is bigger then beta - IIDMargin.
@@ -199,7 +205,7 @@ namespace {
   Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2];
 
   // Minimum depth for use of singular extension
-  const Depth SingularExtensionDepth[2] = { 8 * OnePly /* non-PV */, 6 * OnePly /* PV */};
+  const Depth SingularExtensionDepth[2] = { 8 * ONE_PLY /* non-PV */, 6 * ONE_PLY /* PV */};
 
   // If the TT move is at least SingularExtensionMargin better then the
   // remaining ones we will extend it.
@@ -211,11 +217,11 @@ namespace {
   const Value FutilityMarginQS = Value(0x80);
 
   // Futility lookup tables (initialized at startup) and their getter functions
-  int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
+  Value FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
   int FutilityMoveCountArray[32]; // [depth]
 
-  inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * OnePly ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); }
-  inline int futility_move_count(Depth d) { return d < 16 * OnePly ? FutilityMoveCountArray[d] : 512; }
+  inline Value futility_margin(Depth d, int mn) { return d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE; }
+  inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; }
 
   // Step 14. Reduced search
 
@@ -228,7 +234,7 @@ namespace {
   // Common adjustments
 
   // Search depth at iteration 1
-  const Depth InitialDepth = OnePly;
+  const Depth InitialDepth = ONE_PLY;
 
   // Easy move margin. An easy move candidate must be at least this much
   // better than the second best move.
@@ -338,8 +344,8 @@ int64_t nodes_searched() { return ThreadsMgr.nodes_searched(); }
 
 void init_search() {
 
-  int d;  // depth (OnePly == 2)
-  int hd; // half depth (OnePly == 1)
+  int d;  // depth (ONE_PLY == 2)
+  int hd; // half depth (ONE_PLY == 1)
   int mc; // moveCount
 
   // Init reductions array
@@ -347,17 +353,17 @@ void init_search() {
   {
       double    pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5;
       double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25;
-      ReductionMatrix[PV][hd][mc]    = (int8_t) (   pvRed >= 1.0 ? floor(   pvRed * int(OnePly)) : 0);
-      ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(OnePly)) : 0);
+      ReductionMatrix[PV][hd][mc]    = (int8_t) (   pvRed >= 1.0 ? floor(   pvRed * int(ONE_PLY)) : 0);
+      ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
   }
 
   // Init futility margins array
   for (d = 1; d < 16; d++) for (mc = 0; mc < 64; mc++)
-      FutilityMarginsMatrix[d][mc] = 112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45;
+      FutilityMarginsMatrix[d][mc] = Value(112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45);
 
   // Init futility move count array
   for (d = 0; d < 32; d++)
-      FutilityMoveCountArray[d] = 3 + (1 << (3 * d / 8));
+      FutilityMoveCountArray[d] = int(3.001 + 0.25 * pow(d, 2.0));
 }
 
 
@@ -366,7 +372,7 @@ void init_search() {
 
 int perft(Position& pos, Depth depth)
 {
-    MoveStack mlist[256];
+    MoveStack mlist[MOVES_MAX];
     StateInfo st;
     Move m;
     int sum = 0;
@@ -376,7 +382,7 @@ int perft(Position& pos, Depth depth)
 
     // If we are at the last ply we don't need to do and undo
     // the moves, just to count them.
-    if (depth <= OnePly)
+    if (depth <= ONE_PLY)
         return int(last - mlist);
 
     // Loop through all legal moves
@@ -385,7 +391,7 @@ int perft(Position& pos, Depth depth)
     {
         m = cur->move;
         pos.do_move(m, st, ci, pos.move_is_check(m, ci));
-        sum += perft(pos, depth - OnePly);
+        sum += perft(pos, depth - ONE_PLY);
         pos.undo_move(m);
     }
     return sum;
@@ -447,10 +453,9 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
   MateThreatExtension[1]    = Depth(get_option_value_int("Mate Threat Extension (PV nodes)"));
   MateThreatExtension[0]    = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)"));
 
-  MinimumSplitDepth       = get_option_value_int("Minimum Split Depth") * OnePly;
+  MinimumSplitDepth       = get_option_value_int("Minimum Split Depth") * ONE_PLY;
   MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
   MultiPV                 = get_option_value_int("MultiPV");
-  Chess960                = get_option_value_bool("UCI_Chess960");
   UseLogFile              = get_option_value_bool("Use Search Log");
 
   if (UseLogFile)
@@ -536,26 +541,27 @@ namespace {
 
     // Print RootMoveList startup scoring to the standard output,
     // so to output information also for iteration 1.
-    cout << "info depth " << 1
+    cout << set960(p.is_chess960()) // Is enough to set once at the beginning
+         << "info depth " << 1
          << "\ninfo depth " << 1
-         << " score " << value_to_uci(rml.get_move_score(0))
+         << " score " << value_to_uci(rml.move_score(0))
          << " time " << current_search_time()
          << " nodes " << ThreadsMgr.nodes_searched()
          << " nps " << nps()
-         << " pv " << rml.get_move(0) << "\n";
+         << " pv " << rml.move(0) << "\n";
 
     // Initialize
     TT.new_search();
     H.clear();
     init_ss_array(ss, PLY_MAX_PLUS_2);
     pv[0] = pv[1] = MOVE_NONE;
-    ValueByIteration[1] = rml.get_move_score(0);
+    ValueByIteration[1] = rml.move_score(0);
     Iteration = 1;
 
     // Is one move significantly better than others after initial scoring ?
     if (   rml.move_count() == 1
-        || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin)
-        EasyMove = rml.get_move(0);
+        || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin)
+        EasyMove = rml.move(0);
 
     // Iterative deepening loop
     while (Iteration < PLY_MAX)
@@ -616,15 +622,15 @@ namespace {
             int64_t nodes = ThreadsMgr.nodes_searched();
             if (   Iteration >= 8
                 && EasyMove == pv[0]
-                && (  (   rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
+                && (  (   rml.move_nodes(0) > (nodes * 85) / 100
                        && current_search_time() > TimeMgr.available_time() / 16)
-                    ||(   rml.get_move_cumulative_nodes(0) > (nodes * 98) / 100
+                    ||(   rml.move_nodes(0) > (nodes * 98) / 100
                        && current_search_time() > TimeMgr.available_time() / 32)))
                 stopSearch = true;
 
             // Add some extra time if the best move has changed during the last two iterations
             if (Iteration > 5 && Iteration <= 50)
-                TimeMgr.pv_unstability(BestMoveChangesByIteration[Iteration],
+                TimeMgr.pv_instability(BestMoveChangesByIteration[Iteration],
                                        BestMoveChangesByIteration[Iteration-1]);
 
             // Stop search if most of MaxSearchTime is consumed at the end of the
@@ -659,7 +665,7 @@ namespace {
     // Print the best move and the ponder move to the standard output
     if (pv[0] == MOVE_NONE)
     {
-        pv[0] = rml.get_move(0);
+        pv[0] = rml.move(0);
         pv[1] = MOVE_NONE;
     }
 
@@ -690,7 +696,7 @@ namespace {
                 << move_to_san(p, pv[1]) // Works also with MOVE_NONE
                 << endl;
     }
-    return rml.get_move_score(0);
+    return rml.move_score(0);
   }
 
 
@@ -701,13 +707,12 @@ namespace {
 
   Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
 
-    EvalInfo ei;
     StateInfo st;
     CheckInfo ci(pos);
     int64_t nodes;
     Move move;
     Depth depth, ext, newDepth;
-    Value value, alpha, beta;
+    Value value, evalMargin, alpha, beta;
     bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
     int researchCountFH, researchCountFL;
 
@@ -715,7 +720,7 @@ namespace {
     alpha = *alphaPtr;
     beta = *betaPtr;
     isCheck = pos.is_check();
-    depth = (Iteration - 2) * OnePly + InitialDepth;
+    depth = (Iteration - 2) * ONE_PLY + InitialDepth;
 
     // Step 1. Initialize node (polling is omitted at root)
     ss->currentMove = ss->bestMove = MOVE_NONE;
@@ -726,7 +731,7 @@ namespace {
 
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
-    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ei);
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -739,6 +744,7 @@ namespace {
     while (1)
     {
         // Sort the moves before to (re)search
+        rml.score_moves(pos);
         rml.sort();
 
         // Step 10. Loop through all moves in the root move list
@@ -750,12 +756,9 @@ namespace {
             // Save the current node count before the move is searched
             nodes = ThreadsMgr.nodes_searched();
 
-            // Reset beta cut-off counters
-            ThreadsMgr.resetBetaCounters();
-
             // Pick the next root move, and print the move and the move number to
             // the standard output.
-            move = ss->currentMove = rml.get_move(i);
+            move = ss->currentMove = rml.move(i);
 
             if (current_search_time() >= 1000)
                 cout << "info currmove " << move
@@ -798,7 +801,7 @@ namespace {
                     // if the move fails high will be re-searched at full depth
                     bool doFullDepthSearch = true;
 
-                    if (    depth >= 3 * OnePly
+                    if (    depth >= 3 * ONE_PLY
                         && !dangerous
                         && !captureOrPromotion
                         && !move_is_castle(move))
@@ -806,7 +809,7 @@ namespace {
                         ss->reduction = reduction<PV>(depth, i - MultiPV + 2);
                         if (ss->reduction)
                         {
-                            assert(newDepth-ss->reduction >= OnePly);
+                            assert(newDepth-ss->reduction >= ONE_PLY);
 
                             // Reduced depth non-pv search using alpha as upperbound
                             value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
@@ -816,15 +819,15 @@ namespace {
                         // The move failed high, but if reduction is very big we could
                         // face a false positive, retry with a less aggressive reduction,
                         // if the move fails high again then go with full depth search.
-                        if (doFullDepthSearch && ss->reduction > 2 * OnePly)
+                        if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
                         {
-                            assert(newDepth - OnePly >= OnePly);
+                            assert(newDepth - ONE_PLY >= ONE_PLY);
 
-                            ss->reduction = OnePly;
+                            ss->reduction = ONE_PLY;
                             value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
                             doFullDepthSearch = (value > alpha);
                         }
-                        ss->reduction = Depth(0); // Restore original reduction
+                        ss->reduction = DEPTH_ZERO; // Restore original reduction
                     }
 
                     // Step 15. Full depth search
@@ -871,12 +874,8 @@ namespace {
             if (AbortSearch)
                 break;
 
-            // Remember beta-cutoff and searched nodes counts for this move. The
-            // info is used to sort the root moves for the next iteration.
-            int64_t our, their;
-            ThreadsMgr.get_beta_counters(pos.side_to_move(), our, their);
-            rml.set_beta_counters(i, our, their);
-            rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
+            // Remember searched nodes counts for this move
+            rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
 
             assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
             assert(value < beta);
@@ -915,19 +914,19 @@ namespace {
                     for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
                     {
                         cout << "info multipv " << j + 1
-                             << " score " << value_to_uci(rml.get_move_score(j))
+                             << " score " << value_to_uci(rml.move_score(j))
                              << " depth " << (j <= i ? Iteration : Iteration - 1)
                              << " time " << current_search_time()
                              << " nodes " << ThreadsMgr.nodes_searched()
                              << " nps " << nps()
                              << " pv ";
 
-                        for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
-                            cout << rml.get_move_pv(j, k) << " ";
+                        for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
+                            cout << rml.move_pv(j, k) << " ";
 
                         cout << endl;
                     }
-                    alpha = rml.get_move_score(Min(i, MultiPV - 1));
+                    alpha = rml.move_score(Min(i, MultiPV - 1));
                 }
             } // PV move or new best move
 
@@ -967,15 +966,14 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    Move movesSearched[256];
-    EvalInfo ei;
+    Move movesSearched[MOVES_MAX];
     StateInfo st;
     const TTEntry *tte;
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, oldAlpha;
-    Value refinedValue, nullValue, futilityValueScaled; // Non-PV specific
+    Value bestValue, value, evalMargin, oldAlpha;
+    Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
@@ -996,7 +994,7 @@ namespace {
 
     // Step 2. Check for aborted search and immediate draw
     if (AbortSearch || ThreadsMgr.thread_should_stop(threadID))
-        return Value(0);
+        return VALUE_ZERO;
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
         return VALUE_DRAW;
@@ -1028,7 +1026,7 @@ namespace {
     if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
     {
         // Refresh tte entry to avoid aging
-        TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->king_danger());
+        TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin());
 
         ss->bestMove = ttMove; // Can be MOVE_NONE
         return value_from_tt(tte->value(), ply);
@@ -1038,19 +1036,19 @@ namespace {
     // update gain statistics of parent move.
     isCheck = pos.is_check();
     if (isCheck)
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
     else if (tte)
     {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        ei.kingDanger[pos.side_to_move()] = tte->king_danger();
+        evalMargin = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, ei);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+        refinedValue = ss->eval = evaluate(pos, evalMargin);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
     }
 
     // Save gain for the parent non-capture move
@@ -1067,7 +1065,7 @@ namespace {
         && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
         Value rbeta = beta - razor_margin(depth);
-        Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, Depth(0), ply);
+        Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, DEPTH_ZERO, ply);
         if (v < rbeta)
             // Logically we should return (v + razor_margin(depth)), but
             // surprisingly this did slightly weaker in tests.
@@ -1087,21 +1085,18 @@ namespace {
         return refinedValue - futility_margin(depth, 0);
 
     // Step 8. Null move search with verification search (is omitted in PV nodes)
-    // When we jump directly to qsearch() we do a null move only if static value is
-    // at least beta. Otherwise we do a null move if static value is not more than
-    // NullMoveMargin under beta.
     if (   !PvNode
         && !ss->skipNullMove
-        &&  depth > OnePly
+        &&  depth > ONE_PLY
         && !isCheck
-        &&  refinedValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0)
+        &&  refinedValue >= beta
         && !value_is_mate(beta)
         &&  pos.non_pawn_material(pos.side_to_move()))
     {
         ss->currentMove = MOVE_NULL;
 
         // Null move dynamic reduction based on depth
-        int R = 3 + (depth >= 5 * OnePly ? depth / 8 : 0);
+        int R = 3 + (depth >= 5 * ONE_PLY ? depth / 8 : 0);
 
         // Null move dynamic reduction based on value
         if (refinedValue - beta > PawnValueMidgame)
@@ -1110,8 +1105,8 @@ namespace {
         pos.do_null_move(st);
         (ss+1)->skipNullMove = true;
 
-        nullValue = depth-R*OnePly < OnePly ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
-                                            : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*OnePly, ply+1);
+        nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
+                                              : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1);
         (ss+1)->skipNullMove = false;
         pos.undo_null_move();
 
@@ -1121,12 +1116,12 @@ namespace {
             if (nullValue >= value_mate_in(PLY_MAX))
                 nullValue = beta;
 
-            if (depth < 6 * OnePly)
+            if (depth < 6 * ONE_PLY)
                 return nullValue;
 
             // Do verification search at high depths
             ss->skipNullMove = true;
-            Value v = search<NonPV>(pos, ss, alpha, beta, depth-R*OnePly, ply);
+            Value v = search<NonPV>(pos, ss, alpha, beta, depth-R*ONE_PLY, ply);
             ss->skipNullMove = false;
 
             if (v >= beta)
@@ -1156,7 +1151,7 @@ namespace {
         &&  ttMove == MOVE_NONE
         && (PvNode || (!isCheck && ss->eval >= beta - IIDMargin)))
     {
-        Depth d = (PvNode ? depth - 2 * OnePly : depth / 2);
+        Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
 
         ss->skipNullMove = true;
         search<PvNode>(pos, ss, alpha, beta, d, ply);
@@ -1175,12 +1170,13 @@ namespace {
     CheckInfo ci(pos);
     ss->bestMove = MOVE_NONE;
     singleEvasion = isCheck && mp.number_of_evasions() == 1;
+    futilityBase = ss->eval + evalMargin;
     singularExtensionNode =   depth >= SingularExtensionDepth[PvNode]
                            && tte
                            && tte->move()
                            && !excludedMove // Do not allow recursive singular extension search
-                           && is_lower_bound(tte->type())
-                           && tte->depth() >= depth - 3 * OnePly;
+                           && (tte->type() & VALUE_TYPE_LOWER)
+                           && tte->depth() >= depth - 3 * ONE_PLY;
 
     // Step 10. Loop through moves
     // Loop through all legal moves until no moves remain or a beta cutoff occurs
@@ -1205,7 +1201,7 @@ namespace {
       // lower then ttValue minus a margin then we extend ttMove.
       if (   singularExtensionNode
           && move == tte->move()
-          && ext < OnePly)
+          && ext < ONE_PLY)
       {
           Value ttValue = value_from_tt(tte->value(), ply);
 
@@ -1219,11 +1215,11 @@ namespace {
               ss->excludedMove = MOVE_NONE;
               ss->bestMove = MOVE_NONE;
               if (v < b)
-                  ext = OnePly;
+                  ext = ONE_PLY;
           }
       }
 
-      newDepth = depth - OnePly + ext;
+      newDepth = depth - ONE_PLY + ext;
 
       // Update current move (this must be done after singular extension search)
       movesSearched[moveCount++] = ss->currentMove = move;
@@ -1243,10 +1239,10 @@ namespace {
               continue;
 
           // Value based pruning
-          // We illogically ignore reduction condition depth >= 3*OnePly for predicted depth,
+          // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
           // but fixing this made program slightly weaker.
           Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
-          futilityValueScaled =  ss->eval + futility_margin(predictedDepth, moveCount)
+          futilityValueScaled =  futilityBase + futility_margin(predictedDepth, moveCount)
                                + H.gain(pos.piece_on(move_from(move)), move_to(move));
 
           if (futilityValueScaled < beta)
@@ -1263,15 +1259,15 @@ namespace {
       // Step extra. pv search (only in PV nodes)
       // The first move in list is the expected PV
       if (PvNode && moveCount == 1)
-          value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
-                                    : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
+          value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
+                                     : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
       else
       {
           // Step 14. Reduced depth search
           // If the move fails high will be re-searched at full depth.
           bool doFullDepthSearch = true;
 
-          if (    depth >= 3 * OnePly
+          if (    depth >= 3 * ONE_PLY
               && !captureOrPromotion
               && !dangerous
               && !move_is_castle(move)
@@ -1281,8 +1277,8 @@ namespace {
               if (ss->reduction)
               {
                   Depth d = newDepth - ss->reduction;
-                  value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1)
-                                     : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
+                  value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
+                                      : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
 
                   doFullDepthSearch = (value > alpha);
               }
@@ -1290,29 +1286,29 @@ namespace {
               // The move failed high, but if reduction is very big we could
               // face a false positive, retry with a less aggressive reduction,
               // if the move fails high again then go with full depth search.
-              if (doFullDepthSearch && ss->reduction > 2 * OnePly)
+              if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
               {
-                  assert(newDepth - OnePly >= OnePly);
+                  assert(newDepth - ONE_PLY >= ONE_PLY);
 
-                  ss->reduction = OnePly;
+                  ss->reduction = ONE_PLY;
                   value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
                   doFullDepthSearch = (value > alpha);
               }
-              ss->reduction = Depth(0); // Restore original reduction
+              ss->reduction = DEPTH_ZERO; // Restore original reduction
           }
 
           // Step 15. Full depth search
           if (doFullDepthSearch)
           {
-              value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1)
-                                        : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
+              value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
+                                         : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
 
               // Step extra. pv search (only in PV nodes)
               // Search only for possible new PV nodes, if instead value >= beta then
               // parent node fails low with value <= alpha and tries another move.
               if (PvNode && value > alpha && value < beta)
-                  value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
-                                            : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
+                  value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
+                                             : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
           }
       }
 
@@ -1364,17 +1360,14 @@ namespace {
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
-    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.kingDanger[pos.side_to_move()]);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
 
     // Update killers and history only for non capture moves that fails high
-    if (bestValue >= beta)
+    if (    bestValue >= beta
+        && !pos.move_is_capture_or_promotion(move))
     {
-        ThreadsMgr.incrementBetaCounter(pos.side_to_move(), depth, threadID);
-        if (!pos.move_is_capture_or_promotion(move))
-        {
             update_history(pos, move, depth, movesSearched, moveCount);
             update_killers(move, ss);
-        }
     }
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@@ -1385,7 +1378,7 @@ namespace {
 
   // qsearch() is the quiescence search function, which is called by the main
   // search function when the remaining depth is zero (or, to be more precise,
-  // less than OnePly).
+  // less than ONE_PLY).
 
   template <NodeType PvNode>
   Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
@@ -1397,10 +1390,9 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    EvalInfo ei;
     StateInfo st;
     Move ttMove, move;
-    Value bestValue, value, futilityValue, futilityBase;
+    Value bestValue, value, evalMargin, futilityValue, futilityBase;
     bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable;
     const TTEntry* tte;
     Value oldAlpha = alpha;
@@ -1429,7 +1421,7 @@ namespace {
     if (isCheck)
     {
         bestValue = futilityBase = -VALUE_INFINITE;
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
         deepChecks = enoughMaterial = false;
     }
     else
@@ -1438,20 +1430,19 @@ namespace {
         {
             assert(tte->static_value() != VALUE_NONE);
 
-            ei.kingDanger[pos.side_to_move()] = tte->king_danger();
-            bestValue = tte->static_value();
+            evalMargin = tte->static_value_margin();
+            ss->eval = bestValue = tte->static_value();
         }
         else
-            bestValue = evaluate(pos, ei);
+            ss->eval = bestValue = evaluate(pos, evalMargin);
 
-        ss->eval = bestValue;
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
 
         // Stand pat. Return immediately if static value is at least beta
         if (bestValue >= beta)
         {
             if (!tte)
-                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
 
             return bestValue;
         }
@@ -1460,18 +1451,18 @@ namespace {
             alpha = bestValue;
 
         // If we are near beta then try to get a cutoff pushing checks a bit further
-        deepChecks = (depth == -OnePly && bestValue >= beta - PawnValueMidgame / 8);
+        deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check
-        futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()];
+        futilityBase = ss->eval + evalMargin + FutilityMarginQS;
         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search the moves. Because the depth is <= 0 here, only captures,
-    // queen promotions and checks (only if depth == 0 or depth == -OnePly
+    // queen promotions and checks (only if depth == 0 or depth == -ONE_PLY
     // and we are near beta) will be generated.
-    MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H);
+    MovePicker mp = MovePicker(pos, ttMove, deepChecks ? DEPTH_ZERO : depth, H);
     CheckInfo ci(pos);
 
     // Loop through the moves until no moves remain or a beta cutoff occurs
@@ -1493,7 +1484,7 @@ namespace {
       {
           futilityValue =  futilityBase
                          + pos.endgame_value_of_piece_on(move_to(move))
-                         + (move_is_ep(move) ? PawnValueEndgame : Value(0));
+                         + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
 
           if (futilityValue < alpha)
           {
@@ -1503,11 +1494,10 @@ namespace {
           }
       }
 
-      // Detect blocking evasions that are candidate to be pruned
+      // Detect non-capture evasions that are candidate to be pruned
       evasionPrunable =   isCheck
                        && bestValue > value_mated_in(PLY_MAX)
                        && !pos.move_is_capture(move)
-                       && pos.type_of_piece_on(move_from(move)) != KING
                        && !pos.can_castle(pos.side_to_move());
 
       // Don't search moves with negative SEE values
@@ -1523,7 +1513,7 @@ namespace {
 
       // Make and search the move
       pos.do_move(move, st, ci, moveIsCheck);
-      value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-OnePly, ply+1);
+      value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-ONE_PLY, ply+1);
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
@@ -1546,14 +1536,9 @@ namespace {
         return value_mated_in(ply);
 
     // Update transposition table
-    Depth d = (depth == Depth(0) ? Depth(0) : Depth(-1));
+    Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY);
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
-    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, ei.kingDanger[pos.side_to_move()]);
-
-    // Update killers only for checking moves that fails high
-    if (    bestValue >= beta
-        && !pos.move_is_capture_or_promotion(ss->bestMove))
-        update_killers(ss->bestMove, ss);
+    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
@@ -1607,7 +1592,7 @@ namespace {
 
       // Step 11. Decide the new search depth
       ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
-      newDepth = sp->depth - OnePly + ext;
+      newDepth = sp->depth - ONE_PLY + ext;
 
       // Update current move
       ss->currentMove = move;
@@ -1660,8 +1645,8 @@ namespace {
           {
               Value localAlpha = sp->alpha;
               Depth d = newDepth - ss->reduction;
-              value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1)
-                                 : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1);
+              value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1)
+                                  : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1);
 
               doFullDepthSearch = (value > localAlpha);
           }
@@ -1669,31 +1654,31 @@ namespace {
           // The move failed high, but if reduction is very big we could
           // face a false positive, retry with a less aggressive reduction,
           // if the move fails high again then go with full depth search.
-          if (doFullDepthSearch && ss->reduction > 2 * OnePly)
+          if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
           {
-              assert(newDepth - OnePly >= OnePly);
+              assert(newDepth - ONE_PLY >= ONE_PLY);
 
-              ss->reduction = OnePly;
+              ss->reduction = ONE_PLY;
               Value localAlpha = sp->alpha;
               value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1);
               doFullDepthSearch = (value > localAlpha);
           }
-          ss->reduction = Depth(0); // Restore original reduction
+          ss->reduction = DEPTH_ZERO; // Restore original reduction
       }
 
       // Step 15. Full depth search
       if (doFullDepthSearch)
       {
           Value localAlpha = sp->alpha;
-          value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1)
-                                    : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1);
+          value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1)
+                                     : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1);
 
           // Step extra. pv search (only in PV nodes)
           // Search only for possible new PV nodes, if instead value >= beta then
           // parent node fails low with value <= alpha and tries another move.
           if (PvNode && value > localAlpha && value < sp->beta)
-              value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), sp->ply+1)
-                                        : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1);
+              value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, DEPTH_ZERO, sp->ply+1)
+                                         : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1);
       }
 
       // Step 16. Undo move
@@ -1851,7 +1836,7 @@ namespace {
 
     assert(m != MOVE_NONE);
 
-    Depth result = Depth(0);
+    Depth result = DEPTH_ZERO;
     *dangerous = moveIsCheck | singleEvasion | mateThreat;
 
     if (*dangerous)
@@ -1884,7 +1869,7 @@ namespace {
     if (   captureOrPromotion
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
-            - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
+            - pos.midgame_value_of_piece_on(move_to(m)) == VALUE_ZERO)
         && !move_is_promotion(m)
         && !move_is_ep(m))
     {
@@ -1897,11 +1882,11 @@ namespace {
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && pos.see_sign(m) >= 0)
     {
-        result += OnePly/2;
+        result += ONE_PLY / 2;
         *dangerous = true;
     }
 
-    return Min(result, OnePly);
+    return Min(result, ONE_PLY);
   }
 
 
@@ -1957,8 +1942,8 @@ namespace {
               || v >= Max(value_mate_in(PLY_MAX), beta)
               || v < Min(value_mated_in(PLY_MAX), beta))
 
-          && (   (is_lower_bound(tte->type()) && v >= beta)
-              || (is_upper_bound(tte->type()) && v < beta));
+          && (   ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
+              || ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
   }
 
 
@@ -1971,8 +1956,8 @@ namespace {
 
       Value v = value_from_tt(tte->value(), ply);
 
-      if (   (is_lower_bound(tte->type()) && v >= defaultEval)
-          || (is_upper_bound(tte->type()) && v < defaultEval))
+      if (   ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval)
+          || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval))
           return v;
 
       return defaultEval;
@@ -2043,7 +2028,7 @@ namespace {
 
     std::stringstream s;
 
-    if (abs(v) < VALUE_MATE - PLY_MAX * OnePly)
+    if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
       s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to pawn = 100
     else
       s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 );
@@ -2165,7 +2150,7 @@ namespace {
     {
         ss->excludedMove = MOVE_NONE;
         ss->skipNullMove = false;
-        ss->reduction = Depth(0);
+        ss->reduction = DEPTH_ZERO;
 
         if (i < 3)
             ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE;
@@ -2238,16 +2223,15 @@ namespace {
     StateInfo st;
     TTEntry* tte;
     Position p(pos, pos.thread());
-    EvalInfo ei;
-    Value v;
+    Value v, m = VALUE_NONE;
 
     for (int i = 0; pv[i] != MOVE_NONE; i++)
     {
         tte = TT.retrieve(p.get_key());
         if (!tte || tte->move() != pv[i])
         {
-            v = (p.is_check() ? VALUE_NONE : evaluate(p, ei));
-            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.kingDanger[pos.side_to_move()]);
+            v = (p.is_check() ? VALUE_NONE : evaluate(p, m));
+            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m);
         }
         p.do_move(pv[i], st);
     }
@@ -2320,12 +2304,6 @@ namespace {
         threads[i].nodes = 0ULL;
   }
 
-  void ThreadsManager::resetBetaCounters() {
-
-    for (int i = 0; i < MAX_THREADS; i++)
-        threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL;
-  }
-
   int64_t ThreadsManager::nodes_searched() const {
 
     int64_t result = 0ULL;
@@ -2335,16 +2313,6 @@ namespace {
     return result;
   }
 
-  void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const {
-
-    our = their = 0UL;
-    for (int i = 0; i < MAX_THREADS; i++)
-    {
-        our += threads[i].betaCutOffs[us];
-        their += threads[i].betaCutOffs[opposite_color(us)];
-    }
-  }
-
 
   // idle_loop() is where the threads are parked when they have no work to do.
   // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
@@ -2603,7 +2571,7 @@ namespace {
     assert(*bestValue <= *alpha);
     assert(*alpha < beta);
     assert(beta <= VALUE_INFINITE);
-    assert(depth > Depth(0));
+    assert(depth > DEPTH_ZERO);
     assert(p.thread() >= 0 && p.thread() < ActiveThreads);
     assert(ActiveThreads > 1);
 
@@ -2737,17 +2705,17 @@ namespace {
 
   // RootMoveList c'tor
 
-  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
+  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
 
     SearchStack ss[PLY_MAX_PLUS_2];
-    MoveStack mlist[MaxRootMoves];
+    MoveStack mlist[MOVES_MAX];
     StateInfo st;
     bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
 
     // Initialize search stack
     init_ss_array(ss, PLY_MAX_PLUS_2);
-    ss[0].currentMove = ss[0].bestMove = MOVE_NONE;
     ss[0].eval = VALUE_NONE;
+    count = 0;
 
     // Generate all legal moves
     MoveStack* last = generate_moves(pos, mlist);
@@ -2764,32 +2732,35 @@ namespace {
             continue;
 
         // Find a quick score for the move
-        pos.do_move(cur->move, st);
-        ss[0].currentMove = cur->move;
-        moves[count].move = cur->move;
-        moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1);
-        moves[count].pv[0] = cur->move;
+        moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
         moves[count].pv[1] = MOVE_NONE;
+        pos.do_move(cur->move, st);
+        moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
         pos.undo_move(cur->move);
         count++;
     }
     sort();
   }
 
+  // Score root moves using the standard way used in main search, the moves
+  // are scored according to the order in which are returned by MovePicker.
 
-  // RootMoveList simple methods definitions
-
-  void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
+  void RootMoveList::score_moves(const Position& pos)
+  {
+      Move move;
+      int score = 1000;
+      MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
 
-    moves[moveNum].nodes = nodes;
-    moves[moveNum].cumulativeNodes += nodes;
+      while ((move = mp.get_next_move()) != MOVE_NONE)
+          for (int i = 0; i < count; i++)
+              if (moves[i].move == move)
+              {
+                  moves[i].mp_score = score--;
+                  break;
+              }
   }
 
-  void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
-
-    moves[moveNum].ourBeta = our;
-    moves[moveNum].theirBeta = their;
-  }
+  // RootMoveList simple methods definitions
 
   void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
 
@@ -2829,4 +2800,4 @@ namespace {
     }
   }
 
-} // namspace
+} // namespace