X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.cpp;h=25cbdefd0b10a1b23e9674a35b09776c6bebe98e;hb=2a461b4b745b2542f6e13bab8c60abdb366bc128;hp=d0c1b587bd5d7b3ef3973b7e92c1ad9983393b76;hpb=4e151f7e0d70b9a61ac5adba269a80555133cb73;p=stockfish diff --git a/src/movepick.cpp b/src/movepick.cpp index d0c1b587..25cbdefd 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 @@ -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,17 +141,32 @@ Move MovePicker::get_next_move() { 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; case PH_EVASIONS: @@ -168,6 +185,7 @@ Move MovePicker::get_next_move() { break; case PH_QCHECKS: + // Perhaps we should order moves move here? FIXME numOfMoves = generate_non_capture_checks(pos, moves, dc); movesPicked = 0; break; @@ -226,10 +244,10 @@ void MovePicker::score_captures() { for (int i = 0; i < numOfMoves; i++) { m = moves[i].move; - seeValue = pos.see(m); + seeValue = pos.see_sign(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))) @@ -250,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)), 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(piece, from, to); } } @@ -285,7 +300,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)); } } @@ -295,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))) @@ -311,57 +326,36 @@ void MovePicker::score_qcaptures() { Move MovePicker::pick_move_from_list() { - 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) - { - move = moves[movesPicked++].move; - 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) { - move = moves[movesPicked++].move; + 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) - { - move = moves[movesPicked++].move; - 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)) @@ -370,27 +364,11 @@ Move MovePicker::pick_move_from_list() { break; case PH_QCAPTURES: - assert(!pos.is_check()); - assert(movesPicked >= 0); - - while (movesPicked < numOfMoves) - { - 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; - } - 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; @@ -418,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;