kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-11 19:49:14 +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

465
src/movepick.cpp
View file

@ -94,89 +94,84 @@ 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)); {
return move; assert(move_is_ok(move));
return move;
} }
// Next phase: // Next phase:
phaseIndex++; phaseIndex++;
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)); {
Move m = generate_move_if_legal(*pos, ttMove, pinned); assert(move_is_ok(ttMove));
if(m != MOVE_NONE) { if (generate_move_if_legal(*pos, ttMove, pinned) != MOVE_NONE)
assert(m == ttMove); return 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)); {
Move m = generate_move_if_legal(*pos, mateKiller, pinned); assert(move_is_ok(mateKiller));
if(m != MOVE_NONE) { if (generate_move_if_legal(*pos, mateKiller, pinned) != MOVE_NONE)
assert(m == mateKiller); return ttMove;
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); score_captures();
this->score_captures(); movesPicked = 0;
movesPicked = 0; break;
break;
case PH_BAD_CAPTURES: case PH_BAD_CAPTURES:
badCapturesPicked = 0; badCapturesPicked = 0;
break; break;
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); score_evasions();
this->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); score_qcaptures();
this->score_qcaptures(); movesPicked = 0;
movesPicked = 0; break;
break;
case PH_QCHECKS: case PH_QCHECKS:
numOfMoves = generate_checks(*pos, moves, dc); numOfMoves = generate_checks(*pos, moves, dc);
movesPicked = 0; movesPicked = 0;
break; break;
case PH_STOP: case PH_STOP:
return MOVE_NONE; return MOVE_NONE;
default: default:
assert(false); assert(false);
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); {
return MOVE_NONE; lock_release(&lock);
} return MOVE_NONE;
m = this->get_next_move(); }
if(m == MOVE_NONE) Move m = get_next_move();
finished = true; if (m == MOVE_NONE)
lock_release(&lock); finished = true;
return m; lock_release(&lock);
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++) {
Move m = moves[i].move; for (int i = 0; i < numOfMoves; i++)
if(m == ttMove) {
moves[i].score = 2*HistoryMax; Move m = moves[i].move;
else if(!pos->square_is_empty(move_to(m))) { if (m == ttMove)
int seeScore = pos->see(m); moves[i].score = 2*HistoryMax;
moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore; else if (!pos->square_is_empty(move_to(m)))
} {
else moves[i].score = pos->see(m);
moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m); if (moves[i].score >= 0)
moves[i].score += HistoryMax;
}
else
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; {
if(move_promotion(m)) Move m = moves[i].move;
moves[i].score = QueenValueMidgame; moves[i].score = move_promotion(m) ? QueenValueMidgame
else : int(pos->midgame_value_of_piece_on(move_to(m)))
moves[i].score = -int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
int(pos->midgame_value_of_piece_on(move_to(m))) - // FIXME Why second term like that ???
int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
} }
} }
@ -302,161 +289,187 @@ 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;
switch(PhaseTable[phaseIndex]) { switch (PhaseTable[phaseIndex]) {
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; {
bestIndex = -1; bestScore = -10000000;
for(int i = movesPicked; i < numOfMoves; i++) { bestIndex = -1;
if(moves[i].score < 0) { for (int i = movesPicked; i < numOfMoves; i++)
// Losing capture, move it to the badCaptures[] array {
assert(numOfBadCaptures < 63); if (moves[i].score < 0)
badCaptures[numOfBadCaptures++] = moves[i]; {
moves[i--] = moves[--numOfMoves]; // Losing capture, move it to the badCaptures[] array
} assert(numOfBadCaptures < 63);
else if(moves[i].score > bestScore) { badCaptures[numOfBadCaptures++] = moves[i];
bestIndex = i; moves[i--] = moves[--numOfMoves];
bestScore = moves[i].score; }
} else if (moves[i].score > bestScore)
} {
if(bestIndex != -1) { // Found a good capture bestIndex = i;
move = moves[bestIndex].move; bestScore = moves[i].score;
moves[bestIndex] = moves[movesPicked++]; }
if(move != ttMove && move != mateKiller && }
pos->move_is_legal(move, pinned)) if (bestIndex != -1) // Found a good capture
return move; {
} move = moves[bestIndex].move;
} moves[bestIndex] = moves[movesPicked++];
break; if ( move != ttMove
&& move != mateKiller
case PH_NONCAPTURES: && pos->move_is_legal(move, pinned))
assert(!pos->is_check()); return move;
assert(movesPicked >= 0);
while(movesPicked < numOfMoves) {
bestScore = -10000000;
// 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.
if(pvNode || movesPicked < 12) {
bestIndex = -1;
for(int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore) {
bestIndex = i;
bestScore = moves[i].score;
} }
} }
else break;
bestIndex = movesPicked;
if(bestIndex != -1) { case PH_NONCAPTURES:
move = moves[bestIndex].move; assert(!pos->is_check());
moves[bestIndex] = moves[movesPicked++]; assert(movesPicked >= 0);
if(move != ttMove && move != mateKiller && while (movesPicked < numOfMoves)
pos->move_is_legal(move, pinned)) {
return move; // 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.
if (pvNode || movesPicked < 12)
{
bestScore = -10000000;
bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore)
{
bestIndex = i;
bestScore = moves[i].score;
}
} else
bestIndex = movesPicked;
if (bestIndex != -1)
{
move = moves[bestIndex].move;
moves[bestIndex] = moves[movesPicked++];
if ( move != ttMove
&& move != mateKiller
&& pos->move_is_legal(move, pinned))
return move;
}
} }
break; break;
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; {
bestIndex = -1; bestScore = -10000000;
for(int i = movesPicked; i < numOfMoves; i++) bestIndex = -1;
if(moves[i].score > bestScore) { for (int i = movesPicked; i < numOfMoves; i++)
bestIndex = i; if (moves[i].score > bestScore)
bestScore = moves[i].score; {
} bestIndex = i;
bestScore = moves[i].score;
}
if(bestIndex != -1) { if (bestIndex != -1)
move = moves[bestIndex].move; {
moves[bestIndex] = moves[movesPicked++]; move = moves[bestIndex].move;
return move; moves[bestIndex] = moves[movesPicked++];
} return move;
}
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) {
move = badCaptures[badCapturesPicked++].move;
if(move != ttMove && move != mateKiller &&
pos->move_is_legal(move, pinned))
return move;
}
break;
case PH_QCAPTURES:
assert(!pos->is_check());
assert(movesPicked >= 0);
while(movesPicked < numOfMoves) {
bestScore = -10000000;
if(movesPicked < 4) {
bestIndex = -1;
for(int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore) {
bestIndex = i;
bestScore = moves[i].score;
} }
} }
else break;
bestIndex = movesPicked;
if(bestIndex != -1) { case PH_BAD_CAPTURES:
move = moves[bestIndex].move; assert(!pos->is_check());
moves[bestIndex] = moves[movesPicked++]; assert(badCapturesPicked >= 0);
// Remember to change the line below if we decide to hash the qsearch! // It's probably a good idea to use SEE move ordering here, instead
// Maybe also postpone the legality check until after futility pruning? // of just picking the first move. FIXME
if(/* move != ttMove && */ pos->move_is_legal(move, pinned)) while (badCapturesPicked < numOfBadCaptures)
return move; {
move = badCaptures[badCapturesPicked++].move;
if ( move != ttMove
&& move != mateKiller
&& pos->move_is_legal(move, pinned))
return move;
} }
} break;
break;
case PH_QCAPTURES:
assert(!pos->is_check());
assert(movesPicked >= 0);
while (movesPicked < numOfMoves)
{
bestScore = -10000000;
if (movesPicked < 4) // FIXME makes sens to score qcaps?
{
bestIndex = -1;
for (int i = movesPicked; i < numOfMoves; i++)
if(moves[i].score > bestScore)
{
bestIndex = i;
bestScore = moves[i].score;
}
} else
bestIndex = 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?
// FIXME !!!
if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
return move;
}
}
break;
case PH_QCHECKS: case PH_QCHECKS:
assert(!pos->is_check()); assert(!pos->is_check());
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; {
// Remember to change the line below if we decide to hash the qsearch! move = moves[movesPicked++].move;
if(/* move != ttMove && */ pos->move_is_legal(move, pinned)) // Remember to change the line below if we decide to hash the qsearch!
return move; // FIXME !!!
} if (/* move != ttMove && */ pos->move_is_legal(move, pinned))
break; return move;
}
break;
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.