bool connected_moves(const Position& pos, Move m1, Move m2);
bool value_is_mate(Value value);
bool move_is_killer(Move m, const SearchStack& ss);
- Depth extension(const Position& pos, Move m, Depth depth, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
+ Depth extension(const Position& pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
bool ok_to_do_nullmove(const Position& pos);
bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
Value *alpha, Value *beta, Value *bestValue,
const Value futilityValue, const Value approximateValue,
Depth depth, int *moves,
- MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode);
+ MovePicker *mp, int master, bool pvNode);
void wake_sleeping_threads();
#if !defined(_MSC_VER)
int perft(Position& pos, Depth depth)
{
Move move;
- MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
- Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
int sum = 0;
+ MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
// If we are at the last ply we don't need to do and undo
// the moves, just to count them.
if (depth <= OnePly) // Replace with '<' to test also qsearch
{
- while ((move = mp.get_next_move()) != MOVE_NONE) sum++;
+ while (mp.get_next_move()) sum++;
return sum;
}
// Loop through all legal moves
+ CheckInfo ci(pos);
while ((move = mp.get_next_move()) != MOVE_NONE)
{
- StateInfo st;
- pos.do_move(move, st, dcCandidates);
- sum += perft(pos, depth - OnePly);
- pos.undo_move(move);
+ StateInfo st;
+ pos.do_move(move, st, ci, pos.move_is_check(move, ci));
+ sum += perft(pos, depth - OnePly);
+ pos.undo_move(move);
}
return sum;
}
Value oldAlpha = alpha;
Value value;
- Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+ CheckInfo ci(pos);
// Loop through all the moves in the root move list
for (int i = 0; i < rml.move_count() && !AbortSearch; i++)
<< " currmovenumber " << i + 1 << std::endl;
// Decide search depth for this move
+ bool moveIsCheck = pos.move_is_check(move);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
bool dangerous;
- ext = extension(pos, move, Depth(100), true, captureOrPromotion, pos.move_is_check(move), false, false, &dangerous);
+ ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
// Make the move, and search it
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
if (i < MultiPV)
{
Move movesSearched[256];
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
tte = TT.retrieve(pos.get_key());
ttMove = (tte ? tte->move() : MOVE_NONE);
- // Go with internal iterative deepening if we don't have a TT move or
- // if search depth is more then 4*OnePly higher then TT move depth.
- if ( UseIIDAtPVNodes
- && depth >= 5*OnePly
- &&(!ttMove || depth > tte->depth() + 4*OnePly))
+ // Go with internal iterative deepening if we don't have a TT move
+ if (UseIIDAtPVNodes && ttMove == MOVE_NONE && depth >= 5*OnePly)
{
search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID);
ttMove = ss[ply].pv[ply];
// to search all moves
isCheck = pos.is_check();
mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
- dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+ CheckInfo ci(pos);
MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
// Loop through all legal moves until no moves remain or a beta cutoff
assert(move_is_ok(move));
singleReply = (isCheck && mp.number_of_evasions() == 1);
- moveIsCheck = pos.move_is_check(move, dcCandidates);
+ moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
movesSearched[moveCount++] = ss[ply].currentMove = move;
// Decide the new search depth
- ext = extension(pos, move, depth, true, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+ ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
newDepth = depth - OnePly + ext;
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
if (moveCount == 1) // The first move in list is the PV
value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
&& idle_thread_exists(threadID)
&& !AbortSearch
&& !thread_should_stop(threadID)
- && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE, depth,
- &moveCount, &mp, dcCandidates, threadID, true))
+ && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE,
+ depth, &moveCount, &mp, threadID, true))
break;
}
Move movesSearched[256];
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
ss[ply].currentMove = MOVE_NULL;
pos.do_null_move(st);
- int R = (depth >= 5 * OnePly ? 4 : 3); // Null move dynamic reduction
+
+ // Null move dynamic reduction based on depth
+ int R = (depth >= 5 * OnePly ? 4 : 3);
+
+ // Null move dynamic reduction based on value
+ if (approximateEval - beta > PawnValueMidgame)
+ R++;
nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
// Initialize a MovePicker object for the current position, and prepare
// to search all moves.
MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
- dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+ CheckInfo ci(pos);
futilityValue = VALUE_NONE;
useFutilityPruning = depth < SelectiveDepth && !isCheck;
assert(move_is_ok(move));
singleReply = (isCheck && mp.number_of_evasions() == 1);
- moveIsCheck = pos.move_is_check(move, dcCandidates);
+ moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
movesSearched[moveCount++] = ss[ply].currentMove = move;
// Decide the new search depth
- ext = extension(pos, move, depth, false, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+ ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
newDepth = depth - OnePly + ext;
// Futility pruning
if ( useFutilityPruning
&& !dangerous
- && !captureOrPromotion)
+ && !captureOrPromotion
+ && move != ttMove)
{
// History pruning. See ok_to_prune() definition
if ( moveCount >= 2 + int(depth)
}
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
&& idle_thread_exists(threadID)
&& !AbortSearch
&& !thread_should_stop(threadID)
- && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval, depth, &moveCount,
- &mp, dcCandidates, threadID, false))
+ && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval,
+ depth, &moveCount, &mp, threadID, false))
break;
}
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
Move ttMove, move;
Value staticValue, bestValue, value, futilityValue;
- bool isCheck, enoughMaterial;
+ bool isCheck, enoughMaterial, moveIsCheck;
const TTEntry* tte = NULL;
int moveCount = 0;
bool pvNode = (beta - alpha != 1);
// to search the moves. Because the depth is <= 0 here, only captures,
// queen promotions and checks (only if depth == 0) will be generated.
MovePicker mp = MovePicker(pos, ttMove, depth, H);
- dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+ CheckInfo ci(pos);
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
// Loop through the moves until no moves remain or a beta cutoff
moveCount++;
ss[ply].currentMove = move;
+ moveIsCheck = pos.move_is_check(move, ci);
+
// Futility pruning
if ( enoughMaterial
&& !isCheck
&& !pvNode
+ && !moveIsCheck
+ && move != ttMove
&& !move_is_promotion(move)
- && !pos.move_is_check(move, dcCandidates)
&& !pos.move_is_passed_pawn_push(move))
{
futilityValue = staticValue
continue;
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
value = -qsearch(pos, ss, -beta, -alpha, depth-OnePly, ply+1, threadID);
pos.undo_move(move);
assert(ActiveThreads > 1);
Position pos = Position(sp->pos);
+ CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value;
Move move;
{
assert(move_is_ok(move));
- bool moveIsCheck = pos.move_is_check(move, sp->dcCandidates);
+ bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
lock_grab(&(sp->lock));
// Decide the new search depth.
bool dangerous;
- Depth ext = extension(pos, move, sp->depth, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
// Prune?
// Make and search the move.
StateInfo st;
- pos.do_move(move, st, sp->dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
assert(ActiveThreads > 1);
Position pos = Position(sp->pos);
+ CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value;
Move move;
&& !thread_should_stop(threadID)
&& (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
{
- bool moveIsCheck = pos.move_is_check(move, sp->dcCandidates);
+ bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
assert(move_is_ok(move));
// Decide the new search depth.
bool dangerous;
- Depth ext = extension(pos, move, sp->depth, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
// Make and search the move.
StateInfo st;
- pos.do_move(move, st, sp->dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
// extended, as example because the corresponding UCI option is set to zero,
// the move is marked as 'dangerous' so, at least, we avoid to prune it.
- Depth extension(const Position& pos, Move m, Depth depth, bool pvNode, bool captureOrPromotion,
+ Depth extension(const Position& pos, Move m, bool pvNode, bool captureOrPromotion,
bool check, bool singleReply, bool mateThreat, bool* dangerous) {
assert(m != MOVE_NONE);
result += MateThreatExtension[pvNode];
}
- if ( pvNode
- && captureOrPromotion
- && pos.type_of_piece_on(move_to(m)) != PAWN
- && pos.see_sign(m) >= 0)
- {
- result += OnePly/2;
- *dangerous = true;
- }
-
- // Do not extend at low depths
- if (!pvNode && depth < 4*OnePly)
- return Min(result, OnePly); // Further test with Min(result, OnePly / 2)
-
if (pos.type_of_piece_on(move_from(m)) == PAWN)
{
Color c = pos.side_to_move();
*dangerous = true;
}
+ if ( pvNode
+ && captureOrPromotion
+ && pos.type_of_piece_on(move_to(m)) != PAWN
+ && pos.see_sign(m) >= 0)
+ {
+ result += OnePly/2;
+ *dangerous = true;
+ }
+
return Min(result, OnePly);
}
bool split(const Position& p, SearchStack* sstck, int ply,
Value* alpha, Value* beta, Value* bestValue, const Value futilityValue,
const Value approximateEval, Depth depth, int* moves,
- MovePicker* mp, Bitboard dcCandidates, int master, bool pvNode) {
+ MovePicker* mp, int master, bool pvNode) {
assert(p.is_ok());
assert(sstck != NULL);
splitPoint->alpha = pvNode? *alpha : (*beta - 1);
splitPoint->beta = *beta;
splitPoint->pvNode = pvNode;
- splitPoint->dcCandidates = dcCandidates;
splitPoint->bestValue = *bestValue;
splitPoint->futilityValue = futilityValue;
splitPoint->approximateEval = approximateEval;
projects / stockfish / blobdiff