X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=22845ba2a2a86f3f3cfb86c9ed0428fee21de582;hp=3897f4c10048bf7c164d67c4c2e9858e597c3994;hb=bbb24625764619e5886ce0250739a4c9bfdb4d33;hpb=436fa5c8fa5302f69a83ad28491702c5dc3d4af7

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 3897f4c1..22845ba2 100644
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -63,23 +63,25 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, bool pv, Move ttm,
-                       const SearchStack& ss, Depth d) : pos(p) {
-  pvNode = pv;
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
+                       const History& h, SearchStack* ss) : pos(p), H(h) {
   ttMove = ttm;
-  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
-  killer1 = ss.killers[0];
-  killer2 = ss.killers[1];
-  depth = d;
-  movesPicked = 0;
-  numOfMoves = 0;
-  numOfBadCaptures = 0;
+  if (ss)
+  {
+      mateKiller = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
+      killer1 = ss->killers[0];
+      killer2 = ss->killers[1];
+  } else
+      mateKiller = killer1 = killer2 = MOVE_NONE;
+
+  movesPicked = numOfMoves = numOfBadCaptures = 0;
+  checkKillers = checkLegal = finished = false;
 
   if (p.is_check())
       phaseIndex = EvasionsPhaseIndex;
-  else if (depth > Depth(0))
+  else if (d > Depth(0))
       phaseIndex = MainSearchPhaseIndex;
-  else if (depth == Depth(0))
+  else if (d == Depth(0))
       phaseIndex = QsearchWithChecksPhaseIndex;
   else
       phaseIndex = QsearchWithoutChecksPhaseIndex;
@@ -139,18 +141,32 @@ Move MovePicker::get_next_move() {
         score_captures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
+        checkLegal = true;
         break;
 
-    case PH_BAD_CAPTURES:
-        // It's probably a good idea to use SEE move ordering here. FIXME
-        movesPicked = 0;
+    case PH_KILLERS:
+        movesPicked = numOfMoves = 0;
+        checkLegal = false;
+        if (killer1 != MOVE_NONE && move_is_legal(pos, killer1, pinned) && !pos.move_is_capture(killer1))
+            moves[numOfMoves++].move = killer1;
+        if (killer2 != MOVE_NONE && move_is_legal(pos, killer2, pinned) && !pos.move_is_capture(killer2) )
+            moves[numOfMoves++].move = killer2;
         break;
 
     case PH_NONCAPTURES:
+        checkKillers = (numOfMoves != 0); // previous phase is PH_KILLERS
         numOfMoves = generate_noncaptures(pos, moves);
         score_noncaptures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
+        checkLegal = true;
+        break;
+
+    case PH_BAD_CAPTURES:
+        // Bad captures SEE value is already calculated by score_captures()
+        // so just sort them to get SEE move ordering.
+        std::sort(badCaptures, badCaptures + numOfBadCaptures);
+        movesPicked = 0;
         break;
 
     case PH_EVASIONS:
@@ -231,7 +247,7 @@ void MovePicker::score_captures() {
       seeValue = pos.see(m);
       if (seeValue >= 0)
       {
-          if (move_promotion(m))
+          if (move_is_promotion(m))
               moves[i].score = QueenValueMidgame;
           else
               moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
@@ -252,26 +268,23 @@ void MovePicker::score_noncaptures() {
   // First score by history, when no history is available then use
   // piece/square tables values. This seems to be better then a
   // random choice when we don't have an history for any move.
-  Move m;
+  Piece piece;
+  Square from, to;
   int hs;
 
   for (int i = 0; i < numOfMoves; i++)
   {
-      m = moves[i].move;
-
-      if (m == killer1)
-          hs = HistoryMax + 2;
-      else if (m == killer2)
-          hs = HistoryMax + 1;
-      else
-          hs = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
+      from = move_from(moves[i].move);
+      to = move_to(moves[i].move);
+      piece = pos.piece_on(from);
+      hs = H.move_ordering_score(piece, to);
 
       // Ensure history is always preferred to pst
       if (hs > 0)
           hs += 1000;
 
       // pst based scoring
-      moves[i].score = hs + pos.mg_pst_delta(m);
+      moves[i].score = hs + pos.pst_delta<Position::MidGame>(piece, from, to);
   }
 }
 
@@ -297,7 +310,7 @@ void MovePicker::score_qcaptures() {
   for (int i = 0; i < numOfMoves; i++)
   {
       Move m = moves[i].move;
-      if (move_promotion(m))
+      if (move_is_promotion(m))
           moves[i].score = QueenValueMidgame;
       else
           moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
@@ -320,13 +333,15 @@ Move MovePicker::pick_move_from_list() {
   switch (PhaseTable[phaseIndex]) {
 
   case PH_GOOD_CAPTURES:
+  case PH_KILLERS:
   case PH_NONCAPTURES:
       while (movesPicked < numOfMoves)
       {
           Move move = moves[movesPicked++].move;
           if (   move != ttMove
               && move != mateKiller
-              && pos.pl_move_is_legal(move, pinned))
+              && (!checkKillers || (move != killer1 && move != killer2))
+              && (!checkLegal || pos.pl_move_is_legal(move, pinned)))
               return move;
       }
       break;
@@ -381,9 +396,7 @@ void MovePicker::init_phase_table() {
   PhaseTable[i++] = PH_TT_MOVE;
   PhaseTable[i++] = PH_MATE_KILLER;
   PhaseTable[i++] = PH_GOOD_CAPTURES;
-  // PH_KILLER_1 and PH_KILLER_2 are not yet used.
-  // PhaseTable[i++] = PH_KILLER_1;
-  // PhaseTable[i++] = PH_KILLER_2;
+  PhaseTable[i++] = PH_KILLERS;
   PhaseTable[i++] = PH_NONCAPTURES;
   PhaseTable[i++] = PH_BAD_CAPTURES;
   PhaseTable[i++] = PH_STOP;