// Read UCI options
UCIMultiPV = Options["MultiPV"].value<int>();
- SkillLevel = Options["Skill level"].value<int>();
+ SkillLevel = Options["Skill Level"].value<int>();
read_evaluation_uci_options(pos.side_to_move());
Threads.read_uci_options();
ValueType vt;
Value bestValue, value, oldAlpha;
Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
- bool isPvMove, inCheck, singularExtensionNode, givesCheck, captureOrPromotion, dangerous, isBadCap;
+ bool isPvMove, inCheck, singularExtensionNode, givesCheck, captureOrPromotion, dangerous;
int moveCount = 0, playedMoveCount = 0;
int threadID = pos.thread();
SplitPoint* sp = NULL;
search<PvNode>(pos, ss, alpha, beta, d);
ss->skipNullMove = false;
- ttMove = ss->bestMove;
tte = TT.probe(posKey);
+ ttMove = tte ? tte->move() : MOVE_NONE;
}
split_point_start: // At split points actual search starts from here
singularExtensionNode = !Root
&& !SpNode
&& depth >= SingularExtensionDepth[PvNode]
- && tte
- && tte->move()
+ && ttMove != MOVE_NONE
&& !excludedMove // Do not allow recursive singular extension search
&& (tte->type() & VALUE_TYPE_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
// At Root and at first iteration do a PV search on all the moves to score root moves
isPvMove = (PvNode && moveCount <= (Root ? depth <= ONE_PLY ? 1000 : MultiPV : 1));
givesCheck = pos.move_gives_check(move, ci);
- captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ captureOrPromotion = pos.move_is_capture(move) || move_is_promotion(move);
// Step 11. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, givesCheck, &dangerous);
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttMove.
if ( singularExtensionNode
- && move == tte->move()
+ && move == ttMove
&& ext < ONE_PLY)
{
Value ttValue = value_from_tt(tte->value(), ss->ply);
}
}
- // Bad capture detection. Will be used by prob-cut search
- isBadCap = depth >= 3 * ONE_PLY
- && depth < 8 * ONE_PLY
- && captureOrPromotion
- && move != ttMove
- && !dangerous
- && !move_is_promotion(move)
- && abs(alpha) < VALUE_MATE_IN_PLY_MAX
- && pos.see_sign(move) < 0;
-
// Step 13. Make the move
pos.do_move(move, st, ci, givesCheck);
ss->reduction = reduction<PvNode>(depth, moveCount);
if (ss->reduction)
{
- alpha = SpNode ? sp->alpha : alpha;
Depth d = newDepth - ss->reduction;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);
// Probcut search for bad captures. If a reduced search returns a value
// very below beta then we can (almost) safely prune the bad capture.
- if (isBadCap)
+ if ( depth >= 3 * ONE_PLY
+ && depth < 8 * ONE_PLY
+ && mp.isBadCapture()
+ && move != ttMove
+ && !dangerous
+ && !move_is_promotion(move)
+ && abs(alpha) < VALUE_MATE_IN_PLY_MAX)
{
ss->reduction = 3 * ONE_PLY;
Value rAlpha = alpha - 300;
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
- && !pos.move_is_capture_or_promotion(move))
+ && !pos.move_is_capture(move)
+ && !move_is_promotion(move))
{
if (move != ss->killers[0])
{
&& !inCheck
&& givesCheck
&& move != ttMove
- && !pos.move_is_capture_or_promotion(move)
+ && !pos.move_is_capture(move)
+ && !move_is_promotion(move)
&& ss->eval + PawnValueMidgame / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
{
assert(move_is_ok(m));
assert(threat && move_is_ok(threat));
assert(!pos.move_gives_check(m));
- assert(!pos.move_is_capture_or_promotion(m));
+ assert(!pos.move_is_capture(m) && !move_is_promotion(m));
assert(!pos.move_is_passed_pawn_push(m));
Square mfrom, mto, tfrom, tto;
TTEntry* tte;
int ply = 1;
- assert(pv[0] != MOVE_NONE && pos.move_is_legal(pv[0]));
+ assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
pos.do_move(pv[0], *st++);
+ Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+
while ( (tte = TT.probe(pos.get_key())) != NULL
&& tte->move() != MOVE_NONE
- && pos.move_is_legal(tte->move())
+ && pos.move_is_pl(tte->move())
+ && pos.pl_move_is_legal(tte->move(), pinned)
&& ply < PLY_MAX
&& (!pos.is_draw() || ply < 2))
{
Value v, m = VALUE_NONE;
int ply = 0;
- assert(pv[0] != MOVE_NONE && pos.move_is_legal(pv[0]));
+ assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
do {
k = pos.get_key();