the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
+
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/// Variables
- MovePicker::MovegenPhase PhaseTable[32];
+ MovePicker::MovegenPhase PhaseTable[32];
int MainSearchPhaseIndex;
int EvasionsPhaseIndex;
int QsearchWithChecksPhaseIndex;
/// 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) {
+ Move k1, Move k2, Depth d) : pos(p) {
pvNode = pvnode;
ttMove = ttm;
mateKiller = (mk == ttm)? MOVE_NONE : mk;
if (ttMove != MOVE_NONE)
{
assert(move_is_ok(ttMove));
- if (generate_move_if_legal(pos, ttMove, pinned) != MOVE_NONE)
+ if (move_is_legal(pos, ttMove, pinned))
return ttMove;
}
break;
if (mateKiller != MOVE_NONE)
{
assert(move_is_ok(mateKiller));
- if (generate_move_if_legal(pos, mateKiller, pinned) != MOVE_NONE)
+ if (move_is_legal(pos, mateKiller, pinned))
return mateKiller;
}
break;
break;
case PH_EVASIONS:
- assert(pos.is_check());
+ assert(pos.is_check());
numOfMoves = generate_evasions(pos, moves);
score_evasions();
movesPicked = 0;
break;
- case PH_QCAPTURES:
+ case PH_QCAPTURES:
numOfMoves = generate_captures(pos, moves);
score_qcaptures();
movesPicked = 0;
return MOVE_NONE;
}
}
- assert(false);
- return MOVE_NONE;
}
if (m == MOVE_NONE)
finished = true;
- lock_release(&lock);
+ lock_release(&lock);
return m;
}
// 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
- // first usually doesn't hurt. The opponent will have to recapture, and
+ // first usually doesn't hurt. The opponent will have to recapture, and
// the hanging piece will still be hanging (except in the unusual cases
- // where it is possible to recapture with the hanging piece). Exchanging
+ // where it is possible to recapture with the hanging piece). Exchanging
// big pieces before capturing a hanging piece probably helps to reduce
- // the subtree size.
+ // the subtree size. Instead of calculating SEE here to filter out
+ // loosing captures, we delay the filtering in pick_move_from_list()
+ Move m;
+
for (int i = 0; i < numOfMoves; i++)
{
- int seeValue = pos.see(moves[i].move);
- if (seeValue >= 0)
- {
- if (move_promotion(moves[i].move))
- moves[i].score = QueenValueMidgame;
- else
- moves[i].score = int(pos.midgame_value_of_piece_on(move_to(moves[i].move)))
- -int(pos.type_of_piece_on(move_from(moves[i].move)));
- } else
- moves[i].score = seeValue;
+ m = moves[i].move;
+ if (move_promotion(m))
+ moves[i].score = QueenValueMidgame;
+ else
+ moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+ -int(pos.type_of_piece_on(move_from(m)));
}
}
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;
+ int hs;
for (int i = 0; i < numOfMoves; i++)
{
- Move m = moves[i].move;
+ m = moves[i].move;
+
if (m == killer1)
- moves[i].score = HistoryMax + 2;
+ hs = HistoryMax + 2;
else if (m == killer2)
- moves[i].score = HistoryMax + 1;
+ hs = HistoryMax + 1;
else
- moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+ hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+
+ // Ensure moves in history are always sorted as first
+ if (hs > 0)
+ hs += 1000;
+
+ moves[i].score = hs + pos.mg_pst_delta(m);
}
}
moves[i].score = QueenValueMidgame;
else
moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
- -int(pos.midgame_value_of_piece_on(move_to(m))) / 64;
+ -int(pos.type_of_piece_on(move_from(m)));
}
}
-/// find_best_index() loops across the moves and returns index of\r
-/// the highest scored one.\r
-\r
-int MovePicker::find_best_index() {\r
-\r
- int bestScore = -10000000, bestIndex = -1;\r
-\r
- for (int i = movesPicked; i < numOfMoves; i++)\r
- if (moves[i].score > bestScore)\r
- {\r
- bestIndex = i;\r
- bestScore = moves[i].score;\r
- }\r
- return bestIndex;\r
+/// 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;
}
while (movesPicked < numOfMoves)
{
- int bestScore = -10000000;
- bestIndex = -1;
- for (int i = movesPicked; i < numOfMoves; i++)
+ bestIndex = find_best_index();
+
+ if (bestIndex != -1) // Found a possibly good capture
{
- if (moves[i].score < 0)
+ move = moves[bestIndex].move;
+ int seeValue = pos.see(move);
+ if (seeValue < 0)
{
// Losing capture, move it to the badCaptures[] array
assert(numOfBadCaptures < 63);
- badCaptures[numOfBadCaptures++] = moves[i];
- moves[i--] = moves[--numOfMoves];
- }
- else if (moves[i].score > bestScore)
- {
- bestIndex = i;
- bestScore = moves[i].score;
+ moves[bestIndex].score = seeValue;
+ badCaptures[numOfBadCaptures++] = moves[bestIndex];
+ moves[bestIndex] = moves[--numOfMoves];
+ continue;
}
- }
- if (bestIndex != -1) // Found a good capture
- {
- move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller
- && pos.move_is_legal(move, pinned))
+ && pos.pl_move_is_legal(move, pinned))
return move;
}
}
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller
- && pos.move_is_legal(move, pinned))
+ && pos.pl_move_is_legal(move, pinned))
return move;
}
}
move = badCaptures[badCapturesPicked++].move;
if ( move != ttMove
&& move != mateKiller
- && pos.move_is_legal(move, pinned))
+ && pos.pl_move_is_legal(move, pinned))
return move;
}
break;
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.move_is_legal(move, pinned))
+ if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
return move;
}
}
{
move = moves[movesPicked++].move;
// Remember to change the line below if we decide to hash the qsearch!
- if (/* move != ttMove && */ pos.move_is_legal(move, pinned))
+ if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
return move;
}
break;
}
-/// MovePicker::current_move_type() returns the type of the just\r
-/// picked next move. It can be used in search to further differentiate\r
+/// 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 {
projects / stockfish / blobdiff