// 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
&& !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()
// Initialize a MovePicker object for the current position, and prepare
// to search all moves
- MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
-
Move move, movesSearched[256];
int moveCount = 0;
Value value, bestValue = -VALUE_INFINITE;
- Bitboard dcCandidates = mp.discovered_check_candidates();
Color us = pos.side_to_move();
bool isCheck = pos.is_check();
bool mateThreat = pos.has_mate_threat(opposite_color(us));
+ MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
+ Bitboard dcCandidates = mp.discovered_check_candidates();
+
// Loop through all legal moves until no moves remain or a beta cutoff
// occurs.
while ( alpha < beta
{
assert(move_is_ok(move));
- bool singleReply = (isCheck && mp.number_of_moves() == 1);
+ bool singleReply = (isCheck && mp.number_of_evasions() == 1);
bool moveIsCheck = pos.move_is_check(move, dcCandidates);
bool moveIsCapture = pos.move_is_capture(move);
{
assert(move_is_ok(move));
- bool singleReply = (isCheck && mp.number_of_moves() == 1);
+ bool singleReply = (isCheck && mp.number_of_evasions() == 1);
bool moveIsCheck = pos.move_is_check(move, dcCandidates);
bool moveIsCapture = pos.move_is_capture(move);
// Use the cached evaluation score if possible
assert(ei.futilityMargin == Value(0));
- staticValue = tte->value();
+ staticValue = tte->value() + ply;
}
else
- staticValue = evaluate(pos, ei, threadID);
+ staticValue = evaluate(pos, ei, threadID) + ply;
if (ply == PLY_MAX - 1)
return evaluate(pos, ei, threadID);
{
// Store the score to avoid a future costly evaluation() call
if (!isCheck && !tte && ei.futilityMargin == 0)
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EVAL, Depth(-127*OnePly), MOVE_NONE);
+ TT.store(pos.get_key(), bestValue - ply, VALUE_TYPE_EVAL, Depth(-127*OnePly), MOVE_NONE);
return bestValue;
}
bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
// Generate all legal moves
- int lm_count = generate_legal_moves(pos, mlist);
+ MoveStack* last = generate_legal_moves(pos, mlist);
// Add each move to the moves[] array
- for (int i = 0; i < lm_count; i++)
+ for (MoveStack* cur = mlist; cur != last; cur++)
{
bool includeMove = includeAllMoves;
for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
- includeMove = (searchMoves[k] == mlist[i].move);
+ includeMove = (searchMoves[k] == cur->move);
if (!includeMove)
continue;
StateInfo st;
SearchStack ss[PLY_MAX_PLUS_2];
- moves[count].move = mlist[i].move;
+ moves[count].move = cur->move;
pos.do_move(moves[count].move, st);
moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
pos.undo_move(moves[count].move);
// Case 5: Discovered check, checking piece is the piece moved in m1
if ( piece_is_slider(pos.piece_on(t1))
&& bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), f2)
- && !bit_is_set(squares_between(t2, pos.king_square(pos.side_to_move())), t2))
+ && !bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), t2))
{
Bitboard occ = pos.occupied_squares();
Color us = pos.side_to_move();
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.