X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=7906eb7535631c2bcb8ea6c5398eb82d8e37ed02;hp=6c3f4264dec1af0745aa575d2802f56ad39e362f;hb=c1b60269a26b2ba1c8882b8f382f0e3e435c1962;hpb=7c267587fc7f454182b4d527607bcf8fdbd8c41c

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 6c3f4264..7906eb75 100644
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 //// Includes
 ////
 
+#include <algorithm>
 #include <cassert>
 
 #include "history.h"
@@ -62,17 +63,24 @@ 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) {
+MovePicker::MovePicker(const Position& p, bool pv, Move ttm, Depth d,
+                       const History& h, SearchStack* ss) : pos(p), H(h) {
+
   pvNode = pv;
   ttMove = ttm;
-  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
-  killer1 = ss.killers[0];
-  killer2 = ss.killers[1];
+  if (ss)
+  {
+      mateKiller = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
+      killer1 = ss->killers[0];
+      killer2 = ss->killers[1];
+  } else
+      mateKiller = killer1 = killer2 = MOVE_NONE;
+
   depth = d;
   movesPicked = 0;
   numOfMoves = 0;
   numOfBadCaptures = 0;
+  checkKillers = checkLegal = false;
 
   if (p.is_check())
       phaseIndex = EvasionsPhaseIndex;
@@ -136,16 +144,33 @@ Move MovePicker::get_next_move() {
     case PH_GOOD_CAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_captures();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
+        checkLegal = true;
         break;
 
-    case PH_BAD_CAPTURES:
-        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;
 
@@ -153,16 +178,19 @@ Move MovePicker::get_next_move() {
         assert(pos.is_check());
         numOfMoves = generate_evasions(pos, moves, pinned);
         score_evasions();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_QCAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_qcaptures();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_QCHECKS:
+        // Perhaps we should order moves move here?  FIXME
         numOfMoves = generate_non_capture_checks(pos, moves, dc);
         movesPicked = 0;
         break;
@@ -251,13 +279,7 @@ void MovePicker::score_noncaptures() {
   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)), m);
+      hs = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
 
       // Ensure history is always preferred to pst
       if (hs > 0)
@@ -280,7 +302,7 @@ void MovePicker::score_evasions() {
           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);
+          moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
   }
 }
 
@@ -299,26 +321,6 @@ void MovePicker::score_qcaptures() {
 }
 
 
-/// find_best_index() loops across the moves and returns index of
-/// the highest scored one.
-
-int MovePicker::find_best_index() const {
-
-  assert(movesPicked < numOfMoves);
-
-  int bestIndex = movesPicked;
-  int bestScore = moves[movesPicked].score;
-
-  for (int i = movesPicked + 1; i < numOfMoves; i++)
-      if (moves[i].score > bestScore)
-      {
-          bestIndex = i;
-          bestScore = moves[i].score;
-      }
-  return bestIndex;
-}
-
-
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 /// the current move generation phase).  It takes care not to return the
@@ -326,68 +328,36 @@ int MovePicker::find_best_index() const {
 
 Move MovePicker::pick_move_from_list() {
 
-  int bestIndex;
-  Move move;
+  assert(movesPicked >= 0);
+  assert(!pos.is_check() || PhaseTable[phaseIndex] == PH_EVASIONS || PhaseTable[phaseIndex] == PH_STOP);
+  assert( pos.is_check() || PhaseTable[phaseIndex] != PH_EVASIONS);
 
   switch (PhaseTable[phaseIndex]) {
 
   case PH_GOOD_CAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-
-      while (movesPicked < numOfMoves)
-      {
-          bestIndex = find_best_index();
-          move = moves[bestIndex].move;
-          moves[bestIndex] = moves[movesPicked++];
-          if (   move != ttMove
-              && move != mateKiller
-              && pos.pl_move_is_legal(move, pinned))
-              return move;
-      }
-      break;
-
+  case PH_KILLERS:
   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.
-          bestIndex = (pvNode || movesPicked < 12) ? find_best_index() : movesPicked;
-          move = moves[bestIndex].move;
-          moves[bestIndex] = moves[movesPicked++];
+          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;
 
   case PH_EVASIONS:
-      assert(pos.is_check());
-      assert(movesPicked >= 0);
+      if (movesPicked < numOfMoves)
+          return moves[movesPicked++].move;
 
-      while (movesPicked < numOfMoves)
-      {
-          bestIndex = find_best_index();
-          move = moves[bestIndex].move;
-          moves[bestIndex] = moves[movesPicked++];
-          return move;
-    }
-    break;
+      break;
 
   case PH_BAD_CAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-      // It's probably a good idea to use SEE move ordering here, instead
-      // of just picking the first move.  FIXME
       while (movesPicked < numOfBadCaptures)
       {
-          move = badCaptures[movesPicked++].move;
+          Move move = badCaptures[movesPicked++].move;
           if (   move != ttMove
               && move != mateKiller
               && pos.pl_move_is_legal(move, pinned))
@@ -396,28 +366,11 @@ Move MovePicker::pick_move_from_list() {
       break;
 
   case PH_QCAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-      while (movesPicked < numOfMoves)
-      {
-          bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked);
-          move = moves[bestIndex].move;
-          moves[bestIndex] = moves[movesPicked++];
-          // Maybe postpone the legality check until after futility pruning?
-          if (   move != ttMove
-              && pos.pl_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;
+          Move move = moves[movesPicked++].move;
+          // Maybe postpone the legality check until after futility pruning?
           if (   move != ttMove
               && pos.pl_move_is_legal(move, pinned))
               return move;
@@ -445,9 +398,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;