X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.cpp;h=3897f4c10048bf7c164d67c4c2e9858e597c3994;hb=20c2a314642b8fb911a8e00895544581d4ee2dda;hp=fb218f3d6c26a7a52bdc43744f4d8a5365026ff6;hpb=e68ebe618c82aa2e22016d1e9474861162914002;p=stockfish diff --git a/src/movepick.cpp b/src/movepick.cpp index fb218f3d..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,6 +23,7 @@ //// Includes //// +#include #include #include "history.h" @@ -136,16 +137,19 @@ Move MovePicker::get_next_move() { case PH_GOOD_CAPTURES: numOfMoves = generate_captures(pos, moves); score_captures(); + std::sort(moves, moves + numOfMoves); movesPicked = 0; break; case PH_BAD_CAPTURES: + // 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; @@ -153,17 +157,20 @@ Move MovePicker::get_next_move() { assert(pos.is_check()); 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; @@ -257,7 +264,7 @@ 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 history is always preferred to pst if (hs > 0) @@ -280,7 +287,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)); } } @@ -299,67 +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() { - - assert(movesPicked < numOfMoves); - - int bestIndex = movesPicked, bestScore = moves[movesPicked].score; - - for (int i = movesPicked + 1; 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[]) { - - assert(movesPicked < numOfMoves); - - 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 @@ -367,40 +313,17 @@ 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(); - 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_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; - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; + Move move = moves[movesPicked++].move; if ( move != ttMove && move != mateKiller && pos.pl_move_is_legal(move, pinned)) @@ -409,26 +332,15 @@ Move MovePicker::pick_move_from_list() { 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(); - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - 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)) @@ -437,28 +349,11 @@ 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); - move = moves[bestIndex].move; - moves[bestIndex] = moves[movesPicked++]; - // 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; @@ -510,5 +405,4 @@ void MovePicker::init_phase_table() { PhaseTable[i++] = PH_TT_MOVE; PhaseTable[i++] = PH_QCAPTURES; PhaseTable[i++] = PH_STOP; - }