/// search captures, promotions and some checks) and about how important good
/// move ordering is at the current node.
-MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
- Move k1, Move k2, Depth dpth) {
- pos = &p;
+MovePicker::MovePicker(const Position& p, bool pvnode, Move ttm, Move mk,
+ Move k1, Move k2, Depth d) : pos(p) {
pvNode = pvnode;
ttMove = ttm;
mateKiller = (mk == ttm)? MOVE_NONE : mk;
killer1 = k1;
killer2 = k2;
- depth = dpth;
+ depth = d;
movesPicked = 0;
numOfMoves = 0;
numOfBadCaptures = 0;
dc = p.discovered_check_candidates(p.side_to_move());
- if(p.is_check())
+ if (p.is_check())
phaseIndex = EvasionsPhaseIndex;
- else if(depth > Depth(0))
+ else if (depth > Depth(0))
phaseIndex = MainSearchPhaseIndex;
- else if(depth == Depth(0))
+ else if (depth == Depth(0))
phaseIndex = QsearchWithChecksPhaseIndex;
else
phaseIndex = QsearchWithoutChecksPhaseIndex;
while (true)
{
// If we already have a list of generated moves, pick the best move from
- // the list, and return it:
+ // the list, and return it.
move = pick_move_from_list();
if (move != MOVE_NONE)
{
return move;
}
- // Next phase:
+ // Next phase
phaseIndex++;
switch (PhaseTable[phaseIndex]) {
if (ttMove != MOVE_NONE)
{
assert(move_is_ok(ttMove));
- if (generate_move_if_legal(*pos, ttMove, pinned) != MOVE_NONE)
+ if (generate_move_if_legal(pos, ttMove, pinned) != MOVE_NONE)
return ttMove;
}
break;
if (mateKiller != MOVE_NONE)
{
assert(move_is_ok(mateKiller));
- if (generate_move_if_legal(*pos, mateKiller, pinned) != MOVE_NONE)
- return ttMove;
+ if (generate_move_if_legal(pos, mateKiller, pinned) != MOVE_NONE)
+ return mateKiller;
}
break;
case PH_GOOD_CAPTURES:
- numOfMoves = generate_captures(*pos, moves);
+ numOfMoves = generate_captures(pos, moves);
score_captures();
movesPicked = 0;
break;
break;
case PH_NONCAPTURES:
- numOfMoves = generate_noncaptures(*pos, moves);
+ numOfMoves = generate_noncaptures(pos, moves);
score_noncaptures();
movesPicked = 0;
break;
case PH_EVASIONS:
- assert(pos->is_check());
- numOfMoves = generate_evasions(*pos, moves);
+ assert(pos.is_check());
+ numOfMoves = generate_evasions(pos, moves);
score_evasions();
movesPicked = 0;
break;
case PH_QCAPTURES:
- numOfMoves = generate_captures(*pos, moves);
+ numOfMoves = generate_captures(pos, moves);
score_qcaptures();
movesPicked = 0;
break;
case PH_QCHECKS:
- numOfMoves = generate_checks(*pos, moves, dc);
+ numOfMoves = generate_checks(pos, moves, dc);
movesPicked = 0;
break;
/// 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
-/// with highest scores will be picked first by
-/// MovePicker::pick_move_from_list().
+/// with highest scores will be picked first by pick_move_from_list().
void MovePicker::score_captures() {
- // Winning and equal captures in the main search are ordered by MVV/LVA.
+ // Winning and equal captures in the main search are ordered by MVV.
// Suprisingly, this appears to perform slightly better than SEE based
// move ordering. The reason is probably that in a position with a winning
// capture, capturing a more valuable (but sufficiently defended) piece
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 !
- }
+ moves[i].score = pos.see(m);
+ //if (moves[i].score >= 0)
+ // moves[i].score = move_promotion(m) ? QueenValueMidgame
+ // : pos.midgame_value_of_piece_on(move_to(m));
}
}
else if (m == killer2)
moves[i].score = HistoryMax + 1;
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)), m);
// Ensure moves in history are always sorted as first
if (moves[i].score > 0)
moves[i].score += 1000;
- moves[i].score += pos->mg_pst_delta(moves[i].move);
+ moves[i].score += pos.mg_pst_delta(moves[i].move);
}
}
Move m = moves[i].move;
if (m == ttMove)
moves[i].score = 2*HistoryMax;
- else if (!pos->square_is_empty(move_to(m)))
+ else if (!pos.square_is_empty(move_to(m)))
{
- moves[i].score = pos->see(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);
+ 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.
+ // Use MVV ordering
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 ???
+ : pos.midgame_value_of_piece_on(move_to(m));
}
}
+/// find_best_index() loops across the moves and returns index of
+/// the highest scored one.
+
+int MovePicker::find_best_index() {
+
+ int bestScore = -10000000, bestIndex = -1;
+
+ for (int i = movesPicked; 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
Move MovePicker::pick_move_from_list() {
- int bestScore = -10000000;
int bestIndex;
Move move;
switch (PhaseTable[phaseIndex]) {
case PH_GOOD_CAPTURES:
- assert(!pos->is_check());
+ assert(!pos.is_check());
assert(movesPicked >= 0);
while (movesPicked < numOfMoves)
{
- bestScore = -10000000;
+ int bestScore = -10000000;
bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++)
{
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller
- && pos->move_is_legal(move, pinned))
+ && pos.move_is_legal(move, pinned))
return move;
}
}
break;
case PH_NONCAPTURES:
- assert(!pos->is_check());
+ assert(!pos.is_check());
assert(movesPicked >= 0);
while (movesPicked < numOfMoves)
{
// 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;
+ bestIndex = (movesPicked < 12 || pvNode ? find_best_index() : movesPicked);
if (bestIndex != -1)
{
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller
- && pos->move_is_legal(move, pinned))
+ && pos.move_is_legal(move, pinned))
return move;
}
}
break;
case PH_EVASIONS:
- assert(pos->is_check());
+ 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;
- }
+ bestIndex = find_best_index();
if (bestIndex != -1)
{
break;
case PH_BAD_CAPTURES:
- assert(!pos->is_check());
+ 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
move = badCaptures[badCapturesPicked++].move;
if ( move != ttMove
&& move != mateKiller
- && pos->move_is_legal(move, pinned))
+ && pos.move_is_legal(move, pinned))
return move;
}
break;
case PH_QCAPTURES:
- assert(!pos->is_check());
+ 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;
+ // FIXME makes sens to score qcaps?
+ bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked);
if (bestIndex != -1)
{
move = moves[bestIndex].move;\r
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))
+ if (move != ttMove && pos.move_is_legal(move, pinned))
return move;
}
}
break;
case PH_QCHECKS:
- assert(!pos->is_check());
+ 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))
+ move = moves[movesPicked++].move;
+ if (move != ttMove && pos.move_is_legal(move, pinned))
return move;
}
break;
/// 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];
}
projects / stockfish / blobdiff