namespace {
enum Stages {
- MAIN_SEARCH, GOOD_CAPTURES_INIT, GOOD_CAPTURES, KILLERS, KILLERS_2,
- QUIET_INIT, QUIET, BAD_CAPTURES,
- EVASION, ALL_EVASIONS,
- QSEARCH_WITH_CHECKS, QCAPTURES_CHECKS_INIT, QCAPTURES_CHECKS, CHECKS,
- QSEARCH_WITHOUT_CHECKS, QCAPTURES_NO_CHECKS, REMAINING,
- RECAPTURE, RECAPTURES,
- PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES
+ MAIN_SEARCH, CAPTURES_INIT, GOOD_CAPTURES, KILLERS, COUNTERMOVE, QUIET_INIT, QUIET, BAD_CAPTURES,
+ EVASION, EVASIONS_INIT, ALL_EVASIONS,
+ PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES,
+ QSEARCH_WITH_CHECKS, QCAPTURES_1_INIT, QCAPTURES_1, QCHECKS,
+ QSEARCH_NO_CHECKS, QCAPTURES_2_INIT, QCAPTURES_2,
+ QSEARCH_RECAPTURES, QRECAPTURES
};
// Our insertion sort, which is guaranteed to be stable, as it should be
stage = QSEARCH_WITH_CHECKS;
else if (d > DEPTH_QS_RECAPTURES)
- stage = QSEARCH_WITHOUT_CHECKS;
+ stage = QSEARCH_NO_CHECKS;
else
{
- stage = RECAPTURE;
+ stage = QSEARCH_RECAPTURES;
recaptureSquare = s;
return;
}
m.value = history[pos.moved_piece(m)][to_sq(m)] + fromTo.get(c, m);
}
-int MovePicker::see_sign() const
-{
- return stage == GOOD_CAPTURES ? 1
- : stage == BAD_CAPTURES ? -1 : 0;
-}
/// next_move() is the most important method of the MovePicker class. It returns
/// a new pseudo legal move every time it is called, until there are no more moves
switch (stage) {
case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS:
- case QSEARCH_WITHOUT_CHECKS: case PROBCUT:
+ case QSEARCH_NO_CHECKS: case PROBCUT:
++stage;
return ttMove;
- case GOOD_CAPTURES_INIT:
+ case CAPTURES_INIT:
endBadCaptures = cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
*endBadCaptures++ = move;
}
}
- ++stage;
- // First killer move
- move = ss->killers[0];
+ ++stage;
+ move = ss->killers[0]; // First killer move
if ( move != MOVE_NONE
&& move != ttMove
&& pos.pseudo_legal(move)
&& !pos.capture(move))
return move;
- case KILLERS_2:
+ case COUNTERMOVE:
++stage;
move = countermove;
if ( move != MOVE_NONE
return *cur++;
break;
- case ALL_EVASIONS:
+ case EVASIONS_INIT:
cur = moves;
endMoves = generate<EVASIONS>(pos, cur);
- if (endMoves - cur > 1)
+ if (endMoves - cur - (ttMove != MOVE_NONE) > 1)
score<EVASIONS>();
- stage = REMAINING;
- goto remaining;
-
- case QCAPTURES_CHECKS_INIT:
- case QCAPTURES_NO_CHECKS:
- cur = moves;
- endMoves = generate<CAPTURES>(pos, cur);
- score<CAPTURES>();
++stage;
-remaining:
- case QCAPTURES_CHECKS:
- case REMAINING:
+ case ALL_EVASIONS:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
if (move != ttMove)
return move;
}
- if (stage == REMAINING)
- break;
+ break;
+
+ case PROBCUT_INIT:
cur = moves;
- endMoves = generate<QUIET_CHECKS>(pos, cur);
+ endMoves = generate<CAPTURES>(pos, cur);
+ score<CAPTURES>();
++stage;
- case CHECKS:
+ case PROBCUT_CAPTURES:
while (cur < endMoves)
{
- move = cur++->move;
- if (move != ttMove)
+ move = pick_best(cur++, endMoves);
+ if ( move != ttMove
+ && pos.see(move) > threshold)
return move;
}
break;
- case RECAPTURE:
+ case QCAPTURES_1_INIT: case QCAPTURES_2_INIT:
cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
++stage;
- case RECAPTURES:
+ case QCAPTURES_1: case QCAPTURES_2:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
- if (to_sq(move) == recaptureSquare)
+ if (move != ttMove)
+ return move;
+ }
+ if (stage == QCAPTURES_2)
+ break;
+ cur = moves;
+ endMoves = generate<QUIET_CHECKS>(pos, cur);
+ ++stage;
+
+ case QCHECKS:
+ while (cur < endMoves)
+ {
+ move = cur++->move;
+ if (move != ttMove)
return move;
}
break;
- case PROBCUT_INIT:
+ case QSEARCH_RECAPTURES:
cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
++stage;
- case PROBCUT_CAPTURES:
+ case QRECAPTURES:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
- if ( move != ttMove
- && pos.see(move) > threshold)
+ if (to_sq(move) == recaptureSquare)
return move;
}
break;