kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 00:33:09 +00:00
Code Issues Releases Wiki Activity

Space inflate movepick.cpp

Browse source 
Also added some FIXME to dubious points.

Still no functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2008-10-16 14:25:56 +02:00
parent a930aafce0
commit 486ec580f9
2 changed files with 248 additions and 226 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

197
src/movepick.cpp
View file

@ -94,13 +94,16 @@ MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
/// are no more moves left of the types we are interested in. /// are no more moves left of the types we are interested in.
Move MovePicker::get_next_move() { Move MovePicker::get_next_move() {
Move move; Move move;
while(true) { while (true)
{
// If we already have a list of generated moves, pick the best move from // If we already have a list of generated moves, pick the best move from
// the list, and return it: // the list, and return it:
move = this->pick_move_from_list(); move = pick_move_from_list();
if(move != MOVE_NONE) { if (move != MOVE_NONE)
{
assert(move_is_ok(move)); assert(move_is_ok(move));
return move; return move;
} }
@ -110,31 +113,26 @@ Move MovePicker::get_next_move() {
switch (PhaseTable[phaseIndex]) { switch (PhaseTable[phaseIndex]) {
case PH_TT_MOVE: case PH_TT_MOVE:
if(ttMove != MOVE_NONE) { if (ttMove != MOVE_NONE)
{
assert(move_is_ok(ttMove)); assert(move_is_ok(ttMove));
Move m = generate_move_if_legal(*pos, ttMove, pinned); if (generate_move_if_legal(*pos, ttMove, pinned) != MOVE_NONE)
if(m != MOVE_NONE) { return ttMove;
assert(m == ttMove);
return m;
}
} }
break; break;
case PH_MATE_KILLER: case PH_MATE_KILLER:
if(mateKiller != MOVE_NONE) { if (mateKiller != MOVE_NONE)
{
assert(move_is_ok(mateKiller)); assert(move_is_ok(mateKiller));
Move m = generate_move_if_legal(*pos, mateKiller, pinned); if (generate_move_if_legal(*pos, mateKiller, pinned) != MOVE_NONE)
if(m != MOVE_NONE) { return ttMove;
assert(m == mateKiller);
return m;
}
} }
break; break;
case PH_GOOD_CAPTURES: case PH_GOOD_CAPTURES:
// pinned = pos->pinned_pieces(pos->side_to_move());
numOfMoves = generate_captures(*pos, moves); numOfMoves = generate_captures(*pos, moves);
this->score_captures(); score_captures();
movesPicked = 0; movesPicked = 0;
break; break;
@ -144,22 +142,20 @@ Move MovePicker::get_next_move() {
case PH_NONCAPTURES: case PH_NONCAPTURES:
numOfMoves = generate_noncaptures(*pos, moves); numOfMoves = generate_noncaptures(*pos, moves);
this->score_noncaptures(); score_noncaptures();
movesPicked = 0; movesPicked = 0;
break; break;
case PH_EVASIONS: case PH_EVASIONS:
assert(pos->is_check()); assert(pos->is_check());
// pinned = pos->pinned_pieces(pos->side_to_move());
numOfMoves = generate_evasions(*pos, moves); numOfMoves = generate_evasions(*pos, moves);
this->score_evasions(); score_evasions();
movesPicked = 0; movesPicked = 0;
break; break;
case PH_QCAPTURES: case PH_QCAPTURES:
// pinned = pos->pinned_pieces(pos->side_to_move());
numOfMoves = generate_captures(*pos, moves); numOfMoves = generate_captures(*pos, moves);
this->score_qcaptures(); score_qcaptures();
movesPicked = 0; movesPicked = 0;
break; break;
@ -176,7 +172,6 @@ Move MovePicker::get_next_move() {
return MOVE_NONE; return MOVE_NONE;
} }
} }
assert(false); assert(false);
return MOVE_NONE; return MOVE_NONE;
@ -187,32 +182,21 @@ Move MovePicker::get_next_move() {
/// prevent multiple threads from picking the same move at a split point. /// prevent multiple threads from picking the same move at a split point.
Move MovePicker::get_next_move(Lock &lock) { Move MovePicker::get_next_move(Lock &lock) {
Move m;
lock_grab(&lock); lock_grab(&lock);
if(finished) { if (finished)
{
lock_release(&lock); lock_release(&lock);
return MOVE_NONE; return MOVE_NONE;
} }
m = this->get_next_move(); Move m = get_next_move();
if (m == MOVE_NONE) if (m == MOVE_NONE)
finished = true; finished = true;
lock_release(&lock);
lock_release(&lock);
return m; return m;
} }
/// MovePicker::number_of_moves() simply returns the numOfMoves member
/// variable. It is intended to be used in positions where the side to move
/// is in check, for detecting checkmates or situations where there is only
/// a single reply to check.
int MovePicker::number_of_moves() const {
return numOfMoves;
}
/// MovePicker::score_captures(), MovePicker::score_noncaptures(), /// MovePicker::score_captures(), MovePicker::score_noncaptures(),
/// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a /// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
/// numerical move ordering score to each move in a move list. The moves /// numerical move ordering score to each move in a move list. The moves
@ -229,19 +213,17 @@ void MovePicker::score_captures() {
// 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 // big pieces before capturing a hanging piece probably helps to reduce
// the subtree size. // the subtree size.
for(int i = 0; i < numOfMoves; i++) { for (int i = 0; i < numOfMoves; i++)
int seeValue = pos->see(moves[i].move); {
if(seeValue >= 0) { Move m = moves[i].move;
if(move_promotion(moves[i].move)) moves[i].score = pos->see(m);
moves[i].score = QueenValueMidgame; if (moves[i].score >= 0)
else {
moves[i].score = moves[i].score = move_promotion(m) ? QueenValueMidgame
int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) - : int(pos->midgame_value_of_piece_on(move_to(m)))
int(pos->type_of_piece_on(move_from(moves[i].move))); -int(pos->type_of_piece_on(move_from(m)));
// FIXME second term seems wrong !
} }
else
moves[i].score = seeValue;
} }
} }
@ -266,29 +248,34 @@ void MovePicker::score_noncaptures() {
} }
void MovePicker::score_evasions() { void MovePicker::score_evasions() {
for(int i = 0; i < numOfMoves; i++) {
for (int i = 0; i < numOfMoves; i++)
{
Move m = moves[i].move; Move m = moves[i].move;
if (m == ttMove) if (m == ttMove)
moves[i].score = 2*HistoryMax; moves[i].score = 2*HistoryMax;
else if(!pos->square_is_empty(move_to(m))) { else if (!pos->square_is_empty(move_to(m)))
int seeScore = pos->see(m); {
moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore; moves[i].score = pos->see(m);
if (moves[i].score >= 0)
moves[i].score += HistoryMax;
} }
else 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)), m);
} }
// FIXME try psqt also here
} }
void MovePicker::score_qcaptures() { void MovePicker::score_qcaptures() {
// Use MVV/LVA ordering. // Use MVV/LVA ordering.
for(int i = 0; i < numOfMoves; i++) { for (int i = 0; i < numOfMoves; i++)
{
Move m = moves[i].move; Move m = moves[i].move;
if(move_promotion(m)) moves[i].score = move_promotion(m) ? QueenValueMidgame
moves[i].score = QueenValueMidgame; : int(pos->midgame_value_of_piece_on(move_to(m)))
else -int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
moves[i].score = // FIXME Why second term like that ???
int(pos->midgame_value_of_piece_on(move_to(m))) -
int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
} }
} }
@ -302,6 +289,7 @@ void MovePicker::score_qcaptures() {
/// negative SEE values to the badCaptures[] array. /// negative SEE values to the badCaptures[] array.
Move MovePicker::pick_move_from_list() { Move MovePicker::pick_move_from_list() {
int bestScore = -10000000; int bestScore = -10000000;
int bestIndex; int bestIndex;
Move move; Move move;
@ -311,26 +299,32 @@ Move MovePicker::pick_move_from_list() {
case PH_GOOD_CAPTURES: case PH_GOOD_CAPTURES:
assert(!pos->is_check()); assert(!pos->is_check());
assert(movesPicked >= 0); assert(movesPicked >= 0);
while(movesPicked < numOfMoves) { while (movesPicked < numOfMoves)
{
bestScore = -10000000; bestScore = -10000000;
bestIndex = -1; bestIndex = -1;
for(int i = movesPicked; i < numOfMoves; i++) { for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score < 0) { {
if (moves[i].score < 0)
{
// Losing capture, move it to the badCaptures[] array // Losing capture, move it to the badCaptures[] array
assert(numOfBadCaptures < 63); assert(numOfBadCaptures < 63);
badCaptures[numOfBadCaptures++] = moves[i]; badCaptures[numOfBadCaptures++] = moves[i];
moves[i--] = moves[--numOfMoves]; moves[i--] = moves[--numOfMoves];
} }
else if(moves[i].score > bestScore) { else if (moves[i].score > bestScore)
{
bestIndex = i; bestIndex = i;
bestScore = moves[i].score; bestScore = moves[i].score;
} }
} }
if(bestIndex != -1) { // Found a good capture if (bestIndex != -1) // Found a good capture
{
move = moves[bestIndex].move; move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++]; moves[bestIndex] = moves[movesPicked++];
if(move != ttMove && move != mateKiller && if ( move != ttMove
pos->move_is_legal(move, pinned)) && move != mateKiller
&& pos->move_is_legal(move, pinned))
return move; return move;
} }
} }
@ -339,29 +333,32 @@ Move MovePicker::pick_move_from_list() {
case PH_NONCAPTURES: case PH_NONCAPTURES:
assert(!pos->is_check()); assert(!pos->is_check());
assert(movesPicked >= 0); assert(movesPicked >= 0);
while(movesPicked < numOfMoves) { while (movesPicked < numOfMoves)
bestScore = -10000000; {
// If this is a PV node or we have only picked a few moves, scan // 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 // 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 // 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. // anyway, so we just pick the first move from the list.
if(pvNode || movesPicked < 12) { if (pvNode || movesPicked < 12)
{
bestScore = -10000000;
bestIndex = -1; bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++) for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore) { if(moves[i].score > bestScore)
{
bestIndex = i; bestIndex = i;
bestScore = moves[i].score; bestScore = moves[i].score;
} }
} } else
else
bestIndex = movesPicked; bestIndex = movesPicked;
if(bestIndex != -1) { if (bestIndex != -1)
{
move = moves[bestIndex].move; move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++]; moves[bestIndex] = moves[movesPicked++];
if(move != ttMove && move != mateKiller && if ( move != ttMove
pos->move_is_legal(move, pinned)) && move != mateKiller
&& pos->move_is_legal(move, pinned))
return move; return move;
} }
} }
@ -370,16 +367,19 @@ Move MovePicker::pick_move_from_list() {
case PH_EVASIONS: case PH_EVASIONS:
assert(pos->is_check()); assert(pos->is_check());
assert(movesPicked >= 0); assert(movesPicked >= 0);
while(movesPicked < numOfMoves) { while (movesPicked < numOfMoves)
{
bestScore = -10000000; bestScore = -10000000;
bestIndex = -1; bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++) for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore) { if (moves[i].score > bestScore)
{
bestIndex = i; bestIndex = i;
bestScore = moves[i].score; bestScore = moves[i].score;
} }
if(bestIndex != -1) { if (bestIndex != -1)
{
move = moves[bestIndex].move; move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++]; moves[bestIndex] = moves[movesPicked++];
return move; return move;
@ -392,10 +392,12 @@ Move MovePicker::pick_move_from_list() {
assert(badCapturesPicked >= 0); assert(badCapturesPicked >= 0);
// It's probably a good idea to use SEE move ordering here, instead // It's probably a good idea to use SEE move ordering here, instead
// of just picking the first move. FIXME // of just picking the first move. FIXME
while(badCapturesPicked < numOfBadCaptures) { while (badCapturesPicked < numOfBadCaptures)
{
move = badCaptures[badCapturesPicked++].move; move = badCaptures[badCapturesPicked++].move;
if(move != ttMove && move != mateKiller && if ( move != ttMove
pos->move_is_legal(move, pinned)) && move != mateKiller
&& pos->move_is_legal(move, pinned))
return move; return move;
} }
break; break;
@ -403,24 +405,28 @@ Move MovePicker::pick_move_from_list() {
case PH_QCAPTURES: case PH_QCAPTURES:
assert(!pos->is_check()); assert(!pos->is_check());
assert(movesPicked >= 0); assert(movesPicked >= 0);
while(movesPicked < numOfMoves) { while (movesPicked < numOfMoves)
{
bestScore = -10000000; bestScore = -10000000;
if(movesPicked < 4) { if (movesPicked < 4) // FIXME makes sens to score qcaps?
{
bestIndex = -1; bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++) for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore) { if(moves[i].score > bestScore)
{
bestIndex = i; bestIndex = i;
bestScore = moves[i].score; bestScore = moves[i].score;
} }
} } else
else
bestIndex = movesPicked; bestIndex = movesPicked;
if(bestIndex != -1) { if (bestIndex != -1)
{
move = moves[bestIndex].move; move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++]; moves[bestIndex] = moves[movesPicked++];
// Remember to change the line below if we decide to hash the qsearch! // Remember to change the line below if we decide to hash the qsearch!
// Maybe also postpone the legality check until after futility pruning? // Maybe also postpone the legality check until after futility pruning?
// FIXME !!!
if (/* move != ttMove && */ pos->move_is_legal(move, pinned)) if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
return move; return move;
} }
@ -432,9 +438,11 @@ Move MovePicker::pick_move_from_list() {
assert(movesPicked >= 0); assert(movesPicked >= 0);
// Perhaps we should do something better than just picking the first // Perhaps we should do something better than just picking the first
// move here? FIXME // move here? FIXME
while(movesPicked < numOfMoves) { while (movesPicked < numOfMoves)
{
move = moves[movesPicked++].move; move = moves[movesPicked++].move;
// Remember to change the line below if we decide to hash the qsearch! // Remember to change the line below if we decide to hash the qsearch!
// FIXME !!!
if (/* move != ttMove && */ pos->move_is_legal(move, pinned)) if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
return move; return move;
} }
@ -443,20 +451,25 @@ Move MovePicker::pick_move_from_list() {
default: default:
break; break;
} }
return MOVE_NONE; return MOVE_NONE;
} }
/// 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 { MovePicker::MovegenPhase MovePicker::current_move_type() const {
return PhaseTable[phaseIndex]; return PhaseTable[phaseIndex];
} }
/// MovePicker::init_phase_table() initializes the PhaseTable[], /// MovePicker::init_phase_table() initializes the PhaseTable[],
/// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
/// and QsearchWithoutChecksPhaseIndex variables. It is only called once /// and QsearchWithoutChecksPhaseIndex variables. It is only called once
/// during program startup, and never again while the program is running. /// during program startup, and never again while the program is running.
void MovePicker::init_phase_table() { void MovePicker::init_phase_table() {
int i = 0; int i = 0;
// Main search // Main search

9
src/movepick.h
View file

@ -94,6 +94,15 @@ private:
//// Inline functions //// Inline functions
//// ////
/// MovePicker::number_of_moves() simply returns the numOfMoves member
/// variable. It is intended to be used in positions where the side to move
/// is in check, for detecting checkmates or situations where there is only
/// a single reply to check.
inline int MovePicker::number_of_moves() const {
return numOfMoves;
}
/// MovePicker::discovered_check_candidates() returns a bitboard containing /// MovePicker::discovered_check_candidates() returns a bitboard containing
/// all pieces which can possibly give discovered check. This bitboard is /// all pieces which can possibly give discovered check. This bitboard is
/// computed by the constructor function. /// computed by the constructor function.