X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=e1042ea6005f0255ccb1f4b21f809e0f0e4a3b84;hp=4b8cf747a0d04e020a28ac2b688aa1dd84d65f02;hb=2af2c67650c4ac2531e6ab2753830f91c0999876;hpb=d40e7ee20903257cb0126f1945d63257ded022c3

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 4b8cf747..e1042ea6 100644
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -31,7 +31,7 @@ namespace {
     QSEARCH_TT, QCAPTURE_INIT, QCAPTURE, QCHECK_INIT, QCHECK
   };
 
-  // Helper filter used with select_move()
+  // Helper filter used with select()
   const auto Any = [](){ return true; };
 
   // partial_insertion_sort() sorts moves in descending order up to and including
@@ -62,7 +62,7 @@ namespace {
 MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,
                        const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers)
            : pos(p), mainHistory(mh), captureHistory(cph), contHistory(ch),
-             refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d){
+             refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d) {
 
   assert(d > DEPTH_ZERO);
 
@@ -85,7 +85,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
   stage += (ttMove == MOVE_NONE);
 }
 
-/// MovePicker constructor for ProbCut: we generate captures with SEE higher
+/// MovePicker constructor for ProbCut: we generate captures with SEE greater
 /// than or equal to the given threshold.
 MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph)
            : pos(p), captureHistory(cph), threshold(th) {
@@ -111,7 +111,7 @@ void MovePicker::score() {
   for (auto& m : *this)
       if (Type == CAPTURES)
           m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                   + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))];
+                   + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))] / 16;
 
       else if (Type == QUIETS)
           m.value =  (*mainHistory)[pos.side_to_move()][from_to(m)]
@@ -129,14 +129,14 @@ void MovePicker::score() {
       }
 }
 
-/// MovePicker::select_move() returns the next move satisfying a predicate function.
+/// MovePicker::select() returns the next move satisfying a predicate function.
 /// It never returns the TT move.
-template<PickType T, typename Pred>
-Move MovePicker::select_move(Pred filter) {
+template<MovePicker::PickType T, typename Pred>
+Move MovePicker::select(Pred filter) {
 
   while (cur < endMoves)
   {
-      if (T == BEST_SCORE)
+      if (T == Best)
           std::swap(*cur, *std::max_element(cur, endMoves));
 
       move = *cur++;
@@ -165,20 +165,23 @@ top:
   case CAPTURE_INIT:
   case PROBCUT_INIT:
   case QCAPTURE_INIT:
-      endBadCaptures = cur = moves;
+      cur = endBadCaptures = moves;
       endMoves = generate<CAPTURES>(pos, cur);
+
       score<CAPTURES>();
       ++stage;
       goto top;
 
   case GOOD_CAPTURE:
-      if (select_move<BEST_SCORE>([&](){ return  pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)) ?
-                                                 // Move losing capture to endBadCaptures to be tried later
-                                                 true : (*endBadCaptures++ = move, false); }))
+      if (select<Best>([&](){
+                       return pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)) ?
+                              // Move losing capture to endBadCaptures to be tried later
+                              true : (*endBadCaptures++ = move, false); }))
           return move;
 
       // Prepare the pointers to loop over the refutations array
-      cur = std::begin(refutations), endMoves = std::end(refutations);
+      cur = std::begin(refutations);
+      endMoves = std::end(refutations);
 
       // If the countermove is the same as a killer, skip it
       if (   refutations[0].move == refutations[2].move
@@ -189,9 +192,9 @@ top:
       /* fallthrough */
 
   case REFUTATION:
-      if (select_move<NEXT>([&](){ return     move != MOVE_NONE
-                                          && !pos.capture(move)
-                                          &&  pos.pseudo_legal(move); }))
+      if (select<Next>([&](){ return    move != MOVE_NONE
+                                    && !pos.capture(move)
+                                    &&  pos.pseudo_legal(move); }))
           return move;
       ++stage;
       /* fallthrough */
@@ -199,6 +202,7 @@ top:
   case QUIET_INIT:
       cur = endBadCaptures;
       endMoves = generate<QUIETS>(pos, cur);
+
       score<QUIETS>();
       partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY);
       ++stage;
@@ -206,35 +210,38 @@ top:
 
   case QUIET:
       if (   !skipQuiets
-          && select_move<NEXT>([&](){return    move != refutations[0]
-                                            && move != refutations[1]
-                                            && move != refutations[2];}))
+          && select<Next>([&](){return   move != refutations[0]
+                                      && move != refutations[1]
+                                      && move != refutations[2];}))
           return move;
 
       // Prepare the pointers to loop over the bad captures
-      cur = moves, endMoves = endBadCaptures;
+      cur = moves;
+      endMoves = endBadCaptures;
+
       ++stage;
       /* fallthrough */
 
   case BAD_CAPTURE:
-      return select_move<NEXT>(Any);
+      return select<Next>(Any);
 
   case EVASION_INIT:
       cur = moves;
       endMoves = generate<EVASIONS>(pos, cur);
+
       score<EVASIONS>();
       ++stage;
       /* fallthrough */
 
   case EVASION:
-      return select_move<BEST_SCORE>(Any);
+      return select<Best>(Any);
 
   case PROBCUT:
-      return select_move<BEST_SCORE>([&](){ return pos.see_ge(move, threshold); });
+      return select<Best>([&](){ return pos.see_ge(move, threshold); });
 
   case QCAPTURE:
-      if (select_move<BEST_SCORE>([&](){ return   depth > DEPTH_QS_RECAPTURES
-                                               || to_sq(move) == recaptureSquare; }))
+      if (select<Best>([&](){ return   depth > DEPTH_QS_RECAPTURES
+                                    || to_sq(move) == recaptureSquare; }))
           return move;
 
       // If we did not find any move and we do not try checks, we have finished
@@ -247,11 +254,12 @@ top:
   case QCHECK_INIT:
       cur = moves;
       endMoves = generate<QUIET_CHECKS>(pos, cur);
+
       ++stage;
       /* fallthrough */
 
   case QCHECK:
-      return select_move<NEXT>(Any);
+      return select<Next>(Any);
   }
 
   assert(false);