// 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
// big pieces before capturing a hanging piece probably helps to reduce
- // the subtree size. Instead of calculating SEE here to filter out
- // loosing captures, we delay the filtering in pick_move_from_list()
+ // the subtree size.
Move m;
+ int seeValue;
for (int i = 0; i < numOfMoves; i++)
{
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)));
+ seeValue = pos.see(m);
+ if (seeValue >= 0)
+ {
+ 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)));
+ } else
+ moves[i].score = seeValue;
}
}
}
}
-void MovePicker::score_evasions() {\r
-\r
- Move m;\r
- int hs;\r
-\r
- // Use MVV/LVA ordering\r
- for (int i = 0; i < numOfMoves; i++)\r
- {\r
- m = moves[i].move;\r
-\r
- if (m == ttMove)\r
- hs = 2*HistoryMax;\r
- else if (!pos.square_is_empty(move_to(m)))\r
- hs = int(pos.midgame_value_of_piece_on(move_to(m)))\r
- -int(pos.type_of_piece_on(move_from(m))) + HistoryMax;\r
- else\r
- hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);\r
-\r
- moves[i].score = hs;\r
- }\r
+void MovePicker::score_evasions() {
+
+ for (int i = 0; i < numOfMoves; i++)
+ {
+ Move m = moves[i].move;
+ if (m == ttMove)
+ moves[i].score = 2*HistoryMax;
+ else if (!pos.square_is_empty(move_to(m)))
+ {
+ 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);
+ }
+ // FIXME try psqt also here
}
void MovePicker::score_qcaptures() {
while (movesPicked < numOfMoves)
{
- bestIndex = find_best_index();
-
- if (bestIndex != -1) // Found a possibly good capture
+ int bestScore = -10000000;
+ bestIndex = -1;
+ for (int i = movesPicked; i < numOfMoves; i++)
{
- move = moves[bestIndex].move;
- int seeValue = pos.see(move);
- if (seeValue < 0)
+ if (moves[i].score < 0)
{
// Losing capture, move it to the badCaptures[] array
assert(numOfBadCaptures < 63);
- moves[bestIndex].score = seeValue;
- badCaptures[numOfBadCaptures++] = moves[bestIndex];
- moves[bestIndex] = moves[--numOfMoves];
- continue;
+ badCaptures[numOfBadCaptures++] = moves[i];
+ moves[i--] = moves[--numOfMoves];
}
+ else if (moves[i].score > bestScore)
+ {
+ bestIndex = i;
+ bestScore = moves[i].score;
+ }
+ }
+ if (bestIndex != -1) // Found a good capture
+ {
+ move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller