int QuiesceChecks(POS *p, int ply, int alpha, int beta, int *pv)
{
int stand_pat, best, score, move, new_pv[MAX_PLY];
int is_pv = (beta > alpha + 1);
MOVES m[1];
UNDO u[1];
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);
best = stand_pat = Eval.Return(p, 1);
if (best >= beta) return best;
if (best > alpha) alpha = best;
if (TransRetrieve(p->hash_key, &move, &score, alpha, beta, 0, ply))
return score;
InitCaptures(p, m);
while ((move = NextCaptureOrCheck(m))) {
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;
if (score >= beta) {
TransStore(p->hash_key, move, score, LOWER, 0, ply);
return score;
}
if (score > best) {
best = score;
if (score > alpha) {
alpha = score;
BuildPv(pv, new_pv, move);
}
}
}
if (*pv) TransStore(p->hash_key, *pv, best, EXACT, 0, ply);
else TransStore(p->hash_key, 0, best, UPPER, 0, ply);
return best;
}
void MoveList::prune(Piece::Color enemies, Board *board) {
std::vector<iterator> movesToPrune;
for (iterator moveItr = begin(); moveItr != end(); moveItr++) {
board->executeMove(*moveItr);
// For each move, execute it on the board, and check for any danger to the king.
//if (UnderThreat(board->getKing((Piece::Color)!enemies)->pos, enemies, board))
if (InCheck((Piece::Color)!enemies, board))
movesToPrune.push_back(moveItr);
board->reverseMove(*moveItr);
}
for (std::vector<iterator>::iterator badMoveItr = movesToPrune.begin(); badMoveItr != movesToPrune.end(); badMoveItr++) {
erase(*badMoveItr);
}
}
bool Position::IsGameOver(std::string& message)
{
bool hasMoves = false;
MoveList mvlist;
mvlist.GenAllMoves(*this);
for (int i = 0; i < mvlist.Size(); ++i)
{
if (MakeMove(mvlist[i].m_mv))
{
hasMoves = true;
UnmakeMove();
break;
}
}
if (hasMoves == false)
{
if (InCheck())
message = (m_side == WHITE)? "0-1 {Black mates}" : "1-0 {White mates}";
else
message = "1/2-1/2 {Draw: stalemate}";
return true;
}
if (EstimateDraw(*this) == EVAL_THEORETICAL_DRAW)
{
message = "1/2-1/2 {Draw: material}";
return true;
}
if (GetRepetitions() >= 3)
{
message = "1/2-1/2 {Draw: 3rd repetition}";
return true;
}
return false;
}
static int negascout(struct SearchData *sd,
int alpha,
int beta,
const int depth,
int node_type
#if MP
,int exclusiveP
#endif /* MP */
) {
struct Position *p = sd->position;
struct SearchStatus *st;
int best = -INF;
int bestm = M_NONE;
int tmp;
int talpha;
int incheck;
int lmove;
int move;
int extend = 0;
int threat = FALSE;
int reduce_extensions;
int next_type;
int was_futile = FALSE;
#if FUTILITY
int is_futile;
int optimistic = 0;
#endif
#if MP
int deferred_cnt = 0;
int deferred_list[MAX_DEFERRED];
int deferred_depth[MAX_DEFERRED];
#endif
EnterNode(sd);
Nodes++;
/* check for search termination */
if (sd->master && TerminateSearch(sd)) {
AbortSearch = TRUE;
goto EXIT;
}
/* max search depth reached */
if (sd->ply >= MaxDepth) goto EXIT;
/*
* Check for insufficent material or theoretical draw.
*/
if ( /* InsufMat(p) || CheckDraw(p) || */ Repeated(p, FALSE)) {
best = 0;
goto EXIT;
}
/*
* check extension
*/
incheck = InCheck(p, p->turn);
if (incheck && p->material[p->turn] > 0) {
extend += CheckExtend(p);
ChkExt++;
}
/*
* Check the hashtable
*/
st = sd->current;
HTry++;
#if MP
switch (ProbeHT(p->hkey, &tmp, depth, &(st->st_hashmove), &threat, sd->ply,
exclusiveP, sd->localHashTable))
#else
switch (ProbeHT(p->hkey, &tmp, depth, &(st->st_hashmove), &threat, sd->ply))
#endif /* MP */
{
case ExactScore:
HHit++;
best = tmp;
goto EXIT;
case UpperBound:
if (tmp <= alpha) {
HHit++;
best = tmp;
goto EXIT;
}
break;
case LowerBound:
if (tmp >= beta) {
HHit++;
best = tmp;
goto EXIT;
}
break;
case Useless:
threat = !incheck && MateThreat(p, OPP(p->turn));
break;
#if MP
case OnEvaluation:
best = -ON_EVALUATION;
goto EXIT;
#endif
}
/*
* Probe EGTB
*/
if (depth > EGTBDepth && ProbeEGTB(p, &tmp, sd->ply)) {
best = tmp;
goto EXIT;
}
/*
* Probe recognizers
*/
switch (ProbeRecognizer(p, &tmp)) {
case ExactScore:
best = tmp;
goto EXIT;
case LowerBound:
if (tmp >= beta) {
best = tmp;
goto EXIT;
}
break;
case UpperBound:
if (tmp <= alpha) {
best = tmp;
goto EXIT;
}
break;
}
#if NULLMOVE
/*
* Null move search.
* See Christian Donninger, "Null Move and Deep Search"
* ICCA Journal Volume 16, No. 3, pp. 137-143
*/
if (!incheck && node_type == CutNode && !threat) {
int next_depth;
int nms;
next_depth = depth - ReduceNullMove;
if (next_depth > 0) {
next_depth = depth - ReduceNullMoveDeep;
}
DoNull(p);
if (next_depth < 0) {
nms = -quies(sd, -beta, -beta+1, 0);
} else {
#if MP
nms = -negascout(sd, -beta, -beta+1, next_depth, AllNode, 0);
#else
nms = -negascout(sd, -beta, -beta+1, next_depth, AllNode);
#endif
}
UndoNull(p);
if (AbortSearch) goto EXIT;
if (nms >= beta) {
if (p->nonPawn[p->turn] >= Value[Queen]) {
best = nms;
goto EXIT;
} else {
if (next_depth < 0) {
nms = quies(sd, beta-1, beta, 0);
} else {
#if MP
nms = negascout(sd, beta-1, beta, next_depth, CutNodeNoNull,
0);
#else
nms = negascout(sd, beta-1, beta, next_depth,
CutNodeNoNull);
#endif
}
if (nms >= beta) {
best = nms;
goto EXIT;
} else {
extend += ExtendZugzwang;
ZZExt++;
}
}
} else if (nms <= -CMLIMIT) {
threat = TRUE;
}
}
#endif /* NULLMOVE */
lmove = (p->actLog-1)->gl_Move;
reduce_extensions = (sd->ply > 2*sd->depth);
talpha = alpha;
switch (node_type) {
case AllNode:
next_type = CutNode;
break;
case CutNode:
case CutNodeNoNull:
next_type = AllNode;
break;
default:
next_type = PVNode;
break;
}
#if FUTILITY
is_futile = !incheck && !threat && alpha < CMLIMIT && alpha > -CMLIMIT;
if (is_futile) {
if (p->turn == White) {
optimistic = MaterialBalance(p) + MaxPos;
} else {
optimistic = -MaterialBalance(p) + MaxPos;
}
}
#endif /* FUTILITY */
/*
* Internal iterative deepening. If we do not have a move, we try
* a shallow search to find a good candidate.
*/
if (depth > 2*OnePly && ((alpha + 1) != beta) && !LegalMove(p, st->st_hashmove)) {
int useless;
#if MP
useless = negascout(sd, alpha, beta, depth-2*OnePly, PVNode, 0);
#else
useless = negascout(sd, alpha, beta, depth-2*OnePly, PVNode);
#endif
st->st_hashmove = sd->pv_save[sd->ply+1];
}
/*
* Search all legal moves
*/
while ((move = incheck ? NextEvasion(sd) : NextMove(sd)) != M_NONE) {
int next_depth = extend;
if (move & M_CANY && !MayCastle(p, move)) continue;
/*
* recapture extension
*/
if ((move & M_CAPTURE) && (lmove & M_CAPTURE) &&
M_TO(move) == M_TO(lmove) &&
IsRecapture(p->piece[M_TO(move)], (p->actLog-1)->gl_Piece)) {
RCExt += 1;
next_depth += ExtendRecapture[TYPE(p->piece[M_TO(move)])];
}
/*
* passed pawn push extension
*/
if (TYPE(p->piece[M_FROM(move)]) == Pawn &&
p->nonPawn[OPP(p->turn)] <= Value[Queen]) {
int to = M_TO(move);
if (((p->turn == White && to >= a7)
|| (p->turn == Black && to <= h2))
&& IsPassed(p, to, p->turn) && SwapOff(p, move) >= 0) {
next_depth += ExtendPassedPawn;
PPExt += 1;
}
}
/*
* limit extensions to sensible range.
*/
if (reduce_extensions) next_depth /= 2;
next_depth += depth - OnePly;
#if FUTILITY
/*
* Futility cutoffs
*/
if (is_futile) {
if (next_depth < 0 && !IsCheckingMove(p, move)) {
tmp = optimistic + ScoreMove(p, move);
if (tmp <= alpha) {
if (tmp > best) {
best = tmp;
bestm = move;
was_futile = TRUE;
}
continue;
}
}
#if EXTENDED_FUTILITY
/*
* Extended futility cutoffs and limited razoring.
* See Ernst A. Heinz, "Extended Futility Pruning"
* ICCA Journal Volume 21, No. 2, pp 75-83
*/
else if (next_depth >= 0 && next_depth < OnePly
&& !IsCheckingMove(p, move)) {
tmp = optimistic + ScoreMove(p, move) + (3*Value[Pawn]);
if (tmp <= alpha) {
if (tmp > best) {
best = tmp;
bestm = move;
was_futile = TRUE;
}
continue;
}
}
#if RAZORING
else if (next_depth >= OnePly && next_depth < 2*OnePly
&& !IsCheckingMove(p, move)) {
tmp = optimistic + ScoreMove(p, move) + (6*Value[Pawn]);
if (tmp <= alpha) {
next_depth -= OnePly;
}
}
#endif /* RAZORING */
#endif /* EXTENDED_FUTILITY */
}
#endif /* FUTILITY */
DoMove(p, move);
if (InCheck(p, OPP(p->turn))) {
UndoMove(p, move);
} else {
/*
* Check extension
*/
if (p->material[p->turn] > 0 && InCheck(p, p->turn)) {
next_depth += (reduce_extensions) ?
ExtendInCheck>>1 : ExtendInCheck;
}
/*
* Recursively search this position. If depth is exhausted, use
* quies, otherwise use negascout.
*/
if (next_depth < 0) {
tmp = -quies(sd, -beta, -talpha, 0);
} else if (bestm != M_NONE && !was_futile) {
#if MP
tmp = -negascout(sd, -talpha-1, -talpha, next_depth, next_type,
bestm != M_NONE);
if (tmp != ON_EVALUATION && tmp > talpha && tmp < beta) {
tmp = -negascout(sd, -beta, -tmp, next_depth,
node_type == PVNode ? PVNode : AllNode,
bestm != M_NONE);
}
#else
tmp = -negascout(sd, -talpha-1, -talpha, next_depth, next_type);
if (tmp > talpha && tmp < beta) {
tmp = -negascout(sd, -beta, -tmp, next_depth,
node_type == PVNode ? PVNode : AllNode);
}
#endif /* MP */
} else {
#if MP
tmp = -negascout(sd, -beta, -talpha, next_depth, next_type,
bestm != M_NONE);
#else
tmp = -negascout(sd, -beta, -talpha, next_depth, next_type);
#endif /* MP */
}
UndoMove(p, move);
if (AbortSearch) goto EXIT;
#if MP
if (tmp == ON_EVALUATION) {
/*
* This child is ON_EVALUATION. Remember move and
* depth.
*/
deferred_list[deferred_cnt] = move;
deferred_depth[deferred_cnt] = next_depth;
deferred_cnt++;
} else {
#endif /* MP */
/*
* beta cutoff, enter move in Killer/Countermove table
*/
if (tmp >= beta) {
if (!(move & M_TACTICAL)) {
PutKiller(sd, move);
sd->counterTab[p->turn][lmove & 4095] = move;
}
StoreResult(sd, tmp, alpha, beta, move, depth, threat);
best = tmp;
goto EXIT;
}
/*
* Improvement on best move to date
*/
if (tmp > best) {
best = tmp;
bestm = move;
was_futile = FALSE;
if (best > talpha) {
talpha = best;
}
}
next_type = CutNode;
#if MP
}
#endif /* MP */
}
}
static int quies(struct SearchData *sd, int alpha, int beta, int depth) {
struct Position *p = sd->position;
int best;
int move;
int talpha;
int tmp;
QNodes++;
EnterNode(sd);
/* max search depth reached */
if (sd->ply >= MaxDepth || Repeated(p, FALSE)) {
best = 0;
goto EXIT;
}
/*
* Probe recognizers. If the probe is successful, use the
* recognizer score as evaluation score.
*
* Otherwise, use ScorePosition()
*/
switch (ProbeRecognizer(p, &tmp)) {
case ExactScore:
best = tmp;
goto EXIT;
case LowerBound:
best = tmp;
if (best >= beta) {
goto EXIT;
}
break;
case UpperBound:
best = tmp;
if (best <= alpha) {
goto EXIT;
}
break;
default:
best = ScorePosition(p, alpha, beta);
break;
}
if (best >= beta) {
goto EXIT;
}
talpha = MAX(alpha, best);
while ((move = NextMoveQ(sd, alpha) ) != M_NONE) {
DoMove(p, move);
if (InCheck(p, OPP(p->turn))) UndoMove(p, move);
else {
tmp = -quies(sd, -beta, -talpha, depth-1);
UndoMove(p, move);
if (tmp >= beta) {
best = tmp;
goto EXIT;
}
if (tmp > best) {
best = tmp;
if (best > talpha) {
talpha = best;
}
}
}
}
EXIT:
LeaveNode(sd);
return best;
}
static int AlphaBeta(BOARD *board, unsigned int depth, int alpha, int beta,
int root, CONTROL *control, char skip_null, MOVE killers[][2])
{
int nmoves, nlegal = 0;
MOVE moves[MAXMOVES];
MOVE best_move = 0;
char str_mov[MVLEN];
int val = ERRORVALUE;
char hash_flag = HASH_ALPHA;
int reduce = 0, LMR = 0;
if(depth){
if(root > 0){
val = GetHashEval(&hash_table, board->zobrist_key, depth, alpha, beta);
if(val != ERRORVALUE) return val;
}
if(depth > 2 && !InCheck(board, 0)){
if(!skip_null && board->piece_material[board->white_to_move] != 0){
MOVE null_mv = NULL_MOVE;
MakeMove(board, &null_mv);
val = -AlphaBeta(board, depth-3, -beta, -beta+1, root+1, control, 1, killers);
Takeback(board, null_mv);
if(val >= beta) return beta;
}
reduce = 1; /*Try Late Move reductions.*/
}
nmoves = MoveGen(board, moves, 1);
int good = SortMoves(board, moves, nmoves, killers[root]);
for(int i = 0; i < nmoves; i++){
MakeMove(board, &moves[i]);
control->node_count++;
if(!LeftInCheck(board)){
if(root == 0){
if(!control->best_move) control->best_move = moves[i]; /* Better than nothing. */
if(depth > 6 && !control->ponder){
MoveToAlgeb(moves[i], str_mov);
printf("info depth %i hashfull %i currmove %s currmovenumber %i\n",
depth, hash_table.full/(hash_table.size/1000), str_mov, i+1);
}
}
nlegal++;
val = AssesDraw(board);
if(val) {
if(best_move){
LMR = (reduce && i > good && !CAPTMASK(moves[i]) && !InCheck(board, 0)) ? 1 : 0;
val = -AlphaBeta(board, depth-LMR-1, -alpha-1, -alpha, root+1, control, 0, killers);
if(val > alpha){
val = -AlphaBeta(board, depth-1, -alpha-1, -alpha, root+1, control, 0, killers);
if(val > alpha && val < beta){
val = -AlphaBeta(board, depth-1, -beta, -alpha, root+1, control, 0, killers);
}
}
}else val = -AlphaBeta(board, depth-1, -beta, -alpha, root+1, control, 0, killers);
}
Takeback(board, moves[i]);
if(!control->ponder && control->stop) return alpha;
if(val >= beta){
UpdateTable(&hash_table, board->zobrist_key, val, moves[i], depth, HASH_BETA);
if(CAPTMASK(moves[i]) == 0
&& killers[root][0] != moves[i]
&& killers[root][1] != moves[i]){
killers[root][1] = killers[root][0];
killers[root][0] = moves[i];
}
return beta;
}
if(val > alpha){
alpha = val;
hash_flag = HASH_EXACT;
best_move = moves[i];
if(root == 0) control->best_move = best_move;
}
if(root == 0 && ((clock() - control->init_time) > control->wish_time*CPMS)){
/* if short of time, don't search anymore after current move */
control->stop = 1;
return alpha;
}
}else Takeback(board, moves[i]);
}
if(nlegal == 0){
if(InCheck(board, 0)){
/*UpdateTable(&hash_table, board->zobrist_key, MATE_VALUE+root, 0, depth, HASH_EXACT, hash_table.entries);*/
return MATE_VALUE;
}else{
/*UpdateTable(&hash_table, board->zobrist_key, DRAW_VALUE, 0, depth, HASH_EXACT, hash_table.entries);*/
return DRAW_VALUE; /*Stalemate*/
}
}else UpdateTable(&hash_table, board->zobrist_key, alpha, best_move, depth, hash_flag);
}else if(InCheck(board, 0)){
alpha = AlphaBeta(board, 1, alpha, beta, root+1, control, 1, killers);
}else{
alpha = Quiescent(board, alpha, beta, root, control, killers);
}
return alpha;
}
static int AlphaBeta (BOARD *board, int depth, int alpha, int beta,
int root, CONTROL *control, char skip_null, MOVE killers[][2])
{
int nmoves, good = 0, nlegal = 0;
MOVE moves[MAXMOVES];
MOVE best_move = 0;
char str_mov[MVLEN];
int val = ERRORVALUE;
char hash_flag = HASH_ALPHA;
int in_check = InCheck(board, 0);
if (root > control->seldepth) control->seldepth = root;
if (depth > 0 || in_check) {
if (root > 0) {
val = GetHashEval(&hash_table, board->zobrist_key, depth, alpha, beta);
if (val != ERRORVALUE) return val;
}
if (depth > 2 && !in_check) {
if (!skip_null && board->piece_material[board->white_to_move] != 0) {
MOVE null_mv = NULL_MOVE;
MakeMove(board, &null_mv);
val = -AlphaBeta(board, depth-3, -beta, -beta+1, root+1, control, 1, killers);
Takeback(board, null_mv);
if (val >= beta) return beta;
}
}
nmoves = MoveGen(board, moves, 1);
good = SortMoves(board, moves, nmoves, killers[root]);
} else {
if (!control->ponder && clock() - control->init_time >= control->max_time*CPMS) {
control->stop = 1;
}
val = LazyEval(board);
if (val-LAZYBETA >= beta) return beta;
if (val+LAZYALPHA < alpha) return alpha;
val = StaticEval(board);
UpdateTable(&hash_table, board->zobrist_key, val, 0, 0, HASH_EXACT);
if (val >= beta) return beta;
if (val > alpha) alpha = val;
nmoves = CaptureGen(board, moves);
nmoves = FilterWinning(board, moves, nmoves);
}
for (int i = 0; i < nmoves; i++) {
MakeMove(board, &moves[i]);
control->node_count++;
if (LeftInCheck(board)) {
Takeback(board, moves[i]);
continue;
}
if (root == 0) {
if (!control->best_move) control->best_move = moves[i]; /* Better than nothing. */
if (depth > 6 && !control->ponder) {
MoveToAlgeb(moves[i], str_mov);
printf("info depth %i seldepth %i hashfull %i currmove %s currmovenumber %i\n",
depth, control->seldepth, hash_table.full/(hash_table.size/1000), str_mov, i+1);
}
}
nlegal++;
val = AssessDraw(board, control->contempt);
if (val == ERRORVALUE) {
int ext = 0; //InCheck(board, 0) ? 1 : 0;
if (best_move) {
int LMR = (depth > 2 && !in_check && i > good &&
!CAPTMASK(moves[i]) && !InCheck(board, 0)) ? 1 : 0;
val = -AlphaBeta(board, depth+ext-LMR-1, -alpha-1, -alpha, root+1, control, 0, killers);
if (val > alpha) {
val = -AlphaBeta(board, depth+ext-1, -alpha-1, -alpha, root+1, control, 0, killers);
if (val > alpha && val < beta) {
val = -AlphaBeta(board, depth+ext-1, -beta, -alpha, root+1, control, 0, killers);
}
}
} else {
val = -AlphaBeta(board, depth+ext-1, -beta, -alpha, root+1, control, 0, killers);
}
}
Takeback(board, moves[i]);
if (!control->ponder && control->stop) return alpha;
if (val >= beta) {
UpdateTable(&hash_table, board->zobrist_key, val, moves[i], depth, HASH_BETA);
if (CAPTMASK(moves[i]) == 0 && killers[root][0] != moves[i] && killers[root][1] != moves[i]) {
killers[root][1] = killers[root][0];
killers[root][0] = moves[i];
}
return beta;
}
if (val > alpha) {
alpha = val;
hash_flag = HASH_EXACT;
best_move = moves[i];
if (root == 0) control->best_move = best_move;
}
if (root == 0 && ((clock() - control->init_time) > control->wish_time*CPMS)) {
/* if short of time, don't search anymore after current move */
control->stop = 1;
return alpha;
}
}
if (nlegal == 0) {
if (in_check) {
/*UpdateTable(&hash_table, board->zobrist_key, MATE_VALUE+root, 0, depth, HASH_EXACT, hash_table.entries);*/
return MATE_VALUE;
} else if (depth > 0) {
/*UpdateTable(&hash_table, board->zobrist_key, DRAW_VALUE, 0, depth, HASH_EXACT, hash_table.entries);*/
return DRAW_VALUE; /*Stalemate*/
}
} else {
UpdateTable(&hash_table, board->zobrist_key, alpha, best_move, depth, hash_flag);
}
return alpha;
}
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 QuiesceFlee(POS *p, int ply, int alpha, int beta, int *pv) {
int best, score, move, new_pv[MAX_PLY];
int fl_check, mv_type;
int is_pv = (beta > alpha + 1);
MOVES m[1];
UNDO u[1];
// 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);
// 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, 0, ply))
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);
// Init moves and variables before entering main loop
best = -INF;
InitMoves(p, m, move, -1, ply);
// Main loop
while ((move = NextMove(m, &mv_type))) {
p->DoMove(move, u);
if (Illegal(p)) { p->UndoMove(move, u); continue; }
score = -Quiesce(p, ply, -beta, -alpha, new_pv);
p->UndoMove(move, u);
if (abort_search) return 0;
// Beta cutoff
if (score >= beta) {
TransStore(p->hash_key, move, score, LOWER, 0, 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) TransStore(p->hash_key, *pv, best, EXACT, 0, ply);
else TransStore(p->hash_key, 0, best, UPPER, 0, ply);
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;
}
