X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.cpp;h=3897f4c10048bf7c164d67c4c2e9858e597c3994;hp=1519f85d04388c1b24940a31c4babf65ea33f7e0;hb=ce5d9eb19da890c77d8ef00e078c60edc3e8e4aa;hpb=2ed22e4fc80313f69cbdfe0a617a70188813b16e diff --git a/src/movepick.cpp b/src/movepick.cpp index 1519f85d..3897f4c1 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,9 +23,11 @@ //// Includes //// +#include #include #include "history.h" +#include "evaluate.h" #include "movegen.h" #include "movepick.h" #include "search.h" @@ -49,7 +51,6 @@ namespace { } - //// //// Functions //// @@ -62,29 +63,31 @@ 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 pvnode, Move ttm, Move mk, - Move k1, Move k2, Depth d) : pos(p) { - pvNode = pvnode; +MovePicker::MovePicker(const Position& p, bool pv, Move ttm, + const SearchStack& ss, Depth d) : pos(p) { + pvNode = pv; ttMove = ttm; - mateKiller = (mk == ttm)? MOVE_NONE : mk; - killer1 = k1; - killer2 = k2; + mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller; + killer1 = ss.killers[0]; + killer2 = ss.killers[1]; depth = d; movesPicked = 0; numOfMoves = 0; numOfBadCaptures = 0; - dc = p.discovered_check_candidates(p.side_to_move()); if (p.is_check()) - phaseIndex = EvasionsPhaseIndex; + phaseIndex = EvasionsPhaseIndex; else if (depth > Depth(0)) - phaseIndex = MainSearchPhaseIndex; + phaseIndex = MainSearchPhaseIndex; else if (depth == Depth(0)) - phaseIndex = QsearchWithChecksPhaseIndex; + phaseIndex = QsearchWithChecksPhaseIndex; else - phaseIndex = QsearchWithoutChecksPhaseIndex; + phaseIndex = QsearchWithoutChecksPhaseIndex; + + Color us = pos.side_to_move(); - pinned = p.pinned_pieces(p.side_to_move()); + dc = p.discovered_check_candidates(us); + pinned = p.pinned_pieces(us); finished = false; } @@ -128,41 +131,46 @@ 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(); - capSquares = EmptyBoardBB; + std::sort(moves, moves + numOfMoves); movesPicked = 0; break; case PH_BAD_CAPTURES: - badCapturesPicked = 0; + // It's probably a good idea to use SEE move ordering here. FIXME + movesPicked = 0; break; case PH_NONCAPTURES: numOfMoves = generate_noncaptures(pos, moves); score_noncaptures(); + std::sort(moves, moves + numOfMoves); 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; @@ -256,12 +264,13 @@ void MovePicker::score_noncaptures() { 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 moves in history are always sorted as first + // Ensure history is always preferred to pst if (hs > 0) hs += 1000; + // pst based scoring moves[i].score = hs + pos.mg_pst_delta(m); } } @@ -278,9 +287,8 @@ 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)); } - // FIXME try psqt also here } void MovePicker::score_qcaptures() { @@ -298,63 +306,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 @@ -362,79 +313,34 @@ 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_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 + && pos.pl_move_is_legal(move, pinned)) + return move; } break; case PH_EVASIONS: - assert(pos.is_check()); - assert(movesPicked >= 0); - - while (movesPicked < numOfMoves) - { - bestIndex = find_best_index(); + if (movesPicked < numOfMoves) + return moves[movesPicked++].move; - 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)) @@ -443,34 +349,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; @@ -482,19 +367,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 -/// and QsearchWithoutChecksPhaseIndex 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() { @@ -519,12 +395,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 without checks QsearchWithoutChecksPhaseIndex = i - 1; + PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_STOP; }