/* Display the current board analysis and print it out neatly */
void Analyse(Board B) {
int side = B.side, sc;
double score;
BOOL TB = FALSE;
fprintf(stdout,"Current Position\n----------------\n\n");
fprintf(stdout,"White Points: %d\n",B.WPts);
fprintf(stdout,"Black Points: %d\n",B.BPts);
if (B.WPts==B.BPts) fprintf(stdout,"(Even Sides");
if (B.WPts<B.BPts) {
fprintf(stdout,"(Black is Ahead by %d Pt",B.BPts-B.WPts);
if (B.BPts-B.WPts>1) fprintf(stdout,"s");
}
if (B.WPts>B.BPts) {
fprintf(stdout,"(White is Ahead by %d Pt",B.WPts-B.BPts);
if (B.WPts-B.BPts>1) fprintf(stdout,"s");
}
fprintf(stdout,")\n");
/* Probe the Endgame Tablebases (if any exist) and if this fails then
* eval() the position */
if (TBON && ProbeEGTB(&B,&sc,0)) {
TB = TRUE;
}
else sc = Eval(&B,-INFINITY,INFINITY);
score = ((double)sc)/100.0;
fprintf(stdout,"\nStatic Analysis Score\n");
if (sc==0) fprintf(stdout,"Exactly Even Sides");
if (sc>0) {
if (side==WHITE) fprintf(stdout,"White is Ahead by %.2f Pawns",score);
else fprintf(stdout,"Black is Ahead by %.2f Pawns",score);
}
if (sc<0) {
if (side==WHITE) fprintf(stdout,"Black is Ahead by %.2f Pawns",-score);
else fprintf(stdout,"White is Ahead by %.2f Pawns",-score);
}
if (TB) fprintf(stdout," <TB>");
fprintf(stdout,"\n\n");
}
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 */
}
}
