X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=7b2479fca6135574ec5aa0c645afb34532849d2b;hp=d4242a300de7620e5f58665cb20c7e5ff0aa102c;hb=bafb9f1a25204d06960a44f0637736edce233629;hpb=db1b0bfa1d8391281e5e0b1f93564a1e52c41ed2 diff --git a/src/movepick.cpp b/src/movepick.cpp index d4242a30..7b2479fc 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 #include #include "history.h" @@ -45,14 +46,11 @@ namespace { int MainSearchPhaseIndex; int EvasionsPhaseIndex; int QsearchWithChecksPhaseIndex; - int QsearchNoCapturesPhaseIndex; int QsearchWithoutChecksPhaseIndex; - int NoMovesPhaseIndex; } - //// //// Functions //// @@ -66,7 +64,7 @@ namespace { /// move ordering is at the current node. MovePicker::MovePicker(const Position& p, bool pv, Move ttm, - const SearchStack& ss, Depth d, EvalInfo* ei) : pos(p) { + const SearchStack& ss, Depth d) : pos(p) { pvNode = pv; ttMove = ttm; mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller; @@ -76,28 +74,21 @@ MovePicker::MovePicker(const Position& p, bool pv, Move ttm, movesPicked = 0; numOfMoves = 0; numOfBadCaptures = 0; - - // With EvalInfo we are able to know how many captures are possible before - // generating them. So avoid generating in case we know are zero. - Color us = pos.side_to_move(); - Color them = opposite_color(us); - bool noCaptures = ei - && (ei->attackedBy[us][0] & pos.pieces_of_color(them)) == 0 - && !ei->mi->specialized_eval_exists() - && (pos.ep_square() == SQ_NONE) - && !pos.has_pawn_on_7th(us); + checkKillers = checkLegal = false; if (p.is_check()) phaseIndex = EvasionsPhaseIndex; else if (depth > Depth(0)) phaseIndex = MainSearchPhaseIndex; else if (depth == Depth(0)) - phaseIndex = (noCaptures ? QsearchNoCapturesPhaseIndex : QsearchWithChecksPhaseIndex); + phaseIndex = QsearchWithChecksPhaseIndex; else - phaseIndex = (noCaptures ? NoMovesPhaseIndex : QsearchWithoutChecksPhaseIndex); + phaseIndex = QsearchWithoutChecksPhaseIndex; + + Color us = pos.side_to_move(); dc = p.discovered_check_candidates(us); - pinned = p.pinned_pieces(p.side_to_move()); + pinned = p.pinned_pieces(us); finished = false; } @@ -141,40 +132,60 @@ Move MovePicker::get_next_move() { assert(move_is_ok(mateKiller)); if (move_is_legal(pos, mateKiller, pinned)) return mateKiller; - } - break; + } + break; 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: - badCapturesPicked = 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: assert(pos.is_check()); - numOfMoves = generate_evasions(pos, moves); + 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: - numOfMoves = generate_checks(pos, moves, dc); + // Perhaps we should order moves move here? FIXME + numOfMoves = generate_non_capture_checks(pos, moves, dc); movesPicked = 0; break; @@ -262,13 +273,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) @@ -291,7 +296,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)); } } @@ -310,63 +315,6 @@ void MovePicker::score_qcaptures() { } -/// find_best_index() loops across the moves and returns index of -/// the highest scored one. There is also a second version that -/// lowers the priority of moves that attack the same square, -/// so that if the best move that attack a square fails the next -/// move picked attacks a different square if any, not the same 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; -} - -int MovePicker::find_best_index(Bitboard* squares, int values[]) { - - int hs; - Move m; - Square to; - int bestScore = -10000000, bestIndex = -1; - - for (int i = movesPicked; i < numOfMoves; i++) - { - m = moves[i].move; - to = move_to(m); - - if (!bit_is_set(*squares, to)) - { - // Init at first use - set_bit(squares, to); - values[to] = 0; - } - - hs = moves[i].score - values[to]; - if (hs > bestScore) - { - bestIndex = i; - bestScore = hs; - } - } - - if (bestIndex != -1) - { - // Raise value of the picked square, so next attack - // to the same square will get low priority. - to = move_to(moves[bestIndex].move); - values[to] += 0xB00; - } - 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 @@ -374,79 +322,36 @@ int MovePicker::find_best_index(Bitboard* squares, int values[]) { 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(); - - if (bestIndex != -1) // Found a good capture - { - 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_GOOD_CAPTURES: + 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; - - if (bestIndex != -1) - { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - if ( move != ttMove - && move != mateKiller - && pos.pl_move_is_legal(move, pinned)) - return move; - } + Move move = moves[movesPicked++].move; + if ( move != ttMove + && move != mateKiller + && (!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(); - - if (bestIndex != -1) - { - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - return move; - } - } - break; + break; case PH_BAD_CAPTURES: - 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 - while (badCapturesPicked < numOfBadCaptures) + while (movesPicked < numOfBadCaptures) { - move = badCaptures[badCapturesPicked++].move; + Move move = badCaptures[movesPicked++].move; if ( move != ttMove && move != mateKiller && pos.pl_move_is_legal(move, pinned)) @@ -455,34 +360,13 @@ 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); - - if (bestIndex != -1) - { - move = moves[bestIndex].move; - 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? - 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; - // Remember to change the line below if we decide to hash the qsearch! - if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned)) + 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; } break; @@ -494,20 +378,10 @@ Move MovePicker::pick_move_from_list() { } -/// MovePicker::current_move_type() returns the type of the just -/// 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]; -} - - /// MovePicker::init_phase_table() initializes the PhaseTable[], /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex -/// QsearchNoCapturesPhaseIndex, QsearchWithoutChecksPhaseIndex and -/// NoMovesPhaseIndex variables. It is only called once during program -/// startup, and never again while the program is running. +/// and QsearchWithoutChecksPhaseIndex. It is only called once during +/// program startup, and never again while the program is running. void MovePicker::init_phase_table() { @@ -518,9 +392,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; @@ -532,21 +404,14 @@ void MovePicker::init_phase_table() { // Quiescence search with checks QsearchWithChecksPhaseIndex = i - 1; + PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_QCHECKS; PhaseTable[i++] = PH_STOP; - // Quiescence search with checks only and no captures - QsearchNoCapturesPhaseIndex = i - 1; - PhaseTable[i++] = PH_QCHECKS; - PhaseTable[i++] = PH_STOP; - // Quiescence search without checks QsearchWithoutChecksPhaseIndex = i - 1; + PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_STOP; - - // Do not generate any move - NoMovesPhaseIndex = i - 1; - PhaseTable[i++] = PH_STOP; }