// book_key() returns the PolyGlot hash key of the given position
private static UInt64 book_key(Position pos)
{
UInt64 key = 0;
Bitboard b = pos.occupied_squares;
while (b != 0)
{
// Piece offset is at 64 * polyPiece where polyPiece is defined as:
// BP = 0, WP = 1, BN = 2, WN = 3, ... BK = 10, WK = 11
Square s = Utils.pop_1st_bit(ref b);
Piece p = pos.piece_on(s);
int polyPiece = 2 * (Utils.type_of(p) - 1) + (Utils.color_of(p) == ColorC.WHITE ? 1 : 0);
key ^= PolyGlotRandoms[ZobPieceOffset + (64 * polyPiece + s)];
}
b = (ulong)pos.can_castle_CR(CastleRightC.ALL_CASTLES);
while (b != 0)
key ^= PolyGlotRandoms[ZobCastleOffset + Utils.pop_1st_bit(ref b)];
if (pos.st.epSquare != SquareC.SQ_NONE)
key ^= PolyGlotRandoms[ZobEnPassantOffset + Utils.file_of(pos.st.epSquare)];
if (pos.sideToMove == ColorC.WHITE)
key ^= PolyGlotRandoms[ZobTurnOffset + 0];
return key;
}
/// move_to_san() takes a position and a legal Move as input and returns its
/// short algebraic notation representation.
internal static string move_to_san(Position pos, int m)
{
if (m == MoveC.MOVE_NONE)
{
return "(none)";
}
if (m == MoveC.MOVE_NULL)
{
return "(null)";
}
Debug.Assert(pos.move_is_legal(m));
Bitboard others, b;
Color us = pos.sideToMove;
var san = new StringBuilder();
Square from = from_sq(m);
Square to = to_sq(m);
Piece pc = pos.piece_on(from);
PieceType pt = type_of(pc);
if (type_of_move(m) == MoveTypeC.CASTLING)
{
san.Append(to > from ? "O-O" : "O-O-O");
}
else
{
if (pt != PieceTypeC.PAWN)
{
san.Append(PieceToChar[ColorC.WHITE][pt]); // Upper case
// Disambiguation if we have more then one piece of type 'pt' that can
// reach 'to' with a legal move.
others = b = (pos.attacks_from_PS(pc, to) & pos.pieces_PTC(pt, us)) ^ (ulong)from;
while (others != 0)
{
Move move = make_move(pop_lsb(ref b), to);
if (!pos.pl_move_is_legal(move, pos.pinned_pieces()))
{
others ^= (ulong)from_sq(move);
}
}
if (others != 0)
{
if ((others & file_bb_S(from)) == 0)
{
san.Append(file_to_char(file_of(from)));
}
else if ((others & rank_bb_S(from)) == 0)
{
san.Append(rank_to_char(rank_of(from)));
}
else
{
san.Append(square_to_string(from));
}
}
}
else if (pos.is_capture(m))
{
san.Append(file_to_char(file_of(from)));
}
if (pos.is_capture(m))
{
san.Append('x');
}
san.Append(square_to_string(to));
if (type_of_move(m) == MoveTypeC.PROMOTION)
{
san.Append('=');
san.Append(PieceToChar[ColorC.WHITE][promotion_type(m)]);
}
}
var ci = CheckInfoBroker.GetObject();
ci.CreateCheckInfo(pos);
if (pos.move_gives_check(m, ci))
{
var st = new StateInfo();
pos.do_move(m, st);
var mlist = MListBroker.GetObject();
mlist.pos = 0;
Movegen.generate_legal(pos, mlist.moves, ref mlist.pos);
san.Append(mlist.pos > 0 ? "+" : "#");
MListBroker.Free();
pos.undo_move(m);
}
CheckInfoBroker.Free();
return san.ToString();
}
/// PawnTable::evaluate_pawns() evaluates each pawn of the given color
internal static Score evaluate_pawns(Color Us, Position pos, Bitboard ourPawns, Bitboard theirPawns, PawnEntry e)
{
Color Them = (Us == ColorC.WHITE ? ColorC.BLACK : ColorC.WHITE);
Bitboard b;
Square s;
File f;
Rank r;
bool passed, isolated, doubled, opposed, chain, backward, candidate;
Score value = ScoreC.SCORE_ZERO;
Square[] pl = pos.pieceList[Us][PieceTypeC.PAWN];
int plPos = 0;
// Loop through all pawns of the current color and score each pawn
while ((s = pl[plPos++]) != SquareC.SQ_NONE)
{
Debug.Assert(pos.piece_on(s) == Utils.make_piece(Us, PieceTypeC.PAWN));
f = (s & 7);
r = (s >> 3);
// This file cannot be half open
if (Us == ColorC.WHITE)
{
e.halfOpenFilesWHITE &= ~(1 << f);
}
else
{
e.halfOpenFilesBLACK &= ~(1 << f);
}
// Our rank plus previous one. Used for chain detection
b = Utils.RankBB[r] | Utils.RankBB[Us == ColorC.WHITE ? r - 1 : r + 1];
// Flag the pawn as passed, isolated, doubled or member of a pawn
// chain (but not the backward one).
chain = (ourPawns & Utils.AdjacentFilesBB[f] & b) != 0;
isolated = (ourPawns & Utils.AdjacentFilesBB[f]) == 0;
doubled = (ourPawns & Utils.ForwardBB[Us][s]) != 0;
opposed = (theirPawns & Utils.ForwardBB[Us][s]) != 0;
passed = (theirPawns & Utils.PassedPawnMask[Us][s]) == 0;
// Test for backward pawn
backward = false;
// If the pawn is passed, isolated, or member of a pawn chain it cannot
// be backward. If there are friendly pawns behind on adjacent files
// or if can capture an enemy pawn it cannot be backward either.
if (!(passed | isolated | chain)
&& (((ourPawns & Utils.AttackSpanMask[Them][s])) == 0)
&& ((((Utils.StepAttacksBB[((Us << 3) | PieceTypeC.PAWN)][s]) & theirPawns)) == 0))
{
// We now know that there are no friendly pawns beside or behind this
// pawn on adjacent files. We now check whether the pawn is
// backward by looking in the forward direction on the adjacent
// files, and seeing whether we meet a friendly or an enemy pawn first.
b = Utils.StepAttacksBB[((Us << 3) | PieceTypeC.PAWN)][s];
// Note that we are sure to find something because pawn is not passed
// nor isolated, so loop is potentially infinite, but it isn't.
while ((b & (ourPawns | theirPawns)) == 0)
{
if (Us == ColorC.WHITE) { b <<= 8; } else { b >>= 8; }
}
// The friendly pawn needs to be at least two ranks closer than the
// enemy pawn in order to help the potentially backward pawn advance.
backward = (((b | (Us == ColorC.WHITE ? b << 8 : b >> 8)) & theirPawns) != 0);
}
Debug.Assert(opposed | passed | (((Utils.AttackSpanMask[Us][s] & theirPawns)) != 0));
// A not passed pawn is a candidate to become passed if it is free to
// advance and if the number of friendly pawns beside or behind this
// pawn on adjacent files is higher or equal than the number of
// enemy pawns in the forward direction on the adjacent files.
candidate = !(opposed | passed | backward | isolated)
&& (b = Utils.AttackSpanMask[Them][s + (Us == ColorC.WHITE ? SquareC.DELTA_N : SquareC.DELTA_S)] & ourPawns) != 0
&& Bitcount.popcount_1s_Max15(b) >= Bitcount.popcount_1s_Max15(Utils.AttackSpanMask[Us][s] & theirPawns);
// Passed pawns will be properly scored in evaluation because we need
// full attack info to evaluate passed pawns. Only the frontmost passed
// pawn on each file is considered a true passed pawn.
if (passed && !doubled)
{
if (Us == ColorC.WHITE)
{
e.passedPawnsWHITE |= Utils.SquareBB[s];
}
else
{
e.passedPawnsBLACK |= Utils.SquareBB[s];
}
}
// Score this pawn
if (isolated)
value -= IsolatedPawnPenalty[opposed ? 1 : 0][f];
if (doubled)
value -= DoubledPawnPenalty[opposed ? 1 : 0][f];
if (backward)
value -= BackwardPawnPenalty[opposed ? 1 : 0][f];
if (chain)
value += ChainBonus[f];
if (candidate)
value += CandidateBonus[((s >> 3) ^ (Us * 7))];
}
return value;
}
// connected_threat() tests whether it is safe to forward prune a move or if
// is somehow connected to the threat move returned by null search.
static bool connected_threat(Position pos, Move m, Move threat)
{
Debug.Assert(Utils.is_ok_M(m));
Debug.Assert(Utils.is_ok_M(threat));
Debug.Assert(!pos.is_capture_or_promotion(m));
Debug.Assert(!pos.is_passed_pawn_push(m));
Square mfrom, mto, tfrom, tto;
mfrom = Utils.from_sq(m);
mto = Utils.to_sq(m);
tfrom = Utils.from_sq(threat);
tto = Utils.to_sq(threat);
// Case 1: Don't prune moves which move the threatened piece
if (mfrom == tto)
return true;
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
if (pos.is_capture(threat)
&& (Position.PieceValueMidgame[pos.piece_on(tfrom)] >= Position.PieceValueMidgame[pos.piece_on(tto)]
|| Utils.type_of(pos.piece_on(tfrom)) == PieceTypeC.KING)
&& pos.move_attacks_square(m, tto))
return true;
// Case 3: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray.
if (piece_is_slider(pos.piece_on(tfrom))
&& (Utils.bit_is_set(Utils.between_bb(tfrom, tto), mto) != 0)
&& pos.see(m, true) >= 0)
return true;
return false;
}
// search<>() is the main search function for both PV and non-PV nodes and for
// normal and SplitPoint nodes. When called just after a split point the search
// is simpler because we have already probed the hash table, done a null move
// search, and searched the first move before splitting, we don't have to repeat
// all this work again. We also don't need to store anything to the hash table
// here: This is taken care of after we return from the split point.
internal static Value search(NodeType NT, Position pos, Stack[] ss, int ssPos, Value alpha, Value beta, Depth depth)
{
bool PvNode = (NT == NodeTypeC.PV || NT == NodeTypeC.Root || NT == NodeTypeC.SplitPointPV || NT == NodeTypeC.SplitPointRoot);
bool SpNode = (NT == NodeTypeC.SplitPointPV || NT == NodeTypeC.SplitPointNonPV || NT == NodeTypeC.SplitPointRoot);
bool RootNode = (NT == NodeTypeC.Root || NT == NodeTypeC.SplitPointRoot);
Debug.Assert(alpha >= -ValueC.VALUE_INFINITE && alpha < beta && beta <= ValueC.VALUE_INFINITE);
Debug.Assert((alpha == beta - 1) || PvNode);
Debug.Assert(depth > DepthC.DEPTH_ZERO);
MovesSearched ms = MovesSearchedBroker.GetObject();
Move[] movesSearched = ms.movesSearched;
StateInfo st = null;
TTEntry tte = TT.StaticEntry;
bool tteHasValue = false;
UInt32 ttePos = 0;
Key posKey = 0;
Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
Bound bt;
Value bestValue, value, oldAlpha, ttValue;
Value refinedValue, nullValue, futilityBase, futilityValue;
bool isPvMove, inCheck, singularExtensionNode, givesCheck;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
Thread thisThread = pos.this_thread();
SplitPoint sp = null;
refinedValue = bestValue = value = -ValueC.VALUE_INFINITE;
oldAlpha = alpha;
inCheck = pos.in_check();
ss[ssPos].ply = ss[ssPos - 1].ply + 1;
// Used to send selDepth info to GUI
if (PvNode && thisThread.maxPly < ss[ssPos].ply)
thisThread.maxPly = ss[ssPos].ply;
// Step 1. Initialize node
if (SpNode)
{
ttMove = excludedMove = MoveC.MOVE_NONE;
ttValue = ValueC.VALUE_ZERO;
sp = ss[ssPos].sp;
bestMove = sp.bestMove;
threatMove = sp.threatMove;
bestValue = sp.bestValue;
moveCount = sp.moveCount; // Lock must be held here
Debug.Assert(bestValue > -ValueC.VALUE_INFINITE && moveCount > 0);
goto split_point_start;
}
else
{
ss[ssPos].currentMove = threatMove = ss[ssPos + 1].excludedMove = bestMove = MoveC.MOVE_NONE;
ss[ssPos + 1].skipNullMove = 0; ss[ssPos + 1].reduction = DepthC.DEPTH_ZERO;
ss[ssPos + 2].killers0 = ss[ssPos + 2].killers1 = MoveC.MOVE_NONE;
}
// Step 2. Check for aborted search and immediate draw
// Enforce node limit here. FIXME: This only works with 1 search thread.
if ((Limits.nodes != 0) && pos.nodes >= Limits.nodes)
SignalsStop = true;
if ((SignalsStop
|| pos.is_draw(false)
|| ss[ssPos].ply > Constants.MAX_PLY) && !RootNode)
{
MovesSearchedBroker.Free();
return ValueC.VALUE_DRAW;
}
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss[ssPos].ply+1), but if alpha is already bigger because
// a shorter mate was found upward in the tree then there is no need to search
// further, we will never beat current alpha. Same logic but with reversed signs
// applies also in the opposite condition of being mated instead of giving mate,
// in this case return a fail-high score.
if (!RootNode)
{
alpha = Math.Max(Utils.mated_in(ss[ssPos].ply), alpha);
beta = Math.Min(Utils.mate_in(ss[ssPos].ply + 1), beta);
if (alpha >= beta)
{
MovesSearchedBroker.Free();
return alpha;
}
}
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
// TT value, so we use a different position key in case of an excluded move.
excludedMove = ss[ssPos].excludedMove;
posKey = (excludedMove != 0) ? pos.exclusion_key() : pos.key();
tteHasValue = TT.probe(posKey, ref ttePos, out tte);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tteHasValue ? tte.move() : MoveC.MOVE_NONE;
ttValue = tteHasValue ? value_from_tt(tte.value(), ss[ssPos].ply) : ValueC.VALUE_ZERO;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
// smooth experience in analysis mode. We don't probe at Root nodes otherwise
// we should also update RootMoveList to avoid bogus output.
if (!RootNode && tteHasValue && (PvNode ? tte.depth() >= depth && tte.type() == Bound.BOUND_EXACT
: can_return_tt(tte, depth, ttValue, beta)))
{
TT.entries[ttePos].set_generation(TT.generation);
ss[ssPos].currentMove = ttMove; // Can be MOVE_NONE
if (ttValue >= beta
&& (ttMove != 0)
&& !pos.is_capture_or_promotion(ttMove)
&& ttMove != ss[ssPos].killers0)
{
ss[ssPos].killers1 = ss[ssPos].killers0;
ss[ssPos].killers0 = ttMove;
}
MovesSearchedBroker.Free();
return ttValue;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck)
ss[ssPos].eval = ss[ssPos].evalMargin = ValueC.VALUE_NONE;
else if (tteHasValue)
{
Debug.Assert(tte.static_value() != ValueC.VALUE_NONE);
ss[ssPos].eval = tte.static_value();
ss[ssPos].evalMargin = tte.static_value_margin();
refinedValue = refine_eval(tte, ttValue, ss[ssPos].eval);
}
else
{
refinedValue = ss[ssPos].eval = Evaluate.do_evaluate(false, pos, ref ss[ssPos].evalMargin);
TT.store(posKey, ValueC.VALUE_NONE, Bound.BOUND_NONE, DepthC.DEPTH_NONE, MoveC.MOVE_NONE, ss[ssPos].eval, ss[ssPos].evalMargin);
}
// Update gain for the parent non-capture move given the static position
// evaluation before and after the move.
if ((move = ss[ssPos - 1].currentMove) != MoveC.MOVE_NULL
&& ss[ssPos - 1].eval != ValueC.VALUE_NONE
&& ss[ssPos].eval != ValueC.VALUE_NONE
&& (pos.captured_piece_type() == 0)
&& !Utils.is_special(move))
{
Square to = Utils.to_sq(move);
H.update_gain(pos.piece_on(to), to, -ss[ssPos - 1].eval - ss[ssPos].eval);
}
// Step 6. Razoring (is omitted in PV nodes)
if (!PvNode && !inCheck
&& depth < RazorDepth
&& refinedValue + razor_margin(depth) < beta
&& ttMove == MoveC.MOVE_NONE
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY
&& !pos.pawn_on_7th(pos.sideToMove))
{
Value rbeta = beta - razor_margin(depth);
Value v = qsearch(NodeTypeC.NonPV, pos, ss, ssPos, rbeta - 1, rbeta, DepthC.DEPTH_ZERO);
if (v < rbeta)
{
// Logically we should return (v + razor_margin(depth)), but
// surprisingly this did slightly weaker in tests.
MovesSearchedBroker.Free();
return v;
}
}
// Step 7. Static null move pruning (is omitted in PV nodes)
// We're betting that the opponent doesn't have a move that will reduce
// the score by more than futility_margin(depth) if we do a null move.
if (!PvNode && !inCheck
&& (ss[ssPos].skipNullMove == 0)
&& depth < RazorDepth
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY
&& refinedValue - futility_margin(depth, 0) >= beta
&& (pos.non_pawn_material(pos.sideToMove) != 0))
{
MovesSearchedBroker.Free();
return refinedValue - futility_margin(depth, 0);
}
// Step 8. Null move search with verification search (is omitted in PV nodes)
if (!PvNode && !inCheck
&& (ss[ssPos].skipNullMove == 0)
&& depth > DepthC.ONE_PLY
&& refinedValue >= beta
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY
&& (pos.non_pawn_material(pos.sideToMove) != 0))
{
ss[ssPos].currentMove = MoveC.MOVE_NULL;
// Null move dynamic reduction based on depth
int R = 3 + (depth >= 5 * DepthC.ONE_PLY ? depth / 8 : 0);
// Null move dynamic reduction based on value
if (refinedValue - Constants.PawnValueMidgame > beta)
R++;
if (st == null) { st = StateInfoBroker.GetObject(); }
pos.do_null_move(true, st);
ss[ssPos + 1].skipNullMove = 1;
nullValue = depth - R * DepthC.ONE_PLY < DepthC.ONE_PLY ? -qsearch(NodeTypeC.NonPV, pos, ss, ssPos + 1, -beta, -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -beta, -alpha, depth - R * DepthC.ONE_PLY);
ss[ssPos + 1].skipNullMove = 0;
pos.do_null_move(false, st);
if (nullValue >= beta)
{
// Do not return unproven mate scores
if (nullValue >= ValueC.VALUE_MATE_IN_MAX_PLY)
nullValue = beta;
if (depth < 6 * DepthC.ONE_PLY)
{
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
MovesSearchedBroker.Free();
return nullValue;
}
// Do verification search at high depths
ss[ssPos].skipNullMove = 1;
Value v = search(NodeTypeC.NonPV, pos, ss, ssPos, alpha, beta, depth - R * DepthC.ONE_PLY);
ss[ssPos].skipNullMove = 0;
if (v >= beta)
{
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
MovesSearchedBroker.Free();
return nullValue;
}
}
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).
threatMove = ss[ssPos + 1].currentMove;
if (depth < ThreatDepth
&& (ss[ssPos - 1].reduction != 0)
&& threatMove != MoveC.MOVE_NONE
&& connected_moves(pos, ss[ssPos - 1].currentMove, threatMove))
{
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
MovesSearchedBroker.Free();
return beta - 1;
}
}
}
// Step 9. ProbCut (is omitted in PV nodes)
// If we have a very good capture (i.e. SEE > seeValues[captured_piece_type])
// and a reduced search returns a value much above beta, we can (almost) safely
// prune the previous move.
if (!PvNode && !inCheck
&& excludedMove == MoveC.MOVE_NONE
&& depth >= RazorDepth + DepthC.ONE_PLY
&& (ss[ssPos].skipNullMove == 0)
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY)
{
Value rbeta = beta + 200;
Depth rdepth = depth - DepthC.ONE_PLY - 3 * DepthC.ONE_PLY;
Debug.Assert(rdepth >= DepthC.ONE_PLY);
Debug.Assert(ss[ssPos - 1].currentMove != MoveC.MOVE_NONE);
Debug.Assert(ss[ssPos - 1].currentMove != MoveC.MOVE_NULL);
MovePicker mp2 = MovePickerBroker.GetObject();
mp2.MovePickerC(pos, ttMove, H, pos.captured_piece_type());
CheckInfo ci2 = CheckInfoBroker.GetObject();
ci2.CreateCheckInfo(pos);
while ((move = mp2.next_move()) != MoveC.MOVE_NONE)
{
if (pos.pl_move_is_legal(move, ci2.pinned))
{
ss[ssPos].currentMove = move;
if (st == null) { st = StateInfoBroker.GetObject(); }
pos.do_move(move, st, ci2, pos.move_gives_check(move, ci2));
value = -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -rbeta, -rbeta + 1, rdepth);
pos.undo_move(move);
if (value >= rbeta)
{
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
CheckInfoBroker.Free();
MovePickerBroker.Free(mp2);
MovesSearchedBroker.Free();
return value;
}
}
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp2);
}
// Step 10. Internal iterative deepening
if (ttMove == MoveC.MOVE_NONE
&& depth >= IIDDepth[PvNode ? 1 : 0]
&& (PvNode || (!inCheck && ss[ssPos].eval + IIDMargin >= beta)))
{
Depth d = (PvNode ? depth - 2 * DepthC.ONE_PLY : depth / 2);
ss[ssPos].skipNullMove = 1;
search(PvNode ? NodeTypeC.PV : NodeTypeC.NonPV, pos, ss, ssPos, alpha, beta, d);
ss[ssPos].skipNullMove = 0;
tteHasValue = TT.probe(posKey, ref ttePos, out tte);
ttMove = (tteHasValue) ? tte.move() : MoveC.MOVE_NONE;
}
else
{
// Re-read (needed as TTEntry is a struct in the port)
if ((tteHasValue) && (TT.entries[ttePos].key == tte.key)) { tte = TT.entries[ttePos]; }
}
split_point_start: // At split points actual search starts from here
MovePicker mp = MovePickerBroker.GetObject();
mp.MovePickerC(pos, ttMove, depth, H, ss[ssPos], PvNode ? -ValueC.VALUE_INFINITE : beta, SpNode ? ss[ssPos].sp.mp : null);
CheckInfo ci = CheckInfoBroker.GetObject();
ci.CreateCheckInfo(pos);
futilityBase = ss[ssPos].eval + ss[ssPos].evalMargin;
singularExtensionNode = !RootNode
&& !SpNode
&& depth >= SingularExtensionDepth[PvNode ? 1 : 0]
&& ttMove != MoveC.MOVE_NONE
&& (excludedMove == 0) // Recursive singular search is not allowed
&& ((tte.type() & Bound.BOUND_LOWER) != 0) // FIXME: uninitialized!
&& tte.depth() >= depth - 3 * DepthC.ONE_PLY;
// Step 11. Loop through moves
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while (bestValue < beta
&& (move = mp.next_move()) != MoveC.MOVE_NONE
&& !thisThread.cutoff_occurred()
&& !SignalsStop)
{
Debug.Assert(Utils.is_ok_M(move));
if (move == excludedMove)
continue;
// At root obey the "searchmoves" option and skip moves not listed in Root
// Move List, as a consequence any illegal move is also skipped. In MultiPV
// mode we also skip PV moves which have been already searched.
// If we find none, it means !count
if (RootNode && (find(RootMoves, PVIdx, RootMoves.Count, move) == -1))
continue;
// At PV and SpNode nodes we want all moves to be legal since the beginning
if ((PvNode || SpNode) && !pos.pl_move_is_legal(move, ci.pinned))
continue;
if (SpNode)
{
moveCount = ++sp.moveCount;
ThreadHelper.lock_release(sp.Lock);
}
else
moveCount++;
if (RootNode)
{
SignalsFirstRootMove = (moveCount == 1);
if (thisThread == Threads.main_thread() && SearchTime.ElapsedMilliseconds > 2000)
{
Plug.Write("info depth ");
Plug.Write((depth / DepthC.ONE_PLY).ToString());
Plug.Write(" currmove ");
Plug.Write(Utils.move_to_uci(move, Chess960));
Plug.Write(" nodes ");
Plug.Write(pos.nodes.ToString());
Plug.Write(" currmovenumber ");
Plug.Write((moveCount + PVIdx).ToString());
Plug.Write(Constants.endl);
}
}
isPvMove = (PvNode && moveCount <= 1);
captureOrPromotion = pos.is_capture_or_promotion(move);
givesCheck = pos.move_gives_check(move, ci);
dangerous = givesCheck || is_dangerous(pos, move, captureOrPromotion);
ext = DepthC.DEPTH_ZERO;
// Step 12. Extend checks and, in PV nodes, also dangerous moves
if (PvNode && dangerous)
ext = DepthC.ONE_PLY;
else if (givesCheck && pos.see(move, true) >= 0)
ext = DepthC.ONE_PLY / 2;
// Singular extension search. If all moves but one fail low on a search of
// (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move
// is singular and should be extended. To verify this we do a reduced search
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttMove.
if (singularExtensionNode
&& (ext == 0)
&& move == ttMove
&& pos.pl_move_is_legal(move, ci.pinned))
{
if (Math.Abs(ttValue) < ValueC.VALUE_KNOWN_WIN)
{
Value rBeta = ttValue - (int)(depth);
ss[ssPos].excludedMove = move;
ss[ssPos].skipNullMove = 1;
value = search(NodeTypeC.NonPV, pos, ss, ssPos, rBeta - 1, rBeta, depth / 2);
ss[ssPos].skipNullMove = 0;
ss[ssPos].excludedMove = MoveC.MOVE_NONE;
if (value < rBeta)
ext = DepthC.ONE_PLY;
}
}
// Update current move (this must be done after singular extension search)
newDepth = depth - DepthC.ONE_PLY + ext;
// Step 13. Futility pruning (is omitted in PV nodes)
if (!PvNode && !inCheck
&& !captureOrPromotion
&& !dangerous
&& move != ttMove
&& (bestValue > ValueC.VALUE_MATED_IN_MAX_PLY || bestValue == -ValueC.VALUE_INFINITE)
&& !Utils.is_castle(move))
{
// Move count based pruning
if (moveCount >= futility_move_count(depth)
&& ((threatMove == 0) || !connected_threat(pos, move, threatMove)))
{
if (SpNode)
ThreadHelper.lock_grab(sp.Lock);
continue;
}
// Value based pruning
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction(PvNode, depth, moveCount);
futilityValue = futilityBase + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_moved(move), Utils.to_sq(move));
if (futilityValue < beta)
{
if (SpNode)
ThreadHelper.lock_grab(sp.Lock);
continue;
}
// Prune moves with negative SEE at low depths
if (predictedDepth < 2 * DepthC.ONE_PLY
&& pos.see(move, true) < 0)
{
if (SpNode)
ThreadHelper.lock_grab(sp.Lock);
continue;
}
}
// Check for legality only before to do the move
if (!pos.pl_move_is_legal(move, ci.pinned))
{
moveCount--;
continue;
}
ss[ssPos].currentMove = move;
if (!SpNode && !captureOrPromotion && playedMoveCount < 64)
movesSearched[playedMoveCount++] = move;
// Step 14. Make the move
if (st == null) { st = StateInfoBroker.GetObject(); }
pos.do_move(move, st, ci, givesCheck);
// Step 15. Reduced depth search (LMR). If the move fails high will be
// re-searched at full depth.
if (
!isPvMove
&& !captureOrPromotion
&& !dangerous
&& ss[ssPos].killers0 != move
&& ss[ssPos].killers1 != move
&& depth > 3 * DepthC.ONE_PLY
&& !Utils.is_castle(move))
{
ss[ssPos].reduction = reduction(PvNode, depth, moveCount);
Depth d = Math.Max(newDepth - ss[ssPos].reduction, DepthC.ONE_PLY);
alpha = SpNode ? sp.alpha : alpha;
value = -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -(alpha + 1), -alpha, d);
doFullDepthSearch = (value > alpha && ss[ssPos].reduction != DepthC.DEPTH_ZERO);
ss[ssPos].reduction = DepthC.DEPTH_ZERO;
}
else
doFullDepthSearch = !isPvMove;
// Step 16. Full depth search, when LMR is skipped or fails high
if (doFullDepthSearch)
{
alpha = SpNode ? sp.alpha : alpha;
value = newDepth < DepthC.ONE_PLY ? -qsearch(NodeTypeC.NonPV, pos, ss, ssPos + 1, -(alpha + 1), -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -(alpha + 1), -alpha, newDepth);
}
// Only for PV nodes do a full PV search on the first move or after a fail
// high, in the latter case search only if value < beta, otherwise let the
// parent node to fail low with value <= alpha and to try another move.
if (PvNode && (isPvMove || (value > alpha && (RootNode || value < beta))))
{
value = newDepth < DepthC.ONE_PLY ? -qsearch(NodeTypeC.PV, pos, ss, ssPos + 1, -beta, -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.PV, pos, ss, ssPos + 1, -beta, -alpha, newDepth);
}
// Step 17. Undo move
pos.undo_move(move);
Debug.Assert(value > -ValueC.VALUE_INFINITE && value < ValueC.VALUE_INFINITE);
// Step 18. Check for new best move
if (SpNode)
{
ThreadHelper.lock_grab(sp.Lock);
bestValue = sp.bestValue;
alpha = sp.alpha;
}
// Finished searching the move. If Signals.stop is true, the search
// was aborted because the user interrupted the search or because we
// ran out of time. In this case, the return value of the search cannot
// be trusted, and we don't update the best move and/or PV.
if (RootNode && !SignalsStop)
{
int rmPos = find(RootMoves, 0, RootMoves.Count, move);
// PV move or new best move ?
if (isPvMove || value > alpha)
{
RootMoves[rmPos].score = value;
RootMoves[rmPos].extract_pv_from_tt(pos);
// We record how often the best move has been changed in each
// iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
if (!isPvMove && MultiPV == 1)
BestMoveChanges++;
}
else
// All other moves but the PV are set to the lowest value, this
// is not a problem when sorting becuase sort is stable and move
// position in the list is preserved, just the PV is pushed up.
RootMoves[rmPos].score = -ValueC.VALUE_INFINITE;
}
if (value > bestValue)
{
bestValue = value;
bestMove = move;
if (PvNode
&& value > alpha
&& value < beta) // We want always alpha < beta
alpha = value;
if (SpNode && !thisThread.cutoff_occurred())
{
sp.bestValue = value;
sp.bestMove = move;
sp.alpha = alpha;
if (value >= beta)
sp.cutoff = true;
}
}
// Step 19. Check for split
if (!SpNode
&& depth >= Threads.min_split_depth()
&& bestValue < beta
&& Threads.available_slave_exists(thisThread)
&& !SignalsStop
&& !thisThread.cutoff_occurred())
{
bestValue = Threads.split(Constants.FakeSplit, pos, ss, ssPos, alpha, beta, bestValue, ref bestMove, depth, threatMove, moveCount, mp, NT);
}
}
// Step 20. Check for mate and stalemate
// All legal moves have been searched and if there are no legal moves, it
// must be mate or stalemate. Note that we can have a false positive in
// case of Signals.stop or thread.cutoff_occurred() are set, but this is
// harmless because return value is discarded anyhow in the parent nodes.
// If we are in a singular extension search then return a fail low score.
if (moveCount == 0)
{
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
CheckInfoBroker.Free();
MovePickerBroker.Free(mp);
MovesSearchedBroker.Free();
return (excludedMove != 0) ? oldAlpha : inCheck ? Utils.mated_in(ss[ssPos].ply) : ValueC.VALUE_DRAW;
}
// If we have pruned all the moves without searching return a fail-low score
if (bestValue == -ValueC.VALUE_INFINITE)
{
Debug.Assert(playedMoveCount == 0);
bestValue = oldAlpha;
}
// Step 21. Update tables
// Update transposition table entry, killers and history
if (!SpNode && !SignalsStop && !thisThread.cutoff_occurred())
{
move = bestValue <= oldAlpha ? MoveC.MOVE_NONE : bestMove;
bt = bestValue <= oldAlpha ? Bound.BOUND_UPPER
: bestValue >= beta ? Bound.BOUND_LOWER : Bound.BOUND_EXACT;
TT.store(posKey, value_to_tt(bestValue, ss[ssPos].ply), bt, depth, move, ss[ssPos].eval, ss[ssPos].evalMargin);
// Update killers and history for non capture cut-off moves
if (!inCheck
&& bestValue >= beta
&& !pos.is_capture_or_promotion(move)
)
{
if (move != ss[ssPos].killers0)
{
ss[ssPos].killers1 = ss[ssPos].killers0;
ss[ssPos].killers0 = move;
}
// Increase history value of the cut-off move
Value bonus = (depth * depth);
H.add(pos.piece_moved(move), Utils.to_sq(move), bonus);
// Decrease history of all the other played non-capture moves
for (int i = 0; i < playedMoveCount - 1; i++)
{
Move m = movesSearched[i];
H.add(pos.piece_moved(m), Utils.to_sq(m), -bonus);
}
}
}
Debug.Assert(bestValue > -ValueC.VALUE_INFINITE && bestValue < ValueC.VALUE_INFINITE);
if (st != null) { st.previous = null; StateInfoBroker.Free(); }
CheckInfoBroker.Free();
MovePickerBroker.Free(mp);
MovesSearchedBroker.Free();
return bestValue;
}
// check_is_dangerous() tests if a checking move can be pruned in qsearch().
// bestValue is updated only when returning false because in that case move
// will be pruned.
static bool check_is_dangerous(Position pos, Move move, Value futilityBase, Value beta)
{
Bitboard b, occ, oldAtt, newAtt, kingAtt;
Square from, to, ksq;
Piece pc;
Color them;
from = Utils.from_sq(move);
to = Utils.to_sq(move);
them = Utils.flip_C(pos.sideToMove);
ksq = pos.king_square(them);
kingAtt = Position.attacks_from_KING(ksq);
pc = pos.piece_moved(move);
occ = pos.occupied_squares ^ Utils.SquareBB[from] ^ Utils.SquareBB[ksq];
oldAtt = Position.attacks_from(pc, from, occ);
newAtt = Position.attacks_from(pc, to, occ);
// Rule 1. Checks which give opponent's king at most one escape square are dangerous
b = kingAtt & ~pos.pieces_C(them) & ~newAtt & ~(1UL << to);
if ((b & (b - 1)) == 0) // Catches also !b
return true;
// Rule 2. Queen contact check is very dangerous
if (Utils.type_of(pc) == PieceTypeC.QUEEN
&& (Utils.bit_is_set(kingAtt, to) != 0))
return true;
// Rule 3. Creating new double threats with checks
b = pos.pieces_C(them) & newAtt & ~oldAtt & ~(1UL << ksq);
while (b != 0)
{
// Note that here we generate illegal "double move"!
if (futilityBase + Position.PieceValueEndgame[pos.piece_on(Utils.pop_1st_bit(ref b))] >= beta)
return true;
}
return false;
}
// connected_moves() tests whether two moves are 'connected' in the sense
// that the first move somehow made the second move possible (for instance
// if the moving piece is the same in both moves). The first move is assumed
// to be the move that was made to reach the current position, while the
// second move is assumed to be a move from the current position.
internal static bool connected_moves(Position pos, Move m1, Move m2)
{
Square f1, t1, f2, t2;
Piece p1, p2;
Square ksq;
Debug.Assert(Utils.is_ok_M(m1));
Debug.Assert(Utils.is_ok_M(m2));
// Case 1: The moving piece is the same in both moves
f2 = Utils.from_sq(m2);
t1 = Utils.to_sq(m1);
if (f2 == t1)
return true;
// Case 2: The destination square for m2 was vacated by m1
t2 = Utils.to_sq(m2);
f1 = Utils.from_sq(m1);
if (t2 == f1)
return true;
// Case 3: Moving through the vacated square
p2 = pos.piece_on(f2);
if (piece_is_slider(p2)
&& (Utils.bit_is_set(Utils.between_bb(f2, t2), f1) != 0))
return true;
// Case 4: The destination square for m2 is defended by the moving piece in m1
p1 = pos.piece_on(t1);
if ((Utils.bit_is_set(pos.attacks_from_PS(p1, t1), t2)) != 0)
return true;
// Case 5: Discovered check, checking piece is the piece moved in m1
ksq = pos.king_square(pos.sideToMove);
if (
piece_is_slider(p1)
&&
(Utils.bit_is_set(Utils.between_bb(t1, ksq), f2) != 0)
&&
(Utils.bit_is_set(Position.attacks_from(p1, t1, Utils.xor_bit(pos.occupied_squares, f2)), ksq) != 0)
)
return true;
return false;
}
internal static void generate_quiet_check(Position pos, MoveStack[] ms, ref int mpos)
{
/// generate<MV_NON_CAPTURE_CHECK> generates all pseudo-legal non-captures and knight
/// underpromotions that give check. Returns a pointer to the end of the move list.
Debug.Assert(!pos.in_check());
var ci = CheckInfoBroker.GetObject();
ci.CreateCheckInfo(pos);
var target = ~pos.occupied_squares;
var dc = ci.dcCandidates;
while (dc != 0)
{
var from = Utils.pop_lsb(ref dc);
var pt = Utils.type_of(pos.piece_on(from));
if (pt == PieceTypeC.PAWN)
{
continue; // Will be generated together with direct checks
}
var b = pos.attacks_from_PTS(pt, from) & ~pos.occupied_squares;
if (pt == PieceTypeC.KING)
{
b &= ~Utils.PseudoAttacks[PieceTypeC.QUEEN][ci.ksq];
}
while (b != 0)
{
ms[mpos++].move = Utils.make_move(from, Utils.pop_lsb(ref b));
}
}
generate_all(GenType.QUIET_CHECKS, pos, ms, ref mpos, pos.sideToMove, target, ci);
CheckInfoBroker.Free();
}
// evaluate_pieces_of_color<>() assigns bonuses and penalties to all the
// pieces of a given color.
private static int evaluate_pieces_of_color(int Us, bool Trace, Position pos, EvalInfo ei, ref int mobility)
{
var Them = (Us == ColorC.WHITE ? ColorC.BLACK : ColorC.WHITE);
mobility = ScoreC.SCORE_ZERO;
// Do not include in mobility squares protected by enemy pawns or occupied by our pieces
var mobilityArea = ~(ei.attackedBy[Them][PieceTypeC.PAWN] | pos.byColorBB[Us]);
#region Evaluate pieces
ulong between = 0;
var plPos = 0;
int s, ksq;
int mob;
int f;
int score, scores = ScoreC.SCORE_ZERO;
var attackedByThemKing = ei.attackedBy[Them][PieceTypeC.KING];
var attackedByThemPawn = ei.attackedBy[Them][PieceTypeC.PAWN];
var kingRingThem = ei.kingRing[Them];
for (var Piece = PieceTypeC.KNIGHT; Piece < PieceTypeC.KING; Piece++)
{
score = ScoreC.SCORE_ZERO;
ei.attackedBy[Us][Piece] = 0;
var pl = pos.pieceList[Us][Piece];
plPos = 0;
while ((s = pl[plPos++]) != SquareC.SQ_NONE)
{
// Find attacked squares, including x-ray attacks for bishops and rooks
if (Piece == PieceTypeC.KNIGHT)
{
between = Utils.StepAttacksBB_KNIGHT[s];
}
else if (Piece == PieceTypeC.QUEEN)
{
#if X64
b = Utils.BAttacks[s][(((pos.occupied_squares & Utils.BMasks[s]) * Utils.BMagics[s]) >> Utils.BShifts[s])] | Utils.RAttacks[s][(((pos.occupied_squares & Utils.RMasks[s]) * Utils.RMagics[s]) >> Utils.RShifts[s])];
#else
between = Utils.bishop_attacks_bb(s, pos.occupied_squares)
| Utils.rook_attacks_bb(s, pos.occupied_squares);
#endif
}
else if (Piece == PieceTypeC.BISHOP)
{
#if X64
b = Utils.BAttacks[s][(((
(pos.occupied_squares ^ (pos.byTypeBB[PieceTypeC.QUEEN] & pos.byColorBB[Us]))
& Utils.BMasks[s]) * Utils.BMagics[s]) >> Utils.BShifts[s])];
#else
between = Utils.bishop_attacks_bb(s, pos.occupied_squares ^ pos.pieces_PTC(PieceTypeC.QUEEN, Us));
#endif
}
else if (Piece == PieceTypeC.ROOK)
{
#if X64
b = Utils.RAttacks[s][(((
(pos.occupied_squares ^ ((pos.byTypeBB[PieceTypeC.ROOK] | pos.byTypeBB[PieceTypeC.QUEEN]) & pos.byColorBB[Us]))
& Utils.RMasks[s]) * Utils.RMagics[s]) >> Utils.RShifts[s])];
#else
between = Utils.rook_attacks_bb(
s,
pos.occupied_squares ^ pos.pieces(PieceTypeC.ROOK, PieceTypeC.QUEEN, Us));
#endif
}
// Update attack info
ei.attackedBy[Us][Piece] |= between;
// King attacks
if ((between & kingRingThem) != 0)
{
ei.kingAttackersCount[Us]++;
ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
var bb = (between & attackedByThemKing); //ei.attackedBy[Them][PieceTypeC.KING]);
if (bb != 0)
{
#if X64
bb -= (bb >> 1) & 0x5555555555555555UL;
bb = ((bb >> 2) & 0x3333333333333333UL) + (bb & 0x3333333333333333UL);
ei.kingAdjacentZoneAttacksCount[Us] += (int)((bb * 0x1111111111111111UL) >> 60);
#else
ei.kingAdjacentZoneAttacksCount[Us] += Bitcount.popcount_1s_Max15(bb);
#endif
}
}
// Mobility
#if X64
Bitboard bmob = b & mobilityArea;
if (Piece != PieceTypeC.QUEEN)
{
bmob -= (bmob >> 1) & 0x5555555555555555UL;
bmob = ((bmob >> 2) & 0x3333333333333333UL) + (bmob & 0x3333333333333333UL);
mob = (int)((bmob * 0x1111111111111111UL) >> 60);
}
else
{
bmob -= ((bmob >> 1) & 0x5555555555555555UL);
bmob = ((bmob >> 2) & 0x3333333333333333UL) + (bmob & 0x3333333333333333UL);
bmob = ((bmob >> 4) + bmob) & 0x0F0F0F0F0F0F0F0FUL;
mob = (int)((bmob * 0x0101010101010101UL) >> 56);
}
#else
mob = (Piece != PieceTypeC.QUEEN
? Bitcount.popcount_1s_Max15(between & mobilityArea)
: Bitcount.popcount_1s_Full(between & mobilityArea));
#endif
mobility += MobilityBonus[Piece][mob];
// Decrease score if we are attacked by an enemy pawn. Remaining part
// of threat evaluation must be done later when we have full attack info.
if ((attackedByThemPawn & Utils.SquareBB[s]) != 0)
{
score -= ThreatenedByPawnPenalty[Piece];
}
else if ((Piece == PieceTypeC.BISHOP)
&& ((Utils.PseudoAttacks[Piece][pos.pieceList[Them][PieceTypeC.KING][0]] & Utils.SquareBB[s])
!= 0))
{
between = Utils.BetweenBB[s][pos.pieceList[Them][PieceTypeC.KING][0]] & pos.occupied_squares;
if (!Utils.more_than_one(between))
{
score += Utils.make_score(15, 25);
}
}
// Bishop and knight outposts squares
if ((Piece == PieceTypeC.BISHOP || Piece == PieceTypeC.KNIGHT)
&& (((pos.byTypeBB[PieceTypeC.PAWN] & pos.byColorBB[Them]) & Utils.AttackSpanMask[Us][s]) == 0))
{
#region Evaluate outposts inlined
// evaluate_outposts() evaluates bishop and knight outposts squares
// Initial bonus based on square
var bonus = OutpostBonus[Piece == PieceTypeC.BISHOP ? 1 : 0][s ^ (Us * 56)];
// Increase bonus if supported by pawn, especially if the opponent has
// no minor piece which can exchange the outpost piece.
if ((bonus != 0) && ((ei.attackedBy[Us][PieceTypeC.PAWN] & Utils.SquareBB[s]) != 0))
{
if (((pos.byTypeBB[PieceTypeC.KNIGHT] & pos.byColorBB[Them]) == 0)
&& (((((0xAA55AA55AA55AA55UL & Utils.SquareBB[s]) != 0)
? 0xAA55AA55AA55AA55UL
: ~0xAA55AA55AA55AA55UL)
& (pos.byTypeBB[PieceTypeC.BISHOP] & pos.byColorBB[Them])) == 0))
{
bonus += bonus + bonus / 2;
}
else
{
bonus += bonus / 2;
}
}
score += ((bonus << 16) + bonus); // Utils.make_score(bonus, bonus);
#endregion
}
if ((Piece == PieceTypeC.ROOK || Piece == PieceTypeC.QUEEN) && Utils.relative_rank_CS(Us, s) >= RankC.RANK_5)
{
// Major piece on 7th rank
if (Utils.relative_rank_CS(Us, s) == RankC.RANK_7
&& Utils.relative_rank_CS(Us, pos.king_square(Them)) == RankC.RANK_8)
score += (Piece == PieceTypeC.ROOK ? RookOn7thBonus : QueenOn7thBonus);
// Major piece attacking pawns on the same rank
Bitboard pawns = pos.pieces_PTC(PieceTypeC.PAWN, Them) & Utils.rank_bb_S(s);
if (pawns != 0)
{
score += (Piece == PieceTypeC.ROOK ? RookOnPawnBonus : QueenOnPawnBonus) * Bitcount.popcount_1s_Max15(pawns);
}
}
// Special extra evaluation for bishops
if (pos.chess960 && (Piece == PieceTypeC.BISHOP))
{
// An important Chess960 pattern: A cornered bishop blocked by
// a friendly pawn diagonally in front of it is a very serious
// problem, especially when that pawn is also blocked.
if (s == Utils.relative_square(Us, SquareC.SQ_A1)
|| s == Utils.relative_square(Us, SquareC.SQ_H1))
{
var d = Utils.pawn_push(Us)
+ (Utils.file_of(s) == FileC.FILE_A ? SquareC.DELTA_E : SquareC.DELTA_W);
if (pos.piece_on(s + d) == Utils.make_piece(Us, PieceTypeC.PAWN))
{
if (!pos.is_empty(s + d + Utils.pawn_push(Us)))
{
score -= 2 * TrappedBishopA1H1Penalty;
}
else if (pos.piece_on(s + 2 * d) == Utils.make_piece(Us, PieceTypeC.PAWN))
{
score -= TrappedBishopA1H1Penalty;
}
else
{
score -= TrappedBishopA1H1Penalty / 2;
}
}
}
}
// Special extra evaluation for rooks
if (Piece == PieceTypeC.ROOK)
{
// Open and half-open files
f = (s & 7);
var halfOpenUs = ((Us == ColorC.WHITE)
? (ei.pi.halfOpenFilesWHITE & (1 << f))
: (ei.pi.halfOpenFilesBLACK & (1 << f))) != 0;
if (halfOpenUs)
{
if (((Them == ColorC.WHITE)
? (ei.pi.halfOpenFilesWHITE & (1 << f))
: (ei.pi.halfOpenFilesBLACK & (1 << f))) != 0)
{
score += RookOpenFileBonus;
}
else
{
score += RookHalfOpenFileBonus;
}
}
// Penalize rooks which are trapped inside a king. Penalize more if
// king has lost right to castle.
if (mob > 6 || halfOpenUs)
{
continue;
}
ksq = pos.pieceList[Us][PieceTypeC.KING][0];
if (((ksq >> 3) ^ (Us * 7)) == RankC.RANK_1 || (ksq >> 3) == (s >> 3))
{
if ((ksq & 7) >= FileC.FILE_E)
{
if (f > (ksq & 7))
{
// Is there a half-open file between the king and the edge of the board?
if (((Us == ColorC.WHITE)
? (ei.pi.halfOpenFilesWHITE & ~((1 << ((ksq & 7) + 1)) - 1))
: (ei.pi.halfOpenFilesBLACK & ~((1 << ((ksq & 7) + 1)) - 1))) == 0)
{
score -= ((((pos.st.castleRights & (CastleRightC.WHITE_ANY << (Us << 1))) != 0)
? (TrappedRookPenalty - mob * 16) / 2
: (TrappedRookPenalty - mob * 16)) << 16);
}
}
}
else
{
if (f < (ksq & 7))
{
// Is there a half-open file between the king and the edge of the board?
if (((Us == ColorC.WHITE)
? (ei.pi.halfOpenFilesWHITE & ((1 << (ksq & 7)) - 1))
: (ei.pi.halfOpenFilesBLACK & ((1 << (ksq & 7)) - 1))) == 0)
{
score -= ((((pos.st.castleRights & (CastleRightC.WHITE_ANY << (Us << 1))) != 0)
? (TrappedRookPenalty - mob * 16) / 2
: (TrappedRookPenalty - mob * 16)) << 16);
}
}
}
}
}
}
scores += score;
if (Trace)
{
TracedScores[Us][Piece] = score;
}
}
#endregion
// Sum up all attacked squares
ei.attackedBy[Us][0] = ei.attackedBy[Us][PieceTypeC.PAWN] | ei.attackedBy[Us][PieceTypeC.KNIGHT]
| ei.attackedBy[Us][PieceTypeC.BISHOP] | ei.attackedBy[Us][PieceTypeC.ROOK]
| ei.attackedBy[Us][PieceTypeC.QUEEN] | ei.attackedBy[Us][PieceTypeC.KING];
return scores;
}
// search<>() is the main search function for both PV and non-PV nodes and for
// normal and SplitPoint nodes. When called just after a split point the search
// is simpler because we have already probed the hash table, done a null move
// search, and searched the first move before splitting, we don't have to repeat
// all this work again. We also don't need to store anything to the hash table
// here: This is taken care of after we return from the split point.
internal static int search(int NT, Position pos, Stack[] ss, int ssPos, int alpha, int beta, int depth)
{
var PvNode = (NT == NodeTypeC.PV || NT == NodeTypeC.Root || NT == NodeTypeC.SplitPointPV
|| NT == NodeTypeC.SplitPointRoot);
var SpNode = (NT == NodeTypeC.SplitPointPV || NT == NodeTypeC.SplitPointNonPV
|| NT == NodeTypeC.SplitPointRoot);
var RootNode = (NT == NodeTypeC.Root || NT == NodeTypeC.SplitPointRoot);
Debug.Assert(alpha >= -ValueC.VALUE_INFINITE && alpha < beta && beta <= ValueC.VALUE_INFINITE);
Debug.Assert((PvNode || alpha == beta - 1));
Debug.Assert(depth > DepthC.DEPTH_ZERO);
var ms = MovesSearchedBroker.GetObject();
var movesSearched = ms.movesSearched;
StateInfo st = null;
var tte = TT.StaticEntry;
var tteHasValue = false;
uint ttePos = 0;
ulong posKey = 0;
int ttMove, move, excludedMove, bestMove, threatMove;
int ext, newDepth;
int bestValue, value, ttValue;
int eval = 0, nullValue, futilityValue;
bool inCheck, givesCheck, pvMove, singularExtensionNode;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
SplitPoint sp = null;
// Step 1. Initialize node
var thisThread = pos.this_thread();
//var threatExtension = false;
inCheck = pos.in_check();
if (SpNode)
{
sp = ss[ssPos].sp;
bestMove = sp.bestMove;
threatMove = sp.threatMove;
bestValue = sp.bestValue;
ttMove = excludedMove = MoveC.MOVE_NONE;
ttValue = ValueC.VALUE_NONE;
Debug.Assert(sp.bestValue > -ValueC.VALUE_INFINITE && sp.moveCount > 0);
goto split_point_start;
}
bestValue = -ValueC.VALUE_INFINITE;
ss[ssPos].currentMove = threatMove = ss[ssPos + 1].excludedMove = bestMove = MoveC.MOVE_NONE;
ss[ssPos].ply = ss[ssPos - 1].ply + 1;
ss[ssPos + 1].skipNullMove = 0;
ss[ssPos + 1].reduction = DepthC.DEPTH_ZERO;
ss[ssPos + 2].killers0 = ss[ssPos + 2].killers1 = MoveC.MOVE_NONE;
// Used to send selDepth info to GUI
if (PvNode && thisThread.maxPly < ss[ssPos].ply)
{
thisThread.maxPly = ss[ssPos].ply;
}
if (!RootNode)
{
// Step 2. Check for aborted search and immediate draw
if ((SignalsStop || pos.is_draw(false) || ss[ssPos].ply > Constants.MAX_PLY))
{
MovesSearchedBroker.Free();
return DrawValue[pos.sideToMove];
}
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss->ply+1), but if alpha is already bigger because
// a shorter mate was found upward in the tree then there is no need to search
// further, we will never beat current alpha. Same logic but with reversed signs
// applies also in the opposite condition of being mated instead of giving mate,
// in this case return a fail-high score.
alpha = Math.Max(Utils.mated_in(ss[ssPos].ply), alpha);
beta = Math.Min(Utils.mate_in(ss[ssPos].ply + 1), beta);
if (alpha >= beta)
{
MovesSearchedBroker.Free();
return alpha;
}
}
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
// TT value, so we use a different position key in case of an excluded move.
excludedMove = ss[ssPos].excludedMove;
posKey = (excludedMove != 0) ? pos.exclusion_key() : pos.key();
tteHasValue = TT.probe(posKey, ref ttePos, out tte);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tteHasValue ? tte.move() : MoveC.MOVE_NONE;
ttValue = tteHasValue ? value_from_tt(tte.value(), ss[ssPos].ply) : ValueC.VALUE_NONE;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
// smooth experience in analysis mode. We don't probe at Root nodes otherwise
// we should also update RootMoveList to avoid bogus output.
if (!RootNode
&& tteHasValue
&& tte.depth() >= depth
&& ttValue != ValueC.VALUE_NONE // Only in case of TT access race
&& (PvNode ? tte.type() == Bound.BOUND_EXACT
: ttValue >= beta ? ((tte.type() & Bound.BOUND_LOWER) != 0 )
: ((tte.type() & Bound.BOUND_UPPER) != 0)))
{
Debug.Assert(ttValue != ValueC.VALUE_NONE); // Due to depth > DEPTH_NONE
TT.table[ttePos].set_generation(TT.generation);
ss[ssPos].currentMove = ttMove; // Can be MOVE_NONE
if (ttValue >= beta && (ttMove != 0) && !pos.is_capture_or_promotion(ttMove)
&& ttMove != ss[ssPos].killers0)
{
ss[ssPos].killers1 = ss[ssPos].killers0;
ss[ssPos].killers0 = ttMove;
}
MovesSearchedBroker.Free();
return ttValue;
}
// Step 5. Evaluate the position statically and update parentSplitPoint's gain statistics
if (inCheck)
{
ss[ssPos].staticEval = ss[ssPos].evalMargin = eval = ValueC.VALUE_NONE;
}
else if (tteHasValue)
{
// Never assume anything on values stored in TT
if ((ss[ssPos].staticEval = eval = tte.eval_value()) == ValueC.VALUE_NONE
|| (ss[ssPos].evalMargin = tte.eval_margin()) == ValueC.VALUE_NONE)
{
eval = ss[ssPos].staticEval = Evaluate.do_evaluate(false, pos, ref ss[ssPos].evalMargin);
}
// Can ttValue be used as a better position evaluation?
if (ttValue != ValueC.VALUE_NONE)
{
if ((((tte.type() & Bound.BOUND_LOWER) != 0) && ttValue > eval)
|| (((tte.type() & Bound.BOUND_UPPER) != 0) && ttValue < eval))
{
eval = ttValue;
}
}
}
else
{
eval = ss[ssPos].staticEval = Evaluate.do_evaluate(false, pos, ref ss[ssPos].evalMargin);
TT.store(
posKey,
ValueC.VALUE_NONE,
Bound.BOUND_NONE,
DepthC.DEPTH_NONE,
MoveC.MOVE_NONE,
ss[ssPos].staticEval,
ss[ssPos].evalMargin);
}
// Update gain for the parentSplitPoint non-capture move given the static position
// evaluation before and after the move.
if ((move = ss[ssPos - 1].currentMove) != MoveC.MOVE_NULL && ss[ssPos - 1].staticEval != ValueC.VALUE_NONE
&& ss[ssPos].staticEval != ValueC.VALUE_NONE && (pos.captured_piece_type() == 0) && Utils.type_of_move(move) == MoveTypeC.NORMAL)
{
var to = Utils.to_sq(move);
H.update_gain(pos.piece_on(to), to, -ss[ssPos - 1].staticEval - ss[ssPos].staticEval);
}
// Step 6. Razoring (is omitted in PV nodes)
if (!PvNode && !inCheck && depth < 4 * DepthC.ONE_PLY && eval + razor_margin(depth) < beta
&& ttMove == MoveC.MOVE_NONE && Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY
&& !pos.pawn_on_7th(pos.sideToMove))
{
var rbeta = beta - razor_margin(depth);
var v = qsearch(NodeTypeC.NonPV, false, pos, ss, ssPos, rbeta - 1, rbeta, DepthC.DEPTH_ZERO);
if (v < rbeta)
{
// Logically we should return (v + razor_margin(depth)), but
// surprisingly this did slightly weaker in tests.
MovesSearchedBroker.Free();
return v;
}
}
// Step 7. Static null move pruning (is omitted in PV nodes)
// We're betting that the opponent doesn't have a move that will reduce
// the score by more than futility_margin(depth) if we do a null move.
if (!PvNode && !inCheck && (ss[ssPos].skipNullMove == 0) && depth < 4 * DepthC.ONE_PLY
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY && eval - FutilityMargins[depth][0] >= beta
&& (pos.non_pawn_material(pos.sideToMove) != 0))
{
MovesSearchedBroker.Free();
return eval - FutilityMargins[depth][0];
}
// Step 8. Null move search with verification search (is omitted in PV nodes)
if (!PvNode && !inCheck && (ss[ssPos].skipNullMove == 0) && depth > DepthC.ONE_PLY && eval >= beta
&& Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY && (pos.non_pawn_material(pos.sideToMove) != 0))
{
ss[ssPos].currentMove = MoveC.MOVE_NULL;
// Null move dynamic reduction based on depth
Depth R = 3 * DepthC.ONE_PLY + depth / 4;
// Null move dynamic reduction based on value
if (eval - Constants.PawnValueMidgame > beta)
{
R += DepthC.ONE_PLY;
}
if (st == null)
{
st = StateInfoBroker.GetObject();
}
pos.do_null_move(st);
ss[ssPos + 1].skipNullMove = 1;
nullValue = depth - R < DepthC.ONE_PLY ? -qsearch(NodeTypeC.NonPV, false, pos, ss, ssPos + 1, -beta, -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -beta, -alpha, depth - R);
ss[ssPos + 1].skipNullMove = 0;
pos.undo_null_move(st);
if (nullValue >= beta)
{
// Do not return unproven mate scores
if (nullValue >= ValueC.VALUE_MATE_IN_MAX_PLY)
{
nullValue = beta;
}
if (depth < 6 * DepthC.ONE_PLY)
{
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
MovesSearchedBroker.Free();
return nullValue;
}
// Do verification search at high depths
ss[ssPos].skipNullMove = 1;
var v = search(NodeTypeC.NonPV, pos, ss, ssPos, alpha, beta, depth - R);
ss[ssPos].skipNullMove = 0;
if (v >= beta)
{
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
MovesSearchedBroker.Free();
return nullValue;
}
}
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
// the move that refuted the null move was somehow connected to the
// move which was reduced. If a connection is found extend moves that
// defend against threat.
threatMove = ss[ssPos + 1].currentMove;
if (depth < 5 * DepthC.ONE_PLY && (ss[ssPos - 1].reduction != 0) && threatMove != MoveC.MOVE_NONE
&& allows(pos, ss[ssPos - 1].currentMove, threatMove))
{
//threatExtension = true;
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
MovesSearchedBroker.Free();
return beta - 1;
}
}
}
// Step 9. ProbCut (is omitted in PV nodes)
// If we have a very good capture (i.e. SEE > seeValues[captured_piece_type])
// and a reduced search returns a value much above beta, we can (almost) safely
// prune the previous move.
if (!PvNode && !inCheck && excludedMove == MoveC.MOVE_NONE && depth >= 4 * DepthC.ONE_PLY + DepthC.ONE_PLY
&& (ss[ssPos].skipNullMove == 0) && Math.Abs(beta) < ValueC.VALUE_MATE_IN_MAX_PLY)
{
var rbeta = beta + 200;
var rdepth = depth - DepthC.ONE_PLY - 3 * DepthC.ONE_PLY;
Debug.Assert(rdepth >= DepthC.ONE_PLY);
Debug.Assert(ss[ssPos - 1].currentMove != MoveC.MOVE_NONE);
Debug.Assert(ss[ssPos - 1].currentMove != MoveC.MOVE_NULL);
var mp2 = MovePickerBroker.GetObject();
mp2.MovePickerC(pos, ttMove, H, pos.captured_piece_type());
var ci2 = CheckInfoBroker.GetObject();
ci2.CreateCheckInfo(pos);
while ((move = mp2.next_move()) != MoveC.MOVE_NONE)
{
if (pos.pl_move_is_legal(move, ci2.pinned))
{
ss[ssPos].currentMove = move;
if (st == null)
{
st = StateInfoBroker.GetObject();
}
pos.do_move(move, st, ci2, pos.move_gives_check(move, ci2));
value = -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -rbeta, -rbeta + 1, rdepth);
pos.undo_move(move);
if (value >= rbeta)
{
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp2);
MovesSearchedBroker.Free();
return value;
}
}
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp2);
}
// Step 10. Internal iterative deepening
if (ttMove == MoveC.MOVE_NONE && depth >= (PvNode ? 5 * DepthC.ONE_PLY : 8 * DepthC.ONE_PLY)
&& (PvNode || (!inCheck && ss[ssPos].staticEval + 256 >= beta)))
{
var d = (PvNode ? depth - 2 * DepthC.ONE_PLY : depth / 2);
ss[ssPos].skipNullMove = 1;
search(PvNode ? NodeTypeC.PV : NodeTypeC.NonPV, pos, ss, ssPos, alpha, beta, d);
ss[ssPos].skipNullMove = 0;
tteHasValue = TT.probe(posKey, ref ttePos, out tte);
ttMove = (tteHasValue) ? tte.move() : MoveC.MOVE_NONE;
}
else
{
// Re-read (needed as TTEntry is a struct in the port)
if ((tteHasValue) && (TT.table[ttePos].key == tte.key))
{
tte = TT.table[ttePos];
}
}
split_point_start: // At split points actual search starts from here
var mp = MovePickerBroker.GetObject();
mp.MovePickerC(
pos,
ttMove,
depth,
H,
ss[ssPos],
PvNode ? -ValueC.VALUE_INFINITE : beta,
SpNode ? ss[ssPos].sp.movePicker : null);
var ci = CheckInfoBroker.GetObject();
ci.CreateCheckInfo(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
singularExtensionNode = !RootNode && !SpNode && depth >= (PvNode ? 6 * DepthC.ONE_PLY : 8 * DepthC.ONE_PLY)
&& ttMove != MoveC.MOVE_NONE && (excludedMove == 0)
// Recursive singular search is not allowed
&& ((tte.type() & Bound.BOUND_LOWER) != 0) // FIXME: uninitialized!
&& tte.depth() >= depth - 3 * DepthC.ONE_PLY;
// Step 11. Loop through moves
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ((move = mp.next_move()) != MoveC.MOVE_NONE && !thisThread.cutoff_occurred()
&& !SignalsStop)
{
Debug.Assert(Utils.is_ok_M(move));
if (move == excludedMove)
{
continue;
}
// At root obey the "searchmoves" option and skip moves not listed in Root
// Move List, as a consequence any illegal move is also skipped. In MultiPV
// mode we also skip PV moves which have been already searched.
// If we find none, it means !count
if (RootNode && (find(RootMoves, PVIdx, RootMoves.Count, move) == -1))
{
continue;
}
if (SpNode)
{
// Shared counter cannot be decremented later if move turns out to be illegal
if (!pos.pl_move_is_legal(move, ci.pinned))
{
continue;
}
moveCount = ++sp.moveCount;
ThreadHelper.lock_release(sp.Lock);
}
else
{
moveCount++;
}
if (RootNode)
{
SignalsFirstRootMove = (moveCount == 1);
if (thisThread == Threads.main_thread() && SearchTime.ElapsedMilliseconds > 3000)
{
Plug.Write("info depth ");
Plug.Write((depth / DepthC.ONE_PLY).ToString());
Plug.Write(" currmove ");
Plug.Write(Utils.move_to_uci(move, pos.chess960));
Plug.Write(" nodes ");
Plug.Write(pos.nodes.ToString());
Plug.Write(" currmovenumber ");
Plug.Write((moveCount + PVIdx).ToString());
Plug.Write(Constants.endl);
}
}
ext = DepthC.DEPTH_ZERO;
captureOrPromotion = pos.is_capture_or_promotion(move);
givesCheck = pos.move_gives_check(move, ci);
dangerous = givesCheck
|| pos.is_passed_pawn_push(move)
|| Utils.type_of_move(move) == MoveTypeC.CASTLING
|| (captureOrPromotion // Entering a pawn endgame?
&& Utils.type_of(pos.piece_on(Utils.to_sq(move))) != PieceTypeC.PAWN
&& Utils.type_of_move(move) == MoveTypeC.NORMAL
&& (pos.non_pawn_material(ColorC.WHITE) + pos.non_pawn_material(ColorC.BLACK)
- Position.PieceValue[PhaseC.MG][pos.piece_on(Utils.to_sq(move))] == ValueC.VALUE_ZERO));
// Step 12. Extend checks and, in PV nodes, also dangerous moves
if (PvNode && dangerous)
{
ext = DepthC.ONE_PLY;
}
// else if (threatExtension && refutes(pos, move, threatMove))
// {
// ext = DepthC.ONE_PLY;
// }
else if (givesCheck && pos.see(move, true) >= 0)
{
ext = DepthC.ONE_PLY / 2;
}
// Singular extension search. If all moves but one fail low on a search of
// (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move
// is singular and should be extended. To verify this we do a reduced search
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttreMove.
if (singularExtensionNode && move == ttMove && (ext == 0) && pos.pl_move_is_legal(move, ci.pinned))
{
Debug.Assert(ttValue != ValueC.VALUE_NONE);
var rBeta = ttValue - depth;
ss[ssPos].excludedMove = move;
ss[ssPos].skipNullMove = 1;
value = search(NodeTypeC.NonPV, pos, ss, ssPos, rBeta - 1, rBeta, depth / 2);
ss[ssPos].skipNullMove = 0;
ss[ssPos].excludedMove = MoveC.MOVE_NONE;
if (value < rBeta)
{
ext = DepthC.ONE_PLY;
}
}
// Update current move (this must be done after singular extension search)
newDepth = depth - DepthC.ONE_PLY + ext;
// Step 13. Futility pruning (is omitted in PV nodes)
if (!PvNode
&& !captureOrPromotion
&& !inCheck
&& !dangerous
&& move != ttMove
&& (bestValue > ValueC.VALUE_MATED_IN_MAX_PLY || (bestValue == -ValueC.VALUE_INFINITE && alpha > ValueC.VALUE_MATED_IN_MAX_PLY)))
{
// Move count based pruning
if (depth < 16 * DepthC.ONE_PLY
&& moveCount >= FutilityMoveCounts[depth]
&& ((threatMove == 0) || !refutes(pos, move, threatMove)))
{
if (SpNode)
{
ThreadHelper.lock_grab(sp.Lock);
}
continue;
}
// Value based pruning
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
var predictedDepth = newDepth - reduction(PvNode, depth, moveCount);
futilityValue = ss[ssPos].staticEval + ss[ssPos].evalMargin + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_moved(move), Utils.to_sq(move));
if (futilityValue < beta)
{
if (SpNode)
{
ThreadHelper.lock_grab(sp.Lock);
}
continue;
}
// Prune moves with negative SEE at low depths
if (predictedDepth < 2 * DepthC.ONE_PLY && pos.see(move, true) < 0)
{
if (SpNode)
{
ThreadHelper.lock_grab(sp.Lock);
}
continue;
}
}
// Check for legality only before to do the move
if (!RootNode && !SpNode && !pos.pl_move_is_legal(move, ci.pinned))
{
moveCount--;
continue;
}
pvMove = (PvNode && moveCount == 1);
ss[ssPos].currentMove = move;
if (!SpNode && !captureOrPromotion && playedMoveCount < 64)
{
movesSearched[playedMoveCount++] = move;
}
// Step 14. Make the move
if (st == null)
{
st = StateInfoBroker.GetObject();
}
pos.do_move(move, st, ci, givesCheck);
// Step 15. Reduced depth search (LMR). If the move fails high will be
// re-searched at full depth.
if (depth > 3 * DepthC.ONE_PLY
&& !pvMove
&& !captureOrPromotion
&& !dangerous
&& move != ttMove
&& move != ss[ssPos].killers0
&& move != ss[ssPos].killers1)
{
ss[ssPos].reduction = reduction(PvNode, depth, moveCount);
var d = Math.Max(newDepth - ss[ssPos].reduction, DepthC.ONE_PLY);
alpha = SpNode ? sp.alpha : alpha;
value = -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -(alpha + 1), -alpha, d);
doFullDepthSearch = (value > alpha && ss[ssPos].reduction != DepthC.DEPTH_ZERO);
ss[ssPos].reduction = DepthC.DEPTH_ZERO;
}
else
{
doFullDepthSearch = !pvMove;
}
// Step 16. Full depth search, when LMR is skipped or fails high
if (doFullDepthSearch)
{
alpha = SpNode ? sp.alpha : alpha;
value = newDepth < DepthC.ONE_PLY
? -qsearch(NodeTypeC.NonPV, givesCheck, pos, ss, ssPos + 1, -(alpha + 1), -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.NonPV, pos, ss, ssPos + 1, -(alpha + 1), -alpha, newDepth);
}
// Only for PV nodes do a full PV search on the first move or after a fail
// high, in the latter case search only if value < beta, otherwise let the
// parentSplitPoint node to fail low with value <= alpha and to try another move.
if (PvNode && (pvMove || (value > alpha && (RootNode || value < beta))))
{
value = newDepth < DepthC.ONE_PLY
? -qsearch(NodeTypeC.PV, givesCheck, pos, ss, ssPos + 1, -beta, -alpha, DepthC.DEPTH_ZERO)
: -search(NodeTypeC.PV, pos, ss, ssPos + 1, -beta, -alpha, newDepth);
}
// Step 17. Undo move
pos.undo_move(move);
Debug.Assert(value > -ValueC.VALUE_INFINITE && value < ValueC.VALUE_INFINITE);
// Step 18. Check for new best move
if (SpNode)
{
ThreadHelper.lock_grab(sp.Lock);
bestValue = sp.bestValue;
alpha = sp.alpha;
}
// Finished searching the move. If Signals.stop is true, the search
// was aborted because the user interrupted the search or because we
// ran out of time. In this case, the return value of the search cannot
// be trusted, and we don't update the best move and/or PV.
if (SignalsStop || thisThread.cutoff_occurred())
{
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp);
MovesSearchedBroker.Free();
return value; // To avoid returning VALUE_INFINITE
}
// Finished searching the move. If Signals.stop is true, the search
// was aborted because the user interrupted the search or because we
// ran out of time. In this case, the return value of the search cannot
// be trusted, and we don't update the best move and/or PV.
if (RootNode)
{
var rmPos = find(RootMoves, 0, RootMoves.Count, move);
// PV move or new best move ?
if (pvMove || value > alpha)
{
RootMoves[rmPos].score = value;
RootMoves[rmPos].extract_pv_from_tt(pos);
// We record how often the best move has been changed in each
// iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
if (!pvMove)
{
BestMoveChanges++;
}
}
else
{
// All other moves but the PV are set to the lowest value, this
// is not a problem when sorting becuase sort is stable and move
// position in the list is preserved, just the PV is pushed up.
RootMoves[rmPos].score = -ValueC.VALUE_INFINITE;
}
}
if (value > bestValue)
{
bestValue = value;
if (SpNode) sp.bestValue = value;
if (value > alpha)
{
bestMove = move;
if (SpNode) sp.bestMove = move;
if (PvNode && value < beta)
{
alpha = value; // Update alpha here! Always alpha < beta
if (SpNode) sp.alpha = value;
}
else
{
Debug.Assert(value >= beta); // Fail high
if (SpNode) sp.cutoff = true;
break;
}
}
}
// Step 19. Check for split
if (!SpNode
&& depth >= Threads.minimumSplitDepth
&& Threads.available_slave(thisThread) != null
&& thisThread.splitPointsSize < Constants.MAX_SPLITPOINTS_PER_THREAD)
{
Debug.Assert(bestValue < beta);
Threads.split(
Constants.FakeSplit,
pos,
ss,
ssPos,
alpha,
beta,
ref bestValue,
ref bestMove,
depth,
threatMove,
moveCount,
mp,
NT);
if (bestValue >= beta)
{
break;
}
}
}
// Step 20. Check for mate and stalemate
// All legal moves have been searched and if there are no legal moves, it
// must be mate or stalemate. Note that we can have a false positive in
// case of Signals.stop or thread.cutoff_occurred() are set, but this is
// harmless because return value is discarded anyhow in the parentSplitPoint nodes.
// If we are in a singular extension search then return a fail low score.
// A split node has at least one move, the one tried before to be splitted.
if (!SpNode && moveCount == 0)
{
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp);
MovesSearchedBroker.Free();
return (excludedMove != 0) ? alpha : inCheck ? Utils.mated_in(ss[ssPos].ply) : DrawValue[pos.sideToMove];
}
// If we have pruned all the moves without searching return a fail-low score
if (bestValue == -ValueC.VALUE_INFINITE)
{
Debug.Assert(playedMoveCount == 0);
bestValue = alpha;
}
if (bestValue >= beta) // Failed high
{
TT.store(
posKey,
value_to_tt(bestValue, ss[ssPos].ply),
Bound.BOUND_LOWER,
depth,
bestMove,
ss[ssPos].staticEval,
ss[ssPos].evalMargin);
if (!pos.is_capture_or_promotion(bestMove) && !inCheck)
{
if (bestMove != ss[ssPos].killers0)
{
ss[ssPos].killers1 = ss[ssPos].killers0;
ss[ssPos].killers0 = bestMove;
}
// Increase history value of the cut-off move
var bonus = (depth * depth);
H.add(pos.piece_moved(bestMove), Utils.to_sq(bestMove), bonus);
// Decrease history of all the other played non-capture moves
for (var i = 0; i < playedMoveCount - 1; i++)
{
var m = movesSearched[i];
H.add(pos.piece_moved(m), Utils.to_sq(m), -bonus);
}
}
}
else // Failed low or PV search
{
TT.store(posKey, value_to_tt(bestValue, ss[ssPos].ply), PvNode && bestMove != MoveC.MOVE_NONE ? Bound.BOUND_EXACT : Bound.BOUND_UPPER, depth, bestMove, ss[ssPos].staticEval, ss[ssPos].evalMargin);
}
Debug.Assert(bestValue > -ValueC.VALUE_INFINITE && bestValue < ValueC.VALUE_INFINITE);
if (st != null)
{
st.previous = null;
StateInfoBroker.Free();
}
CheckInfoBroker.Free();
MovePickerBroker.Free(mp);
MovesSearchedBroker.Free();
return bestValue;
}
internal static void generate_evasion(Position pos, MoveStack[] ms, ref int mpos)
{
/// generate<EVASIONS> generates all pseudo-legal check evasions when the side
/// to move is in check. Returns a pointer to the end of the move list.
Debug.Assert(pos.in_check());
ulong b;
int from, checksq;
var checkersCnt = 0;
var us = pos.sideToMove;
var ksq = pos.king_square(us);
ulong sliderAttacks = 0;
var checkers = pos.st.checkersBB;
Debug.Assert(checkers != 0);
// Find squares attacked by slider checkers, we will remove them from the king
// evasions so to skip known illegal moves avoiding useless legality check later.
b = checkers;
do
{
checkersCnt++;
checksq = Utils.pop_lsb(ref b);
Debug.Assert(Utils.color_of(pos.piece_on(checksq)) == Utils.flip_C(us));
switch (Utils.type_of(pos.piece_on(checksq)))
{
case PieceTypeC.BISHOP:
sliderAttacks |= Utils.PseudoAttacks[PieceTypeC.BISHOP][checksq];
break;
case PieceTypeC.ROOK:
sliderAttacks |= Utils.PseudoAttacks[PieceTypeC.ROOK][checksq];
break;
case PieceTypeC.QUEEN:
// If queen and king are far or not on a diagonal line we can safely
// remove all the squares attacked in the other direction becuase are
// not reachable by the king anyway.
if ((Utils.between_bb(ksq, checksq) != 0)
|| ((Utils.bit_is_set(Utils.PseudoAttacks[PieceTypeC.BISHOP][checksq], ksq)) == 0))
{
sliderAttacks |= Utils.PseudoAttacks[PieceTypeC.QUEEN][checksq];
}
// Otherwise we need to use real rook attacks to check if king is safe
// to move in the other direction. For example: king in B2, queen in A1
// a knight in B1, and we can safely move to C1.
else
{
sliderAttacks |= Utils.PseudoAttacks[PieceTypeC.BISHOP][checksq]
| pos.attacks_from_ROOK(checksq);
}
break;
default:
break;
}
}
while (b != 0);
// Generate evasions for king, capture and non capture moves
b = Position.attacks_from_KING(ksq) & ~pos.pieces_C(us) & ~sliderAttacks;
from = ksq;
while (b != 0)
{
ms[mpos++].move = Utils.make_move(from, Utils.pop_lsb(ref b));
}
// Generate evasions for other pieces only if not under a double check
if (checkersCnt > 1)
{
return;
}
// Blocking evasions or captures of the checking piece
var target = Utils.between_bb(checksq, ksq) | checkers;
generate_all(GenType.EVASIONS, pos, ms, ref mpos, us, target, null);
}
// refutes() tests whether a 'first' move is able to defend against a 'second'
// opponent's move. In this case will not be pruned. Normally the second move
// is the threat (the best move returned from a null search that fails low).
private static bool refutes(Position pos, int move, int threat)
{
Debug.Assert(Utils.is_ok_M(move));
Debug.Assert(Utils.is_ok_M(threat));
Square mfrom = Utils.from_sq(move);
Square mto = Utils.to_sq(move);
Square tfrom = Utils.from_sq(threat);
Square tto = Utils.to_sq(threat);
// Don't prune moves of the threatened piece
if (mfrom == tto)
{
return true;
}
// If the threatened piece has value less than or equal to the value of the
// threat piece, don't prune moves which defend it.
if (pos.is_capture(threat)
&& (Position.PieceValue[PhaseC.MG][pos.piece_on(tfrom)] >= Position.PieceValue[PhaseC.MG][pos.piece_on(tto)]
|| Utils.type_of(pos.piece_on(tfrom)) == PieceTypeC.KING))
{
// Update occupancy as if the piece and the threat are moving
var occ = Utils.xor_bit(Utils.xor_bit(Utils.xor_bit(pos.occupied_squares, mfrom), mto), tfrom);
Piece piece = pos.piece_on(mfrom);
// The piece moved in 'to' attacks the square 's' ?
if (Utils.bit_is_set(Position.attacks_from(piece, mto, occ), tto) != 0)
{
return true;
}
// Scan for possible X-ray attackers behind the moved piece
var xray = (Utils.rook_attacks_bb(tto, occ)
& pos.pieces(PieceTypeC.ROOK, PieceTypeC.QUEEN, Utils.color_of(piece)))
| (Utils.bishop_attacks_bb(tto, occ)
& pos.pieces(PieceTypeC.BISHOP, PieceTypeC.QUEEN, Utils.color_of(piece)));
// Verify attackers are triggered by our move and not already existing
if ((xray != 0) && ((xray ^ (xray & pos.attacks_from_QUEEN(tto))) != 0))
{
return true;
}
}
// Don't prune safe moves which block the threat path
if ((Utils.bit_is_set(Utils.between_bb(tfrom, tto), mto) != 0) && pos.see(move, true) >= 0)
{
return true;
}
return false;
}
// allows() tests whether the 'first' move at previous ply somehow makes the
// 'second' move possible, for instance if the moving piece is the same in
// both moves. Normally the second move is the threat (the best move returned
// from a null search that fails low).
internal static bool allows(Position pos, int first, int second)
{
Debug.Assert(Utils.is_ok_M(first));
Debug.Assert(Utils.is_ok_M(second));
Debug.Assert(Utils.color_of(pos.piece_on(Utils.from_sq(second))) == 1 - pos.sideToMove);
Square m1to = Utils.to_sq(first);
Square m1from = Utils.from_sq(first);
Square m2to = Utils.to_sq(second);
Square m2from = Utils.from_sq(second);
// The piece is the same or second's destination was vacated by the first move
if (m1to == m2from || m2to == m1from)
{
return true;
}
// Second one moves through the square vacated by first one
if (Utils.bit_is_set(Utils.between_bb(m2from, m2to), m1from) != 0)
{
return true;
}
// Second's destination is defended by the first move's piece
Bitboard m1att = Position.attacks_from(pos.piece_on(m1to), m1to, pos.occupied_squares ^ (ulong)m2from);
if (Utils.bit_is_set(m1att, m2to) != 0)
{
return true;
}
// Second move gives a discovered check through the first's checking piece
if (Utils.bit_is_set(m1att, pos.king_square(pos.sideToMove)) != 0 &&
Utils.bit_is_set(Utils.between_bb(m1to, pos.king_square(pos.sideToMove)), m2from) != 0) // TODO: removing condition asserts below
{
Debug.Assert(Utils.bit_is_set(Utils.between_bb(m1to, pos.king_square(pos.sideToMove)), m2from) != 0);
return true;
}
return false;
}
// check_is_dangerous() tests if a checking move can be pruned in qsearch().
// bestValue is updated only when returning false because in that case move
// will be pruned.
private static bool check_is_dangerous(Position pos, int move, int futilityBase, int beta)
{
//ulong b, occ, oldAtt, newAtt, kingAtt;
//int from, to, ksq;
//int pc;
//int them;
//from = Utils.from_sq(move);
//to = Utils.to_sq(move);
//them = Utils.flip_C(pos.sideToMove);
//ksq = pos.king_square(them);
//kingAtt = Position.attacks_from_KING(ksq);
//pc = pos.piece_moved(move);
//occ = pos.occupied_squares ^ Utils.SquareBB[from] ^ Utils.SquareBB[ksq];
//oldAtt = Position.attacks_from(pc, from, occ);
//newAtt = Position.attacks_from(pc, to, occ);
//// Rule 1. Checks which give opponent's king at most one escape square are dangerous
//b = kingAtt & ~pos.pieces_C(them) & ~newAtt & ~(1UL << to);
//if ((b & (b - 1)) == 0) // Catches also !b
Piece pc = pos.piece_moved(move);
Square from = Utils.from_sq(move);
Square to = Utils.to_sq(move);
Color them = pos.sideToMove ^ 1;
Square ksq = pos.king_square(them);
Bitboard enemies = pos.pieces_C(them);
Bitboard kingAtt = Position.attacks_from_KING(ksq);
Bitboard occ = pos.occupied_squares ^ Utils.SquareBB[from] ^ Utils.SquareBB[ksq];
Bitboard oldAtt = Position.attacks_from(pc, from, occ);
Bitboard newAtt = Position.attacks_from(pc, to, occ);
// Checks which give opponent's king at most one escape square are dangerous
if (!Utils.more_than_one(kingAtt & ~(enemies | newAtt | (ulong)to)))
{
return true;
}
// Queen contact check is very dangerous
if (Utils.type_of(pc) == PieceTypeC.QUEEN && (Utils.bit_is_set(kingAtt, to) != 0))
{
return true;
}
// Creating new double threats with checks is dangerous
Bitboard b = (enemies ^ (ulong)ksq) & newAtt & ~oldAtt;
while (b != 0)
{
// Note that here we generate illegal "double move"!
if (futilityBase + Position.PieceValue[PhaseC.EG][pos.piece_on(Utils.pop_lsb(ref b))] >= beta)
{
return true;
}
}
return false;
}
internal static void generate_quiet_check(Position pos, MoveStack[] ms, ref int mpos)
{
/// generate<MV_NON_CAPTURE_CHECK> generates all pseudo-legal non-captures and knight
/// underpromotions that give check. Returns a pointer to the end of the move list.
Debug.Assert(!pos.in_check());
Color us = pos.sideToMove;
CheckInfo ci = CheckInfoBroker.GetObject();
ci.CreateCheckInfo(pos);
Bitboard dc = ci.dcCandidates;
while (dc != 0)
{
Square from = Utils.pop_1st_bit(ref dc);
PieceType pt = Utils.type_of(pos.piece_on(from));
if (pt == PieceTypeC.PAWN)
continue; // Will be generated together with direct checks
Bitboard b = pos.attacks_from_PTS(pt, from) & ~pos.occupied_squares;
if (pt == PieceTypeC.KING)
b &= ~Utils.PseudoAttacks[PieceTypeC.QUEEN][ci.ksq];
while (b != 0) { ms[mpos++].move = Utils.make_move(from, Utils.pop_1st_bit(ref b)); }
}
generate_pawn_moves(us, MoveType.MV_QUIET_CHECK, pos, ms, ref mpos, ci.dcCandidates, ci.ksq);
generate_direct_checks(PieceTypeC.KNIGHT, pos, ms, ref mpos, us, ci);
generate_direct_checks(PieceTypeC.BISHOP, pos, ms, ref mpos, us, ci);
generate_direct_checks(PieceTypeC.ROOK, pos, ms, ref mpos, us, ci);
generate_direct_checks(PieceTypeC.QUEEN, pos, ms, ref mpos, us, ci);
if (pos.can_castle_C(us) != 0)
{
generate_castle(CastlingSideC.KING_SIDE, true, pos, ms, ref mpos, us);
generate_castle(CastlingSideC.QUEEN_SIDE, true, pos, ms, ref mpos, us);
}
CheckInfoBroker.Free();
}
/// flip() flips position with the white and black sides reversed. This
/// is only useful for debugging especially for finding evaluation symmetry bugs.
internal void flip()
{
// Make a copy of current position before to start changing
Position pos = new Position(this);
clear();
sideToMove = pos.sideToMove ^ 1;
thisThread = pos.this_thread();
nodes = pos.nodes;
chess960 = pos.chess960;
startPosPly = pos.startpos_ply_counter();
for (Square s = SquareC.SQ_A1; s <= SquareC.SQ_H8; s++)
if (!pos.is_empty(s))
put_piece((pos.piece_on(s) ^ 8), Utils.flip_S(s));
if (pos.can_castle_CR(CastleRightC.WHITE_OO) != 0)
set_castle_right(ColorC.BLACK, Utils.flip_S(pos.castle_rook_square(ColorC.WHITE, CastlingSideC.KING_SIDE)));
if (pos.can_castle_CR(CastleRightC.WHITE_OOO) != 0)
set_castle_right(ColorC.BLACK, Utils.flip_S(pos.castle_rook_square(ColorC.WHITE, CastlingSideC.QUEEN_SIDE)));
if (pos.can_castle_CR(CastleRightC.BLACK_OO) != 0)
set_castle_right(ColorC.WHITE, Utils.flip_S(pos.castle_rook_square(ColorC.BLACK, CastlingSideC.KING_SIDE)));
if (pos.can_castle_CR(CastleRightC.BLACK_OOO) != 0)
set_castle_right(ColorC.WHITE, Utils.flip_S(pos.castle_rook_square(ColorC.BLACK, CastlingSideC.QUEEN_SIDE)));
if (pos.st.epSquare != SquareC.SQ_NONE)
st.epSquare = Utils.flip_S(pos.st.epSquare);
// Checkers
st.checkersBB = attackers_to(king_square(sideToMove)) & pieces_C(Utils.flip_C(sideToMove));
// Hash keys
st.key = compute_key();
st.pawnKey = compute_pawn_key();
st.materialKey = compute_material_key();
// Incremental scores
st.psqScore = compute_psq_score();
// Material
st.npMaterialWHITE = compute_non_pawn_material(ColorC.WHITE);
st.npMaterialBLACK = compute_non_pawn_material(ColorC.BLACK);
Debug.Assert(pos_is_ok());
}
