Fix indentation in movepicker.cpp

Fix indentation in movepicker.cpp and evaluate.cpp. Also move
the PickType enum out of global space.

No functional change

src/evaluate.cpp

@@ -412,7 +412,7 @@ namespace {
 
     constexpr Color    Them = (Us == WHITE ? BLACK : WHITE);
     constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
-                                       : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
+                                           : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
 
     const Square ksq = pos.square<KING>(Us);
     Bitboard weak, b, b1, b2, safe, unsafeChecks, pinned;

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) {
@@ -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>
+template<MovePicker::PickType T, typename Pred>
-Move MovePicker::select_move(Pred filter) {
+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)) ?
+      if (select<Best>([&](){
-                                                 // Move losing capture to endBadCaptures to be tried later
+                       return pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)) ?
-                                                 true : (*endBadCaptures++ = move, false); }))
+                              // 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
+      if (select<Next>([&](){ return    move != MOVE_NONE
-                                          && !pos.capture(move)
+                                    && !pos.capture(move)
-                                          &&  pos.pseudo_legal(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]
+          && select<Next>([&](){return   move != refutations[0]
-                                            && move != refutations[1]
+                                      && move != refutations[1]
-                                            && move != refutations[2];}))
+                                      && 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
+      if (select<Best>([&](){ return   depth > DEPTH_QS_RECAPTURES
-                                               || to_sq(move) == recaptureSquare; }))
+                                    || 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);

src/movepick.h

@@ -109,10 +109,10 @@ typedef Stats<PieceToHistory, W32, NOT_USED, PIECE_NB, SQUARE_NB> ContinuationHi
 /// when MOVE_NONE is returned. In order to improve the efficiency of the alpha
 /// beta algorithm, MovePicker attempts to return the moves which are most likely
 /// to get a cut-off first.
-
-enum PickType { NEXT, BEST_SCORE };
-
 class MovePicker {
+
+  enum PickType { Next, Best };
+
 public:
   MovePicker(const MovePicker&) = delete;
   MovePicker& operator=(const MovePicker&) = delete;
@@ -122,7 +122,7 @@ public:
   Move next_move(bool skipQuiets = false);
 
 private:
-  template<PickType T, typename Pred> Move select_move(Pred);
+  template<PickType T, typename Pred> Move select(Pred);
   template<GenType> void score();
   ExtMove* begin() { return cur; }
   ExtMove* end() { return endMoves; }