void cEval::ScoreHanging(POS *p, eData *e, int sd) {
int pc, sq, sc;
int op = Opp(sd);
U64 bbHanging = p->cl_bb[op] & ~e->bbPawnTakes[op];
U64 bbThreatened = p->cl_bb[op] & e->bbPawnTakes[sd];
bbHanging |= bbThreatened; // piece attacked by our pawn isn't well defended
bbHanging &= e->bbAllAttacks[sd]; // hanging piece has to be attacked
bbHanging &= ~p->Pawns(op); // currently we don't evaluate threats against pawns
U64 bbDefended = p->cl_bb[op] & e->bbAllAttacks[op];
bbDefended &= e->bbEvAttacks[sd]; // N, B, R attacks (pieces attacked by pawns are scored as hanging)
bbDefended &= ~e->bbPawnTakes[sd]; // no defense against pawn attack
bbDefended &= ~p->Pawns(op); // currently we don't evaluate threats against pawns
// hanging pieces (attacked and undefended)
while (bbHanging) {
sq = BB.PopFirstBit(&bbHanging);
pc = TpOnSq(p, sq);
sc = tp_value[pc] / 64;
Add(e, sd, F_PRESSURE, 10 + sc, 18 + sc);
}
// defended pieces under attack
while (bbDefended) {
sq = BB.PopFirstBit(&bbDefended);
pc = TpOnSq(p, sq);
sc = tp_value[pc] / 96;
Add(e, sd, F_PRESSURE, 5 + sc, 9 + sc);
}
}
int StrToMove(POS *p, char *move_str) {
int from, to, type;
from = Sq(move_str[0] - 'a', move_str[1] - '1');
to = Sq(move_str[2] - 'a', move_str[3] - '1');
type = NORMAL;
if (TpOnSq(p, from) == K && Abs(to - from) == 2)
type = CASTLE;
else if (TpOnSq(p, from) == P) {
if (to == p->ep_sq)
type = EP_CAP;
else if (Abs(to - from) == 16)
type = EP_SET;
else if (move_str[4] != '\0')
switch (move_str[4]) {
case 'n':
type = N_PROM;
break;
case 'b':
type = B_PROM;
break;
case 'r':
type = R_PROM;
break;
case 'q':
type = Q_PROM;
break;
}
}
return (type << 12) | (to << 6) | from;
}
int MvvLva(POS *p, int move) {
// Captures
if (p->pc[Tsq(move)] != NO_PC)
return TpOnSq(p, Tsq(move)) * 6 + 5 - TpOnSq(p, Fsq(move));
// Non-capturing promotions
if (IsProm(move)) return PromType(move) - 5;
return 5;
}
void ScoreQuiet(MOVES *m) {
int *movep, *valuep;
int move_score;
valuep = m->value;
for (movep = m->move; movep < m->last; movep++) {
move_score = history[m->p->pc[Fsq(*movep)]][Tsq(*movep)];
if (TpOnSq(m->p,Fsq(*movep)) != K)
move_score += Param.mg_pst[m->p->side][TpOnSq(m->p,Fsq(*movep))][Tsq(*movep)]
- Param.mg_pst[m->p->side][TpOnSq(m->p, Fsq(*movep))][Fsq(*movep)];
//if (Fsq(*movep) == m->ref_sq && m->ref_sq != -1) move_score += 2048;
*valuep++ = move_score;
}
}
U64 AttacksFrom(POS *p, int sq) {
switch (TpOnSq(p, sq)) {
case P:
return BB.PawnAttacks(Cl(p->pc[sq]), sq);
case N:
return BB.KnightAttacks(sq);
case B:
return BB.BishAttacks(OccBb(p), sq);
case R:
return BB.RookAttacks(OccBb(p), sq);
case Q:
return BB.QueenAttacks(OccBb(p), sq);
case K:
return BB.KingAttacks(sq);
}
return 0;
}
int BadCapture(POS *p, int move) {
int fsq = Fsq(move);
int tsq = Tsq(move);
// Captures that gain material or capture equal piece are good by definition
if (tp_value[TpOnSq(p, tsq)] >= tp_value[TpOnSq(p, fsq)])
return 0;
// Bishop takes knight and knight takes bishop are good irrespectively from
// the way minor pieces' values are tuned
if ((TpOnSq(p, fsq) == B) && (TpOnSq(p, tsq) == N)) return 0;
if ((TpOnSq(p, fsq) == N) && (TpOnSq(p, tsq) == B)) return 0;
// En passant captures are good by definition
if (MoveType(move) == EP_CAP) return 0;
// We have to evaluate this capture using expensive Static Exchange Evaluation
return Swap(p, fsq, tsq) < 0;
}
void sManipulator::DoMove(sPosition *p, int move, UNDO *u)
{
int side = p->side; // moving side
int fsq = Fsq(move); // start square
int tsq = Tsq(move); // target square
int ftp = TpOnSq(p, fsq); // moving piece
int ttp = TpOnSq(p, tsq); // captured piece
U64 bbMove = SqBb(fsq) | SqBb(tsq); // optimization from Stockfish
// save data for undoing a move
u->ttp = ttp;
u->castleFlags = p->castleFlags;
u->epSquare = p->epSquare;
u->reversibleMoves = p->reversibleMoves;
u->hashKey = p->hashKey;
u->pawnKey = p->pawnKey;
p->repetitionList[p->head++] = p->hashKey;
// update reversible move counter (zeroing is done on captures and pawn moves)
p->reversibleMoves++;
p->hashKey ^= zobCastle[p->castleFlags];
p->castleFlags &= castleMask[fsq] & castleMask[tsq];
p->hashKey ^= zobCastle[p->castleFlags];
// clear en passant square
if (p->epSquare != NO_SQ) {
p->hashKey ^= zobEp[File(p->epSquare)];
p->epSquare = NO_SQ;
}
// move a piece from start square
p->pc[fsq] = NO_PC;
p->pc[tsq] = Pc(side, ftp);
p->hashKey ^= zobPiece[Pc(side, ftp)][fsq] ^ zobPiece[Pc(side, ftp)][tsq];
if (ftp == P) {
p->reversibleMoves = 0;
p->pawnKey ^= zobPiece[Pc(side, ftp)][fsq] ^ zobPiece[Pc(side, ftp)][tsq];
}
p->bbCl[side] ^= bbMove;
p->bbTp[ftp] ^= bbMove;
p->pstMg[side] += Data.pstMg[side][ftp][tsq] - Data.pstMg[side][ftp][fsq];
p->pstEg[side] += Data.pstEg[side][ftp][tsq] - Data.pstEg[side][ftp][fsq];
// on a king move update king location data
if (ftp == K) p->kingSquare[side] = tsq;
// capture
if (ttp != NO_TP) {
p->reversibleMoves = 0;
p->hashKey ^= zobPiece[Pc(Opp(side), ttp)][tsq];
if (ttp == P)
p->pawnKey ^= zobPiece[Pc(Opp(side), ttp)][tsq];
p->bbCl[Opp(side)] ^= SqBb(tsq);
p->bbTp[ttp] ^= SqBb(tsq);
p->pcCount[Opp(side)][ttp]--;
p->pieceMat[Opp(side)] -= Data.matValue[ttp];
p->phase -= Data.phaseValue[ttp];
p->pstMg[Opp(side)] -= Data.pstMg[Opp(side)][ttp][tsq];
p->pstEg[Opp(side)] -= Data.pstEg[Opp(side)][ttp][tsq];
}
switch (MoveType(move)) {
case NORMAL:
break;
case CASTLE:
if (tsq > fsq) {
fsq += 3;
tsq -= 1;
} else {
fsq -= 4;
tsq += 1;
}
p->pc[fsq] = NO_PC;
p->pc[tsq] = Pc(side, R);
p->hashKey ^= zobPiece[Pc(side, R)][fsq] ^ zobPiece[Pc(side, R)][tsq];
p->bbCl[side] ^= SqBb(fsq) | SqBb(tsq);
p->bbTp[R] ^= SqBb(fsq) | SqBb(tsq);
p->pstMg[side] += Data.pstMg[side][R][tsq] - Data.pstMg[side][R][fsq];
p->pstEg[side] += Data.pstEg[side][R][tsq] - Data.pstEg[side][R][fsq];
break;
case EP_CAP:
tsq ^= 8;
p->pc[tsq] = NO_PC;
p->hashKey ^= zobPiece[Pc(Opp(side), P)][tsq];
p->pawnKey ^= zobPiece[Pc(Opp(side), P)][tsq];
p->bbCl[Opp(side)] ^= SqBb(tsq);
p->bbTp[P] ^= SqBb(tsq);
p->pcCount[Opp(side)][P]--;
p->phase -= Data.phaseValue[P];
p->pstMg[Opp(side)] -= Data.pstMg[Opp(side)][P][tsq];
p->pstEg[Opp(side)] -= Data.pstEg[Opp(side)][P][tsq];
break;
case EP_SET:
tsq ^= 8;
if (bbPawnAttacks[side][tsq] & bbPc(p, Opp(side), P)) {
p->epSquare = tsq;
p->hashKey ^= zobEp[File(tsq)];
}
break;
// promotion: (1) add promoted piece and add values associated with it
case N_PROM: // (2) remove promoted pawn and substract values associated with it
case B_PROM:
case R_PROM:
case Q_PROM:
ftp = PromType(move);
p->pc[tsq] = Pc(side, ftp);
p->hashKey ^= zobPiece[Pc(side, P)][tsq] ^ zobPiece[Pc(side, ftp)][tsq];
p->pawnKey ^= zobPiece[Pc(side, P)][tsq];
p->bbTp[P] ^= SqBb(tsq);
p->bbTp[ftp]^= SqBb(tsq);
p->pcCount[side][ftp]++;
p->pcCount[side][P]--;
p->pieceMat[side] += Data.matValue[ftp];
p->phase += Data.phaseValue[ftp] - Data.phaseValue[P];
p->pstMg[side] += Data.pstMg[side][ftp][tsq] - Data.pstMg[side][P][tsq];
p->pstEg[side] += Data.pstEg[side][ftp][tsq] - Data.pstEg[side][P][tsq];
break;
}
p->side ^= 1;
p->hashKey ^= SIDE_RANDOM;
}
int Quiesce(POS *p, int ply, int alpha, int beta, int *pv) {
int best, score, move, new_pv[MAX_PLY];
MOVES m[1];
UNDO u[1];
int op = Opp(p->side);
// Statistics and attempt at quick exit
if (InCheck(p)) return QuiesceFlee(p, ply, alpha, beta, pv);
nodes++;
CheckTimeout();
if (abort_search) return 0;
*pv = 0;
if (IsDraw(p)) return DrawScore(p);
if (ply >= MAX_PLY - 1) return Eval.Return(p, 1);
// Get a stand-pat score and adjust bounds
// (exiting if eval exceeds beta)
best = Eval.Return(p, 1);
if (best >= beta) return best;
if (best > alpha) alpha = best;
#ifdef USE_QS_HASH
// Transposition table read
if (TransRetrieve(p->hash_key, &move, &score, alpha, beta, 0, ply))
return score;
#endif
InitCaptures(p, m);
// Main loop
while ((move = NextCapture(m))) {
// Pruning in quiescence search
// (not applicable if we are capturing last enemy piece)
if (p->cnt[op][N] + p->cnt[op][B] + p->cnt[op][R] + p->cnt[op][Q] > 1) {
// 1. Delta pruning
if (best + tp_value[TpOnSq(p, Tsq(move))] + 300 < alpha) continue;
// 2. SEE-based pruning of bad captures
if (BadCapture(p, move)) continue;
}
p->DoMove(move, u);
if (Illegal(p)) { p->UndoMove(move, u); continue; }
score = -Quiesce(p, ply + 1, -beta, -alpha, new_pv);
p->UndoMove(move, u);
if (abort_search) return 0;
// Beta cutoff
if (score >= beta) {
#ifdef USE_QS_HASH
TransStore(p->hash_key, *pv, best, LOWER, 0, ply);
#endif
return score;
}
// Adjust alpha and score
if (score > best) {
best = score;
if (score > alpha) {
alpha = score;
BuildPv(pv, new_pv, move);
}
}
}
#ifdef USE_QS_HASH
if (*pv) TransStore(p->hash_key, *pv, best, EXACT, 0, ply);
else TransStore(p->hash_key, 0, best, UPPER, 0, ply);
#endif
return best;
}
int Search(POS *p, int ply, int alpha, int beta, int depth, int was_null, int last_move, int last_capt_sq, int *pv) {
int best, score, null_score, move, new_depth, new_pv[MAX_PLY];
int fl_check, fl_prunable_node, fl_prunable_move, mv_type, reduction;
int is_pv = (beta > alpha + 1);
int mv_tried = 0, quiet_tried = 0, fl_futility = 0;
int mv_played[MAX_MOVES];
int mv_hist_score;
int victim, last_capt;
MOVES m[1];
UNDO u[1];
assert(ply > 0);
// Quiescence search entry point
if (depth <= 0)
return QuiesceChecks(p, ply, alpha, beta, pv);
// Periodically check for timeout, ponderhit or stop command
nodes++;
CheckTimeout();
// Quick exit on a timeout or on a statically detected draw
if (abort_search) return 0;
if (ply) *pv = 0;
if (IsDraw(p)) return DrawScore(p);
// Mate distance pruning
int checkmatingScore = MATE - ply;
if (checkmatingScore < beta) {
beta = checkmatingScore;
if (alpha >= checkmatingScore)
return alpha;
}
int checkmatedScore = -MATE + ply;
if (checkmatedScore > alpha) {
alpha = checkmatedScore;
if (beta <= checkmatedScore)
return beta;
}
// Retrieving data from transposition table. We hope for a cutoff
// or at least for a move to improve move ordering.
move = 0;
if (TransRetrieve(p->hash_key, &move, &score, alpha, beta, depth, ply)) {
// For move ordering purposes, a cutoff from hash is treated
// exactly like a cutoff from search
if (score >= beta) UpdateHistory(p, last_move, move, depth, ply);
// In pv nodes only exact scores are returned. This is done because
// there is much more pruning and reductions in zero-window nodes,
// so retrieving such scores in pv nodes works like retrieving scores
// from slightly lower depth.
if (!is_pv || (score > alpha && score < beta))
return score;
}
// Safeguard against exceeding ply limit
if (ply >= MAX_PLY - 1)
return Eval.Return(p, 1);
// Are we in check? Knowing that is useful when it comes
// to pruning/reduction decisions
fl_check = InCheck(p);
// INTERNAL ITERATIVE DEEPENING - we try to get a hash move to improve move ordering
if (!move && is_pv && depth >= 6 && !fl_check) {
Search(p, ply, alpha, beta, depth - 2, 0, 0, -1, new_pv);
if (abort_search) return 0;
TransRetrieve(p->hash_key, &move, &score, alpha, beta, depth, ply);
}
// Can we prune this node?
fl_prunable_node = !fl_check
&& !is_pv
&& alpha > -MAX_EVAL
&& beta < MAX_EVAL;
// Beta pruning / static null move
if (use_beta_pruning
&& fl_prunable_node
&& depth <= 3
&& !was_null) {
int sc = Eval.Return(p, 1) - 120 * depth; // TODO: Tune me!
if (sc > beta) return sc;
}
// Null move
if (use_nullmove
&& fl_prunable_node
&& depth > 1
&& !was_null
&& MayNull(p)
) {
int eval = Eval.Return(p, 1);
if (eval > beta) {
new_depth = depth - ((823 + 67 * depth) / 256); // simplified Stockfish formula
// omit null move search if normal search to the same depth wouldn't exceed beta
// (sometimes we can check it for free via hash table)
if (TransRetrieve(p->hash_key, &move, &null_score, alpha, beta, new_depth, ply)) {
if (null_score < beta) goto avoid_null;
}
p->DoNull(u);
if (new_depth > 0) score = -Search(p, ply + 1, -beta, -beta + 1, new_depth, 1, 0, -1, new_pv);
else score = -QuiesceChecks(p, ply + 1, -beta, -beta + 1, new_pv);
p->UndoNull(u);
// Verification search (nb. immediate null move within it is prohibited)
if (new_depth > 6 && score >= beta && use_null_verification)
score = Search(p, ply, alpha, beta, new_depth - 5, 1, move, -1, new_pv);
if (abort_search ) return 0;
if (score >= beta) return score;
}
}
avoid_null:
// end of null move code
// Razoring based on Toga II 3.0
if (use_razoring
&& fl_prunable_node
&& !move
&& !was_null
&& !(p->Pawns(p->side) & bbRelRank[p->side][RANK_7]) // no pawns to promote in one move
&& depth <= 3) {
int threshold = beta - razor_margin[depth];
int eval = Eval.Return(p, 1);
if (eval < threshold) {
score = QuiesceChecks(p, ply, alpha, beta, pv);
if (score < threshold) return score;
}
}
// end of razoring code
// Init moves and variables before entering main loop
best = -INF;
InitMoves(p, m, move, Refutation(last_move), ply);
// Main loop
while ((move = NextMove(m, &mv_type))) {
// Gather data about the move
mv_hist_score = history[p->pc[Fsq(move)]][Tsq(move)];
victim = TpOnSq(p, Tsq(move));
if (victim != NO_TP) last_capt = Tsq(move);
else last_capt = -1;
// Set futility pruning flag before the first applicable move is tried
if (mv_type == MV_NORMAL && quiet_tried == 0) {
if (use_futility
&& fl_prunable_node
&& depth <= 6) {
if (Eval.Return(p, 1) + fut_margin[depth] < beta) fl_futility = 1;
}
}
p->DoMove(move, u);
if (Illegal(p)) { p->UndoMove(move, u); continue; }
// Update move statistics
// (needed for reduction/pruning decisions and for updating history score)
mv_played[mv_tried] = move;
mv_tried++;
if (mv_type == MV_NORMAL) quiet_tried++;
// Can we prune this move?
fl_prunable_move = !InCheck(p)
&& (mv_type == MV_NORMAL)
&& (mv_hist_score < hist_limit);
// Set new search depth
new_depth = depth - 1;
// Check extension (pv node or low depth)
if (is_pv || depth < 9) {
new_depth += InCheck(p);
if (is_pv && Tsq(move) == last_capt_sq) new_depth += 1;
}
// Futility pruning
if (fl_futility
&& fl_prunable_move
&& mv_tried > 1) {
p->UndoMove(move, u); continue;
}
// Late move pruning
if (use_lmp
&& fl_prunable_node
&& fl_prunable_move
&& quiet_tried > lmp_limit[depth]
&& depth <= 3
&& MoveType(move) != CASTLE ) {
p->UndoMove(move, u); continue;
}
// Late move reduction
reduction = 0;
if (use_lmr
&& depth >= 2
&& mv_tried > 3
&& alpha > -MAX_EVAL && beta < MAX_EVAL
&& !fl_check
&& fl_prunable_move
&& lmr_size[is_pv][depth][mv_tried] > 0
&& MoveType(move) != CASTLE ) {
// read reduction size from the table
reduction = lmr_size[is_pv][depth][mv_tried];
// increase reduction on bad history score
if (mv_hist_score < 0
&& new_depth - reduction > 2
&& lmr_hist_adjustement)
reduction++;
// reduce search depth
new_depth -= reduction;
}
// a place to come back if reduction looks suspect
re_search:
// PVS
if (best == -INF)
score = -Search(p, ply + 1, -beta, -alpha, new_depth, 0, move, last_capt, new_pv);
else {
score = -Search(p, ply + 1, -alpha - 1, -alpha, new_depth, 0, move, last_capt, new_pv);
if (!abort_search && score > alpha && score < beta)
score = -Search(p, ply + 1, -beta, -alpha, new_depth, 0, move, last_capt, new_pv);
}
// Reduced move scored above alpha - we need to re-search it
if (reduction
&& score > alpha) {
new_depth += reduction;
reduction = 0;
goto re_search;
}
// Undo move
p->UndoMove(move, u);
if (abort_search) return 0;
// Beta cutoff
if (score >= beta) {
if (!fl_check) {
UpdateHistory(p, last_move, move, depth, ply);
for (int mv = 0; mv < mv_tried; mv++)
DecreaseHistory(p, mv_played[mv], depth);
}
TransStore(p->hash_key, move, score, LOWER, depth, ply);
return score;
}
// Updating score and alpha
if (score > best) {
best = score;
if (score > alpha) {
alpha = score;
BuildPv(pv, new_pv, move);
}
}
} // end of the main loop
// Return correct checkmate/stalemate score
if (best == -INF)
return InCheck(p) ? -MATE + ply : DrawScore(p);
// Save score in the transposition table
if (*pv) {
if (!fl_check) {
UpdateHistory(p, last_move, *pv, depth, ply);
for (int mv = 0; mv < mv_tried; mv++)
DecreaseHistory(p, mv_played[mv], depth);
}
TransStore(p->hash_key, *pv, best, EXACT, depth, ply);
} else
TransStore(p->hash_key, 0, best, UPPER, depth, ply);
return best;
}
int SearchRoot(POS *p, int ply, int alpha, int beta, int depth, int *pv) {
int best, score, move, new_depth, new_pv[MAX_PLY];
int fl_check, fl_prunable_move, mv_type, reduction;
int mv_tried = 0, quiet_tried = 0;
int mv_played[MAX_MOVES];
int mv_hist_score;
int victim, last_capt;
int move_change = 0;
fl_has_choice = 0;
MOVES m[1];
UNDO u[1];
// Periodically check for timeout, ponderhit or stop command
nodes++;
CheckTimeout();
// Quick exit
if (abort_search) return 0;
// Retrieving data from transposition table. We hope for a cutoff
// or at least for a move to improve move ordering.
move = 0;
if (TransRetrieve(p->hash_key, &move, &score, alpha, beta, depth, ply)) {
// For move ordering purposes, a cutoff from hash is treated
// exactly like a cutoff from search
if (score >= beta) UpdateHistory(p, -1, move, depth, ply);
// Root node is a pv node, so we return only exact scores
if (score > alpha && score < beta)
return score;
}
// Are we in check? Knowing that is useful when it comes
// to pruning/reduction decisions
fl_check = InCheck(p);
// Init moves and variables before entering main loop
best = -INF;
InitMoves(p, m, move, Refutation(-1), ply);
// Main loop
while ((move = NextMove(m, &mv_type))) {
mv_hist_score = history[p->pc[Fsq(move)]][Tsq(move)];
victim = TpOnSq(p, Tsq(move));
if (victim != NO_TP) last_capt = Tsq(move);
else last_capt = -1;
p->DoMove(move, u);
if (Illegal(p)) { p->UndoMove(move, u); continue; }
// Update move statistics (needed for reduction/pruning decisions)
mv_played[mv_tried] = move;
mv_tried++;
if (mv_tried > 1) fl_has_choice = 1; // we have a choice between at least two root moves
if (depth > 16 && verbose) DisplayCurrmove(move, mv_tried);
if (mv_type == MV_NORMAL) quiet_tried++;
fl_prunable_move = !InCheck(p) && (mv_type == MV_NORMAL);
// Set new search depth
new_depth = depth - 1 + InCheck(p);
// Late move reduction
reduction = 0;
if (use_lmr
&& depth >= 2
&& mv_tried > 3
&& mv_hist_score < hist_limit
&& alpha > -MAX_EVAL && beta < MAX_EVAL
&& !fl_check
&& fl_prunable_move
&& lmr_size[1][depth][mv_tried] > 0
&& MoveType(move) != CASTLE ) {
reduction = lmr_size[1][depth][mv_tried];
// increase reduction on bad history score
if (mv_hist_score < 0
&& new_depth - reduction > 2
&& lmr_hist_adjustement)
reduction++;
new_depth -= reduction;
}
re_search:
// PVS
if (best == -INF)
score = -Search(p, ply + 1, -beta, -alpha, new_depth, 0, move, last_capt, new_pv);
else {
score = -Search(p, ply + 1, -alpha - 1, -alpha, new_depth, 0, move, last_capt, new_pv);
if (!abort_search && score > alpha && score < beta)
score = -Search(p, ply + 1, -beta, -alpha, new_depth, 0, move, last_capt, new_pv);
}
// Reduced move scored above alpha - we need to re-search it
if (reduction && score > alpha) {
new_depth += reduction;
reduction = 0;
goto re_search;
}
p->UndoMove(move, u);
if (abort_search) return 0;
// Beta cutoff
if (score >= beta) {
if (!fl_check) {
UpdateHistory(p, -1, move, depth, ply);
for (int mv = 0; mv < mv_tried; mv++)
DecreaseHistory(p, mv_played[mv], depth);
}
TransStore(p->hash_key, move, score, LOWER, depth, ply);
// Update search time depending on whether the first move has changed
if (depth > 4) {
if (pv[0] != move) Timer.OnNewRootMove();
else Timer.OnOldRootMove();
}
// Change the best move and show the new pv
BuildPv(pv, new_pv, move);
DisplayPv(score, pv);
return score;
}
// Updating score and alpha
if (score > best) {
best = score;
if (score > alpha) {
alpha = score;
// Update search time depending on whether the first move has changed
if (depth > 4) {
if (pv[0] != move) Timer.OnNewRootMove();
else Timer.OnOldRootMove();
}
// Change the best move and show the new pv
BuildPv(pv, new_pv, move);
DisplayPv(score, pv);
}
}
} // end of the main loop
// Return correct checkmate/stalemate score
if (best == -INF)
return InCheck(p) ? -MATE + ply : DrawScore(p);
// Save score in the transposition table
if (*pv) {
if (!fl_check) {
UpdateHistory(p, -1, *pv, depth, ply);
for (int mv = 0; mv < mv_tried; mv++)
DecreaseHistory(p, mv_played[mv], depth);
}
TransStore(p->hash_key, *pv, best, EXACT, depth, ply);
} else
TransStore(p->hash_key, 0, best, UPPER, depth, ply);
return best;
}
