Space inflate movepick.cpp

Also added some FIXME to dubious points.

Still no functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

src/movepick.cpp

@@ -94,89 +94,84 @@ MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
 /// are no more moves left of the types we are interested in.
 
 Move MovePicker::get_next_move() {
+
   Move move;
 
-  while(true) {
+  while (true)
+  {
     // If we already have a list of generated moves, pick the best move from
     // the list, and return it:
-    move = this->pick_move_from_list();
-    if(move != MOVE_NONE) {
-      assert(move_is_ok(move));
-      return move;
+    move = pick_move_from_list();
+    if (move != MOVE_NONE)
+    {
+        assert(move_is_ok(move));
+        return move;
     }
 
     // Next phase:
     phaseIndex++;
-    switch(PhaseTable[phaseIndex]) {
+    switch (PhaseTable[phaseIndex]) {
 
     case PH_TT_MOVE:
-      if(ttMove != MOVE_NONE) {
-        assert(move_is_ok(ttMove));
-        Move m = generate_move_if_legal(*pos, ttMove, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == ttMove);
-          return m;
+        if (ttMove != MOVE_NONE)
+        {
+            assert(move_is_ok(ttMove));
+            if (generate_move_if_legal(*pos, ttMove, pinned) != MOVE_NONE)
+                return ttMove;
         }
-      }
-      break;
+        break;
 
     case PH_MATE_KILLER:
-      if(mateKiller != MOVE_NONE) {
-        assert(move_is_ok(mateKiller));
-        Move m = generate_move_if_legal(*pos, mateKiller, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == mateKiller);
-          return m;
+        if (mateKiller != MOVE_NONE)
+        {
+            assert(move_is_ok(mateKiller));
+            if (generate_move_if_legal(*pos, mateKiller, pinned) != MOVE_NONE)
+                return ttMove;
         }
-      }
-      break;
+        break;
 
-    case PH_GOOD_CAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_captures();
-      movesPicked = 0;
-      break;
+    case PH_GOOD_CAPTURES:      
+        numOfMoves = generate_captures(*pos, moves);
+        score_captures();
+        movesPicked = 0;
+        break;
 
     case PH_BAD_CAPTURES:
-      badCapturesPicked = 0;
-      break;
+        badCapturesPicked = 0;
+        break;
 
     case PH_NONCAPTURES:
-      numOfMoves = generate_noncaptures(*pos, moves);
-      this->score_noncaptures();
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_noncaptures(*pos, moves);
+        score_noncaptures();
+        movesPicked = 0;
+        break;
 
     case PH_EVASIONS:
-      assert(pos->is_check());
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_evasions(*pos, moves);
-      this->score_evasions();
-      movesPicked = 0;
-      break;
+        assert(pos->is_check());      
+        numOfMoves = generate_evasions(*pos, moves);
+        score_evasions();
+        movesPicked = 0;
+        break;
 
-    case PH_QCAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_qcaptures();
-      movesPicked = 0;
-      break;
+    case PH_QCAPTURES:      
+        numOfMoves = generate_captures(*pos, moves);
+        score_qcaptures();
+        movesPicked = 0;
+        break;
 
     case PH_QCHECKS:
-      numOfMoves = generate_checks(*pos, moves, dc);
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_checks(*pos, moves, dc);
+        movesPicked = 0;
+        break;
 
     case PH_STOP:
-      return MOVE_NONE;
+        return MOVE_NONE;
 
     default:
-      assert(false);
-      return MOVE_NONE;
+        assert(false);
+        return MOVE_NONE;
     }
   }
-
   assert(false);
 
   return MOVE_NONE;
@@ -187,32 +182,21 @@ Move MovePicker::get_next_move() {
 /// prevent multiple threads from picking the same move at a split point.
 
 Move MovePicker::get_next_move(Lock &lock) {
-   Move m;
 
-   lock_grab(&lock);
-   if(finished) {
-     lock_release(&lock);
-     return MOVE_NONE;
-   }
-   m = this->get_next_move();
-   if(m == MOVE_NONE)
-     finished = true;
-   lock_release(&lock);
-   
-   return m;
+  lock_grab(&lock);
+  if (finished)
+  {
+      lock_release(&lock);
+      return MOVE_NONE;
+  }
+  Move m = get_next_move();
+  if (m == MOVE_NONE)
+      finished = true;
+
+  lock_release(&lock);   
+  return m;
 }
 
- 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable.  It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-int MovePicker::number_of_moves() const {
-  return numOfMoves;
-}
-
-
 /// MovePicker::score_captures(), MovePicker::score_noncaptures(),
 /// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
 /// numerical move ordering score to each move in a move list.  The moves
@@ -229,19 +213,17 @@ void MovePicker::score_captures() {
   // where it is possible to recapture with the hanging piece).  Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
-  for(int i = 0; i < numOfMoves; i++) {
-    int seeValue = pos->see(moves[i].move);
-    if(seeValue >= 0) {
-      if(move_promotion(moves[i].move))
-        moves[i].score = QueenValueMidgame;
-      else 
-        moves[i].score =
-          int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) -
-          int(pos->type_of_piece_on(move_from(moves[i].move)));
-    }
-    else
-      moves[i].score = seeValue;
-        
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      moves[i].score = pos->see(m);
+      if (moves[i].score >= 0)
+      {
+          moves[i].score = move_promotion(m) ? QueenValueMidgame
+                          : int(pos->midgame_value_of_piece_on(move_to(m)))
+                           -int(pos->type_of_piece_on(move_from(m)));
+          // FIXME second term seems wrong !
+      }
   }
 }
 
@@ -266,29 +248,34 @@ void MovePicker::score_noncaptures() {
 }
 
 void MovePicker::score_evasions() {
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(m == ttMove)
-      moves[i].score = 2*HistoryMax;
-    else if(!pos->square_is_empty(move_to(m))) {
-      int seeScore = pos->see(m);
-      moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
-    }
-    else
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      if (m == ttMove)
+          moves[i].score = 2*HistoryMax;
+      else if (!pos->square_is_empty(move_to(m)))
+      {
+          moves[i].score = pos->see(m);
+          if (moves[i].score >= 0)
+              moves[i].score += HistoryMax;          
+      }
+      else
+          moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
   }
+  // FIXME try psqt also here
 }
 
 void MovePicker::score_qcaptures() {
+
   // Use MVV/LVA ordering.
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(move_promotion(m))
-      moves[i].score = QueenValueMidgame;
-    else
-      moves[i].score =
-        int(pos->midgame_value_of_piece_on(move_to(m))) -
-        int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      moves[i].score = move_promotion(m) ? QueenValueMidgame
+                      : int(pos->midgame_value_of_piece_on(move_to(m)))
+                       -int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
+      // FIXME Why second term like that ???
   }
 }
 
@@ -302,161 +289,187 @@ void MovePicker::score_qcaptures() {
 /// negative SEE values to the badCaptures[] array.
 
 Move MovePicker::pick_move_from_list() {
+
   int bestScore = -10000000;
   int bestIndex;
   Move move;
 
-  switch(PhaseTable[phaseIndex]) {
+  switch (PhaseTable[phaseIndex]) {
 
   case PH_GOOD_CAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++) {
-        if(moves[i].score < 0) {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-        }
-        else if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-      }
-      if(bestIndex != -1) { // Found a good capture
-        move = moves[bestIndex].move;
-        moves[bestIndex] = moves[movesPicked++];
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
-
-  case PH_NONCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-
-      // If this is a PV node or we have only picked a few moves, scan
-      // the entire move list for the best move.  If many moves have already
-      // been searched and it is not a PV node, we are probably failing low
-      // anyway, so we just pick the first move from the list.
-      if(pvNode || movesPicked < 12) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
+      assert(!pos->is_check());
+      assert(movesPicked >= 0);
+      while (movesPicked < numOfMoves)
+      {
+          bestScore = -10000000;
+          bestIndex = -1;
+          for (int i = movesPicked; i < numOfMoves; i++)
+          {
+              if (moves[i].score < 0)
+              {
+                  // Losing capture, move it to the badCaptures[] array
+                  assert(numOfBadCaptures < 63);
+                  badCaptures[numOfBadCaptures++] = moves[i];
+                  moves[i--] = moves[--numOfMoves];
+               }
+               else if (moves[i].score > bestScore)
+               {
+                   bestIndex = i;
+                   bestScore = moves[i].score;
+               }
+          }
+          if (bestIndex != -1) // Found a good capture
+          {
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              if (   move != ttMove
+                  && move != mateKiller
+                  && pos->move_is_legal(move, pinned))
+                  return move;
           }
       }
-      else
-        bestIndex = movesPicked;
+      break;
 
-      if(bestIndex != -1) {
-        move = moves[bestIndex].move;
-        moves[bestIndex] = moves[movesPicked++];
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
+  case PH_NONCAPTURES:
+      assert(!pos->is_check());
+      assert(movesPicked >= 0);
+      while (movesPicked < numOfMoves)
+      {
+          // If this is a PV node or we have only picked a few moves, scan
+          // the entire move list for the best move.  If many moves have already
+          // been searched and it is not a PV node, we are probably failing low
+          // anyway, so we just pick the first move from the list.
+          if (pvNode || movesPicked < 12)
+          {
+              bestScore = -10000000;
+              bestIndex = -1;
+              for (int i = movesPicked; i < numOfMoves; i++)
+                  if(moves[i].score > bestScore)
+                  {
+                      bestIndex = i;
+                      bestScore = moves[i].score;
+                  }
+          } else
+              bestIndex = movesPicked;
+
+          if (bestIndex != -1)
+          {
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              if (   move != ttMove
+                  && move != mateKiller
+                  && pos->move_is_legal(move, pinned))
+                  return move;
+         }
     }
     break;
 
   case PH_EVASIONS:
-    assert(pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++)
-        if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
+      assert(pos->is_check());
+      assert(movesPicked >= 0);
+      while (movesPicked < numOfMoves)
+      {
+          bestScore = -10000000;
+          bestIndex = -1;
+          for (int i = movesPicked; i < numOfMoves; i++)
+              if (moves[i].score > bestScore)
+              {
+                  bestIndex = i;
+                  bestScore = moves[i].score;
+              }
 
-      if(bestIndex != -1) {
-        move = moves[bestIndex].move;
-        moves[bestIndex] = moves[movesPicked++];
-        return move;
-      }
-    }
-    break;
-
-  case PH_BAD_CAPTURES:
-    assert(!pos->is_check());
-    assert(badCapturesPicked >= 0);
-    // It's probably a good idea to use SEE move ordering here, instead
-    // of just picking the first move.  FIXME
-    while(badCapturesPicked < numOfBadCaptures) {
-      move = badCaptures[badCapturesPicked++].move;
-      if(move != ttMove && move != mateKiller && 
-         pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
-
-  case PH_QCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      if(movesPicked < 4) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
+          if (bestIndex != -1)
+          {
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              return move;
           }
       }
-      else
-        bestIndex = movesPicked;
+      break;
 
-      if(bestIndex != -1) {
-        move = moves[bestIndex].move;
-        moves[bestIndex] = moves[movesPicked++];
-        // Remember to change the line below if we decide to hash the qsearch!
-        // Maybe also postpone the legality check until after futility pruning?
-        if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-          return move;
+  case PH_BAD_CAPTURES:
+      assert(!pos->is_check());
+      assert(badCapturesPicked >= 0);
+      // It's probably a good idea to use SEE move ordering here, instead
+      // of just picking the first move.  FIXME
+      while (badCapturesPicked < numOfBadCaptures)
+      {
+          move = badCaptures[badCapturesPicked++].move;
+          if (   move != ttMove
+              && move != mateKiller
+              && pos->move_is_legal(move, pinned))
+              return move;
       }
-    }
-    break;
+      break;
+
+  case PH_QCAPTURES:
+      assert(!pos->is_check());
+      assert(movesPicked >= 0);
+      while (movesPicked < numOfMoves)
+      {
+          bestScore = -10000000;
+          if (movesPicked < 4) // FIXME makes sens to score qcaps?
+          {
+              bestIndex = -1;
+              for (int i = movesPicked; i < numOfMoves; i++)
+                  if(moves[i].score > bestScore)
+                  {
+                      bestIndex = i;
+                      bestScore = moves[i].score;
+                  }
+          } else
+              bestIndex = movesPicked;
+
+          if (bestIndex != -1)
+          {
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              // Remember to change the line below if we decide to hash the qsearch!
+              // Maybe also postpone the legality check until after futility pruning?
+              // FIXME !!!
+              if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
+                  return move;
+          }
+      }
+      break;
 
   case PH_QCHECKS:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    // Perhaps we should do something better than just picking the first
-    // move here?  FIXME
-    while(movesPicked < numOfMoves) {
-      move = moves[movesPicked++].move;
-      // Remember to change the line below if we decide to hash the qsearch!
-      if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
+      assert(!pos->is_check());
+      assert(movesPicked >= 0);
+      // Perhaps we should do something better than just picking the first
+      // move here?  FIXME
+      while (movesPicked < numOfMoves)
+      {
+          move = moves[movesPicked++].move;
+          // Remember to change the line below if we decide to hash the qsearch!
+          // FIXME !!!
+          if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
+              return move;
+      }
+      break;
 
   default:
-    break;
+      break;
   }
-
   return MOVE_NONE;
 }
 
+
+/// MovePicker::current_move_type() returns the type of the just
+/// picked next move. It can be used in search to further differentiate
+/// according to the current move type: capture, non capture, escape, etc.
 MovePicker::MovegenPhase MovePicker::current_move_type() const {
   return PhaseTable[phaseIndex];
 }
 
+
 /// MovePicker::init_phase_table() initializes the PhaseTable[],
 /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
 /// and QsearchWithoutChecksPhaseIndex variables.  It is only called once
 /// during program startup, and never again while the program is running.
 
 void MovePicker::init_phase_table() {
+
   int i = 0;
 
   // Main search

src/movepick.h

@@ -94,6 +94,15 @@ private:
 //// Inline functions
 ////
 
+/// MovePicker::number_of_moves() simply returns the numOfMoves member
+/// variable. It is intended to be used in positions where the side to move
+/// is in check, for detecting checkmates or situations where there is only
+/// a single reply to check.
+
+inline int MovePicker::number_of_moves() const {
+  return numOfMoves;
+}
+
 /// MovePicker::discovered_check_candidates() returns a bitboard containing
 /// all pieces which can possibly give discovered check.  This bitboard is
 /// computed by the constructor function.