// Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
const Value RazorApprMargins[6] = { Value(0x520), Value(0x300), Value(0x300), Value(0x300), Value(0x300), Value(0x300) };
- // The main transposition table
- TranspositionTable TT;
-
/// Variables initialized by UCI options
void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
void slowdown(const Position& pos);
- void build_pv(const Position& pos, Move pv[]);
bool fail_high_ply_1();
int current_search_time();
// Decide search depth for this move
bool moveIsCapture = pos.move_is_capture(move);
bool dangerous;
- ext = extension(pos, move, true, pos.move_is_capture(move), pos.move_is_check(move), false, false, &dangerous);
+ ext = extension(pos, move, true, moveIsCapture, pos.move_is_check(move), false, false, &dangerous);
newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
// Make the move, and search it
}
else
{
- if (newDepth >= 3*OnePly
- && i + MultiPV >= LMRPVMoves
+ if ( newDepth >= 3*OnePly
+ && i >= MultiPV + LMRPVMoves - 2 // Remove -2 and decrease LMRPVMoves instead ?
&& !dangerous
&& !moveIsCapture
&& !move_is_promotion(move)
{
ss[0].reduction = OnePly;
value = -search(pos, ss, -alpha, newDepth-OnePly, 1, true, 0);
- }
- else
+ } else
value = alpha + 1; // Just to trigger next condition
- if(value > alpha)
+
+ if (value > alpha)
{
value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
if (value > alpha)
// Update PV
rml.set_move_score(i, value);
update_pv(ss, 0);
- build_pv(pos, ss[0].pv);
+ TT.extract_pv(pos, ss[0].pv);
rml.set_move_pv(i, ss[0].pv);
if (MultiPV == 1)
// Print search information to the standard output
std::cout << "info depth " << Iteration
<< " score " << value_to_string(value)
+ << ((value >= beta)?
+ " lowerbound" : ((value <= alpha)? " upperbound" : ""))
<< " time " << current_search_time()
<< " nodes " << nodes_searched()
<< " nps " << nps()
bool mateThreat = false;
bool isCheck = pos.is_check();
- // Null move search
- if ( allowNullmove
- && depth > OnePly
- && !isCheck
- && !value_is_mate(beta)
- && ok_to_do_nullmove(pos)
- && approximateEval >= beta - NullMoveMargin)
- {
- ss[ply].currentMove = MOVE_NULL;
+ bool useNullMove = ( allowNullmove
+ //&& depth > OnePly
+ && !isCheck
+ && !value_is_mate(beta)
+ && ok_to_do_nullmove(pos)
+ && approximateEval >= beta - NullMoveMargin);
- StateInfo st;
- pos.do_null_move(st);
- int R = (depth >= 5 * OnePly ? 4 : 3); // Null move dynamic reduction
-
- Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
-
- pos.undo_null_move();
-
- if (nullValue >= beta)
- {
- if (depth < 6 * OnePly)
- return beta;
-
- // Do zugzwang verification search
- Value v = search(pos, ss, beta, depth-5*OnePly, ply, false, threadID);
- if (v >= beta)
- return beta;
- } else {
- // The null move failed low, which means that we may be faced with
- // some kind of threat. If the previous move was reduced, check if
- // the move that refuted the null move was somehow connected to the
- // move which was reduced. If a connection is found, return a fail
- // low score (which will cause the reduced move to fail high in the
- // parent node, which will trigger a re-search with full depth).
- if (nullValue == value_mated_in(ply + 2))
- mateThreat = true;
-
- ss[ply].threatMove = ss[ply + 1].currentMove;
- if ( depth < ThreatDepth
- && ss[ply - 1].reduction
- && connected_moves(pos, ss[ply - 1].currentMove, ss[ply].threatMove))
- return beta - 1;
- }
- }
// Null move search not allowed, try razoring
- else if ( !value_is_mate(beta)
- && depth < RazorDepth
- && approximateEval < beta - RazorApprMargins[int(depth) - 2]
- && ss[ply - 1].currentMove != MOVE_NULL
- && ttMove == MOVE_NONE
- && !pos.has_pawn_on_7th(pos.side_to_move()))
+ if ( !useNullMove
+ && !value_is_mate(beta)
+ && depth < RazorDepth
+ && approximateEval < beta - RazorApprMargins[int(depth) - 2]
+ && ss[ply - 1].currentMove != MOVE_NULL
+ && ttMove == MOVE_NONE
+ && !pos.has_pawn_on_7th(pos.side_to_move()))
{
Value v = qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
if (v < beta - RazorMargins[int(depth) - 2])
// Initialize a MovePicker object for the current position, and prepare
// to search all moves.
- MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
+ MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply], useNullMove);
Move move, movesSearched[256];
int moveCount = 0;
&& (move = mp.get_next_move()) != MOVE_NONE
&& !thread_should_stop(threadID))
{
+
+ // Null move search
+ if (move == MOVE_NULL)
+ {
+ ss[ply].currentMove = MOVE_NULL;
+
+ StateInfo st;
+ pos.do_null_move(st);
+ int R = (depth >= 5 * OnePly ? 4 : 3); // Null move dynamic reduction
+
+ Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
+
+ pos.undo_null_move();
+
+ if (nullValue >= beta)
+ {
+ if (depth < 6 * OnePly)
+ return beta;
+
+ // Do zugzwang verification search
+ Value v = search(pos, ss, beta, depth-5*OnePly, ply, false, threadID);
+ if (v >= beta)
+ return beta;
+ } else {
+ // The null move failed low, which means that we may be faced with
+ // some kind of threat. If the previous move was reduced, check if
+ // the move that refuted the null move was somehow connected to the
+ // move which was reduced. If a connection is found, return a fail
+ // low score (which will cause the reduced move to fail high in the
+ // parent node, which will trigger a re-search with full depth).
+ if (nullValue == value_mated_in(ply + 2))
+ mateThreat = true;
+
+ ss[ply].threatMove = ss[ply + 1].currentMove;
+ if ( depth < ThreatDepth
+ && ss[ply - 1].reduction
+ && connected_moves(pos, ss[ply - 1].currentMove, ss[ply].threatMove))
+ return beta - 1;
+ }
+ continue;
+ }
+
assert(move_is_ok(move));
bool singleReply = (isCheck && mp.number_of_moves() == 1);
if (pos.type_of_piece_on(move_from(m)) == PAWN)
{
- if (pos.move_is_pawn_push_to_7th(m))
+ Color c = pos.side_to_move();
+ if (relative_rank(c, move_to(m)) == RANK_7)
{
result += PawnPushTo7thExtension[pvNode];
*dangerous = true;
}
- if (pos.move_is_passed_pawn_push(m))
+ if (pos.pawn_is_passed(c, move_to(m)))
{
result += PassedPawnExtension[pvNode];
*dangerous = true;
}
- // build_pv() extends a PV by adding moves from the transposition table at
- // the end. This should ensure that the PV is almost always at least two
- // plies long, which is important, because otherwise we will often get
- // single-move PVs when the search stops while failing high, and a
- // single-move PV means that we don't have a ponder move.
-
- void build_pv(const Position& pos, Move pv[]) {
- int ply;
- Position p(pos);
- StateInfo st[100];
-
- for (ply = 0; pv[ply] != MOVE_NONE; ply++)
- p.do_move(pv[ply], st[ply]);
-
- bool stop;
- const TTEntry* tte;
- for (stop = false, tte = TT.retrieve(p.get_key());
- tte && tte->move() != MOVE_NONE && !stop;
- tte = TT.retrieve(p.get_key()), ply++)
- {
- if (!move_is_legal(p, tte->move(), p.pinned_pieces(p.side_to_move())))
- break;
- pv[ply] = tte->move();
- p.do_move(pv[ply], st[ply]);
- for (int j = 0; j < ply; j++)
- if (st[j].key == p.get_key()) stop = true;
- }
- pv[ply] = MOVE_NONE;
- }
-
-
// fail_high_ply_1() checks if some thread is currently resolving a fail
// high at ply 1 at the node below the first root node. This information
// is used for time managment.