if (moveIsCheck && pos.see_sign(m) >= 0)
result += CheckExtension[PvNode];
- if (piece_type(pos.piece_on(move_from(m))) == PAWN)
+ if (type_of(pos.piece_on(move_from(m))) == PAWN)
{
Color c = pos.side_to_move();
if (relative_rank(c, move_to(m)) == RANK_7)
}
if ( captureOrPromotion
- && piece_type(pos.piece_on(move_to(m))) != PAWN
+ && type_of(pos.piece_on(move_to(m))) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
&& !move_is_special(m))
bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
- static Book book;
+ static Book book; // Define static to initialize the PRNG only once
// Initialize global search-related variables
StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = false;
if (Options["Book File"].value<string>() != book.name())
book.open(Options["Book File"].value<string>());
- Move bookMove = book.get_move(pos, Options["Best Book Move"].value<bool>());
+ Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
if (bookMove != MOVE_NONE)
{
if (Limits.ponder)
Rml.bestMoveChanges = 0;
- // MultiPV iteration loop. At depth 1 perform at least 2 iterations to
- // get a score of the second best move for easy move detection.
- int e = Min(Max(MultiPV, 2 * int(depth == 1)), (int)Rml.size());
- for (MultiPVIteration = 0; MultiPVIteration < e; MultiPVIteration++)
+ // MultiPV iteration loop
+ for (MultiPVIteration = 0; MultiPVIteration < Min(MultiPV, (int)Rml.size()); MultiPVIteration++)
{
// Calculate dynamic aspiration window based on previous iterations
if (depth >= 5 && abs(Rml[MultiPVIteration].prevScore) < VALUE_KNOWN_WIN)
: can_return_tt(tte, depth, beta, ss->ply)))
{
TT.refresh(tte);
- ss->bestMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ ss->bestMove = move = ttMove; // Can be MOVE_NONE
+ value = value_from_tt(tte->value(), ss->ply);
+
+ if ( value >= beta
+ && move
+ && !pos.move_is_capture_or_promotion(move)
+ && move != ss->killers[0])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
+ return value;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
<< " currmovenumber " << moveCount + MultiPVIteration << endl;
}
- isPvMove = (PvNode && moveCount == 1);
+ // At Root and at first iteration do a PV search on all the moves to score root moves
+ isPvMove = (PvNode && moveCount <= (RootNode && depth <= ONE_PLY ? MAX_MOVES : 1));
givesCheck = pos.move_gives_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
from = move_from(move);
to = move_to(move);
- them = opposite_color(pos.side_to_move());
+ them = flip(pos.side_to_move());
ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq);
pc = pos.piece_on(from);
return true;
// Rule 2. Queen contact check is very dangerous
- if ( piece_type(pc) == QUEEN
+ if ( type_of(pc) == QUEEN
&& bit_is_set(kingAtt, to))
return true;
Piece p1, p2;
Square ksq;
- assert(m1 && move_is_ok(m1));
- assert(m2 && move_is_ok(m2));
+ assert(move_is_ok(m1));
+ assert(move_is_ok(m2));
// Case 1: The moving piece is the same in both moves
f2 = move_from(m2);
bool connected_threat(const Position& pos, Move m, Move threat) {
assert(move_is_ok(m));
- assert(threat && move_is_ok(threat));
+ assert(move_is_ok(threat));
assert(!pos.move_is_capture_or_promotion(m));
assert(!pos.move_is_passed_pawn_push(m));
// value of the threatening piece, don't prune moves which defend it.
if ( pos.move_is_capture(threat)
&& ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
- || piece_type(pos.piece_on(tfrom)) == KING)
+ || type_of(pos.piece_on(tfrom)) == KING)
&& pos.move_attacks_square(m, tto))
return true;
{
assert((!sp && threadID) || Threads.use_sleeping_threads());
- // Grab the lock to avoid races with Thread::wake_up()
- lock_grab(&sleepLock);
-
// Slave thread should exit as soon as do_terminate flag raises
if (do_terminate)
{
assert(!sp);
- lock_release(&sleepLock);
return;
}
+ // Grab the lock to avoid races with Thread::wake_up()
+ lock_grab(&sleepLock);
+
// If we are master and all slaves have finished don't go to sleep
if (sp && all_slaves_finished(sp))
{