kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Rename OnePly in ONE_PLY

Browse source 
Use enum values standard naming policy also for this one.

No fuctional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-08-18 14:23:19 +01:00
parent cfb52fcd5d
commit 4aeffc8c9a
7 changed files with 70 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/benchmark.cpp
View file

@ -155,7 +155,7 @@ void benchmark(const string& commandLine) {
cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl; cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
if (limitType == "perft") if (limitType == "perft")
{ {
int64_t perftCnt = perft(pos, maxDepth * OnePly); int64_t perftCnt = perft(pos, maxDepth * ONE_PLY);
cerr << "\nPerft " << maxDepth << " result (nodes searched): " << perftCnt << endl << endl; cerr << "\nPerft " << maxDepth << " result (nodes searched): " << perftCnt << endl << endl;
totalNodes += perftCnt; totalNodes += perftCnt;
} else { } else {

4
src/depth.h
View file

@ -27,8 +27,8 @@
enum Depth { enum Depth {
OnePly = 2, ONE_PLY = 2,
DEPTH_NONE = -127 * OnePly DEPTH_NONE = -127 * ONE_PLY
}; };

2
src/history.h
View file

@ -71,7 +71,7 @@ private:
/// recently have a bigger importance for move ordering than the moves which /// recently have a bigger importance for move ordering than the moves which
/// have been searched a long time ago. /// have been searched a long time ago.
const int HistoryMax = 50000 * OnePly; const int HistoryMax = 50000 * ONE_PLY;
//// ////

2
src/movepick.cpp
View file

@ -94,7 +94,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
{ {
// Consider sligtly negative captures as good if at low // Consider sligtly negative captures as good if at low
// depth and far from beta. // depth and far from beta.
if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * OnePly) if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
badCaptureThreshold = -PawnValueMidgame; badCaptureThreshold = -PawnValueMidgame;
phasePtr = MainSearchPhaseTable; phasePtr = MainSearchPhaseTable;

4
src/san.cpp
View file

@ -138,7 +138,7 @@ Move move_from_san(const Position& pos, const string& movestr) {
assert(pos.is_ok()); assert(pos.is_ok());
MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H); MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
// Castling moves // Castling moves
@ -368,7 +368,7 @@ namespace {
if (type_of_piece(pc) == KING) if (type_of_piece(pc) == KING)
return AMBIGUITY_NONE; return AMBIGUITY_NONE;
MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H); MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
Move mv, moveList[8]; Move mv, moveList[8];

110
src/search.cpp
View file

@ -168,7 +168,7 @@ namespace {
// Step 6. Razoring // Step 6. Razoring
// Maximum depth for razoring // Maximum depth for razoring
const Depth RazorDepth = 4 * OnePly; const Depth RazorDepth = 4 * ONE_PLY;
// Dynamic razoring margin based on depth // Dynamic razoring margin based on depth
inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); } inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
@ -180,12 +180,12 @@ namespace {
const Value NullMoveMargin = Value(0x200); const Value NullMoveMargin = Value(0x200);
// Maximum depth for use of dynamic threat detection when null move fails low // Maximum depth for use of dynamic threat detection when null move fails low
const Depth ThreatDepth = 5 * OnePly; const Depth ThreatDepth = 5 * ONE_PLY;
// Step 9. Internal iterative deepening // Step 9. Internal iterative deepening
// Minimum depth for use of internal iterative deepening // Minimum depth for use of internal iterative deepening
const Depth IIDDepth[2] = { 8 * OnePly /* non-PV */, 5 * OnePly /* PV */}; const Depth IIDDepth[2] = { 8 * ONE_PLY /* non-PV */, 5 * ONE_PLY /* PV */};
// At Non-PV nodes we do an internal iterative deepening search // At Non-PV nodes we do an internal iterative deepening search
// when the static evaluation is bigger then beta - IIDMargin. // when the static evaluation is bigger then beta - IIDMargin.
@ -199,7 +199,7 @@ namespace {
Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2]; Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2];
// Minimum depth for use of singular extension // Minimum depth for use of singular extension
const Depth SingularExtensionDepth[2] = { 8 * OnePly /* non-PV */, 6 * OnePly /* PV */}; const Depth SingularExtensionDepth[2] = { 8 * ONE_PLY /* non-PV */, 6 * ONE_PLY /* PV */};
// If the TT move is at least SingularExtensionMargin better then the // If the TT move is at least SingularExtensionMargin better then the
// remaining ones we will extend it. // remaining ones we will extend it.
@ -214,8 +214,8 @@ namespace {
int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber] int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
int FutilityMoveCountArray[32]; // [depth] int FutilityMoveCountArray[32]; // [depth]
inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * OnePly ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); } inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); }
inline int futility_move_count(Depth d) { return d < 16 * OnePly ? FutilityMoveCountArray[d] : 512; } inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; }
// Step 14. Reduced search // Step 14. Reduced search
@ -228,7 +228,7 @@ namespace {
// Common adjustments // Common adjustments
// Search depth at iteration 1 // Search depth at iteration 1
const Depth InitialDepth = OnePly; const Depth InitialDepth = ONE_PLY;
// Easy move margin. An easy move candidate must be at least this much // Easy move margin. An easy move candidate must be at least this much
// better than the second best move. // better than the second best move.
@ -338,8 +338,8 @@ int64_t nodes_searched() { return ThreadsMgr.nodes_searched(); }
void init_search() { void init_search() {
int d; // depth (OnePly == 2) int d; // depth (ONE_PLY == 2)
int hd; // half depth (OnePly == 1) int hd; // half depth (ONE_PLY == 1)
int mc; // moveCount int mc; // moveCount
// Init reductions array // Init reductions array
@ -347,8 +347,8 @@ void init_search() {
{ {
double pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5; double pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5;
double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25; double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25;
ReductionMatrix[PV][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(OnePly)) : 0); ReductionMatrix[PV][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0);
ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(OnePly)) : 0); ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
} }
// Init futility margins array // Init futility margins array
@ -376,7 +376,7 @@ int perft(Position& pos, Depth depth)
// If we are at the last ply we don't need to do and undo // If we are at the last ply we don't need to do and undo
// the moves, just to count them. // the moves, just to count them.
if (depth <= OnePly) if (depth <= ONE_PLY)
return int(last - mlist); return int(last - mlist);
// Loop through all legal moves // Loop through all legal moves
@ -385,7 +385,7 @@ int perft(Position& pos, Depth depth)
{ {
m = cur->move; m = cur->move;
pos.do_move(m, st, ci, pos.move_is_check(m, ci)); pos.do_move(m, st, ci, pos.move_is_check(m, ci));
sum += perft(pos, depth - OnePly); sum += perft(pos, depth - ONE_PLY);
pos.undo_move(m); pos.undo_move(m);
} }
return sum; return sum;
@ -447,7 +447,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
MateThreatExtension[1] = Depth(get_option_value_int("Mate Threat Extension (PV nodes)")); MateThreatExtension[1] = Depth(get_option_value_int("Mate Threat Extension (PV nodes)"));
MateThreatExtension[0] = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)")); MateThreatExtension[0] = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)"));
MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * OnePly; MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * ONE_PLY;
MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point"); MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
MultiPV = get_option_value_int("MultiPV"); MultiPV = get_option_value_int("MultiPV");
Chess960 = get_option_value_bool("UCI_Chess960"); Chess960 = get_option_value_bool("UCI_Chess960");
@ -715,7 +715,7 @@ namespace {
alpha = *alphaPtr; alpha = *alphaPtr;
beta = *betaPtr; beta = *betaPtr;
isCheck = pos.is_check(); isCheck = pos.is_check();
depth = (Iteration - 2) * OnePly + InitialDepth; depth = (Iteration - 2) * ONE_PLY + InitialDepth;
// Step 1. Initialize node (polling is omitted at root) // Step 1. Initialize node (polling is omitted at root)
ss->currentMove = ss->bestMove = MOVE_NONE; ss->currentMove = ss->bestMove = MOVE_NONE;
@ -798,7 +798,7 @@ namespace {
// if the move fails high will be re-searched at full depth // if the move fails high will be re-searched at full depth
bool doFullDepthSearch = true; bool doFullDepthSearch = true;
if ( depth >= 3 * OnePly if ( depth >= 3 * ONE_PLY
&& !dangerous && !dangerous
&& !captureOrPromotion && !captureOrPromotion
&& !move_is_castle(move)) && !move_is_castle(move))
@ -806,7 +806,7 @@ namespace {
ss->reduction = reduction<PV>(depth, i - MultiPV + 2); ss->reduction = reduction<PV>(depth, i - MultiPV + 2);
if (ss->reduction) if (ss->reduction)
{ {
assert(newDepth-ss->reduction >= OnePly); assert(newDepth-ss->reduction >= ONE_PLY);
// Reduced depth non-pv search using alpha as upperbound // Reduced depth non-pv search using alpha as upperbound
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
@ -816,11 +816,11 @@ namespace {
// The move failed high, but if reduction is very big we could // The move failed high, but if reduction is very big we could
// face a false positive, retry with a less aggressive reduction, // face a false positive, retry with a less aggressive reduction,
// if the move fails high again then go with full depth search. // if the move fails high again then go with full depth search.
if (doFullDepthSearch && ss->reduction > 2 * OnePly) if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
{ {
assert(newDepth - OnePly >= OnePly); assert(newDepth - ONE_PLY >= ONE_PLY);
ss->reduction = OnePly; ss->reduction = ONE_PLY;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1); value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
doFullDepthSearch = (value > alpha); doFullDepthSearch = (value > alpha);
} }
@ -1092,16 +1092,16 @@ namespace {
// NullMoveMargin under beta. // NullMoveMargin under beta.
if ( !PvNode if ( !PvNode
&& !ss->skipNullMove && !ss->skipNullMove
&& depth > OnePly && depth > ONE_PLY
&& !isCheck && !isCheck
&& refinedValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0) && refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0)
&& !value_is_mate(beta) && !value_is_mate(beta)
&& pos.non_pawn_material(pos.side_to_move())) && pos.non_pawn_material(pos.side_to_move()))
{ {
ss->currentMove = MOVE_NULL; ss->currentMove = MOVE_NULL;
// Null move dynamic reduction based on depth // Null move dynamic reduction based on depth
int R = 3 + (depth >= 5 * OnePly ? depth / 8 : 0); int R = 3 + (depth >= 5 * ONE_PLY ? depth / 8 : 0);
// Null move dynamic reduction based on value // Null move dynamic reduction based on value
if (refinedValue - beta > PawnValueMidgame) if (refinedValue - beta > PawnValueMidgame)
@ -1110,8 +1110,8 @@ namespace {
pos.do_null_move(st); pos.do_null_move(st);
(ss+1)->skipNullMove = true; (ss+1)->skipNullMove = true;
nullValue = depth-R*OnePly < OnePly ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1) nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
: - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*OnePly, ply+1); : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1);
(ss+1)->skipNullMove = false; (ss+1)->skipNullMove = false;
pos.undo_null_move(); pos.undo_null_move();
@ -1121,12 +1121,12 @@ namespace {
if (nullValue >= value_mate_in(PLY_MAX)) if (nullValue >= value_mate_in(PLY_MAX))
nullValue = beta; nullValue = beta;
if (depth < 6 * OnePly) if (depth < 6 * ONE_PLY)
return nullValue; return nullValue;
// Do verification search at high depths // Do verification search at high depths
ss->skipNullMove = true; ss->skipNullMove = true;
Value v = search<NonPV>(pos, ss, alpha, beta, depth-R*OnePly, ply); Value v = search<NonPV>(pos, ss, alpha, beta, depth-R*ONE_PLY, ply);
ss->skipNullMove = false; ss->skipNullMove = false;
if (v >= beta) if (v >= beta)
@ -1156,7 +1156,7 @@ namespace {
&& ttMove == MOVE_NONE && ttMove == MOVE_NONE
&& (PvNode || (!isCheck && ss->eval >= beta - IIDMargin))) && (PvNode || (!isCheck && ss->eval >= beta - IIDMargin)))
{ {
Depth d = (PvNode ? depth - 2 * OnePly : depth / 2); Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
ss->skipNullMove = true; ss->skipNullMove = true;
search<PvNode>(pos, ss, alpha, beta, d, ply); search<PvNode>(pos, ss, alpha, beta, d, ply);
@ -1180,7 +1180,7 @@ namespace {
&& tte->move() && tte->move()
&& !excludedMove // Do not allow recursive singular extension search && !excludedMove // Do not allow recursive singular extension search
&& is_lower_bound(tte->type()) && is_lower_bound(tte->type())
&& tte->depth() >= depth - 3 * OnePly; && tte->depth() >= depth - 3 * ONE_PLY;
// Step 10. Loop through moves // Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs // Loop through all legal moves until no moves remain or a beta cutoff occurs
@ -1205,7 +1205,7 @@ namespace {
// lower then ttValue minus a margin then we extend ttMove. // lower then ttValue minus a margin then we extend ttMove.
if ( singularExtensionNode if ( singularExtensionNode
&& move == tte->move() && move == tte->move()
&& ext < OnePly) && ext < ONE_PLY)
{ {
Value ttValue = value_from_tt(tte->value(), ply); Value ttValue = value_from_tt(tte->value(), ply);
@ -1219,11 +1219,11 @@ namespace {
ss->excludedMove = MOVE_NONE; ss->excludedMove = MOVE_NONE;
ss->bestMove = MOVE_NONE; ss->bestMove = MOVE_NONE;
if (v < b) if (v < b)
ext = OnePly; ext = ONE_PLY;
} }
} }
newDepth = depth - OnePly + ext; newDepth = depth - ONE_PLY + ext;
// Update current move (this must be done after singular extension search) // Update current move (this must be done after singular extension search)
movesSearched[moveCount++] = ss->currentMove = move; movesSearched[moveCount++] = ss->currentMove = move;
@ -1243,7 +1243,7 @@ namespace {
continue; continue;
// Value based pruning // Value based pruning
// We illogically ignore reduction condition depth >= 3*OnePly for predicted depth, // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker. // but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount); Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
@ -1263,7 +1263,7 @@ namespace {
// Step extra. pv search (only in PV nodes) // Step extra. pv search (only in PV nodes)
// The first move in list is the expected PV // The first move in list is the expected PV
if (PvNode && moveCount == 1) if (PvNode && moveCount == 1)
value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1) value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
: - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1); : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
else else
{ {
@ -1271,7 +1271,7 @@ namespace {
// If the move fails high will be re-searched at full depth. // If the move fails high will be re-searched at full depth.
bool doFullDepthSearch = true; bool doFullDepthSearch = true;
if ( depth >= 3 * OnePly if ( depth >= 3 * ONE_PLY
&& !captureOrPromotion && !captureOrPromotion
&& !dangerous && !dangerous
&& !move_is_castle(move) && !move_is_castle(move)
@ -1281,7 +1281,7 @@ namespace {
if (ss->reduction) if (ss->reduction)
{ {
Depth d = newDepth - ss->reduction; Depth d = newDepth - ss->reduction;
value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1); : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
doFullDepthSearch = (value > alpha); doFullDepthSearch = (value > alpha);
@ -1290,11 +1290,11 @@ namespace {
// The move failed high, but if reduction is very big we could // The move failed high, but if reduction is very big we could
// face a false positive, retry with a less aggressive reduction, // face a false positive, retry with a less aggressive reduction,
// if the move fails high again then go with full depth search. // if the move fails high again then go with full depth search.
if (doFullDepthSearch && ss->reduction > 2 * OnePly) if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
{ {
assert(newDepth - OnePly >= OnePly); assert(newDepth - ONE_PLY >= ONE_PLY);
ss->reduction = OnePly; ss->reduction = ONE_PLY;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
doFullDepthSearch = (value > alpha); doFullDepthSearch = (value > alpha);
} }
@ -1304,14 +1304,14 @@ namespace {
// Step 15. Full depth search // Step 15. Full depth search
if (doFullDepthSearch) if (doFullDepthSearch)
{ {
value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1) value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
// Step extra. pv search (only in PV nodes) // Step extra. pv search (only in PV nodes)
// Search only for possible new PV nodes, if instead value >= beta then // Search only for possible new PV nodes, if instead value >= beta then
// parent node fails low with value <= alpha and tries another move. // parent node fails low with value <= alpha and tries another move.
if (PvNode && value > alpha && value < beta) if (PvNode && value > alpha && value < beta)
value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1) value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), ply+1)
: - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1); : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
} }
} }
@ -1385,7 +1385,7 @@ namespace {
// qsearch() is the quiescence search function, which is called by the main // qsearch() is the quiescence search function, which is called by the main
// search function when the remaining depth is zero (or, to be more precise, // search function when the remaining depth is zero (or, to be more precise,
// less than OnePly). // less than ONE_PLY).
template <NodeType PvNode> template <NodeType PvNode>
Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
@ -1460,7 +1460,7 @@ namespace {
alpha = bestValue; alpha = bestValue;
// If we are near beta then try to get a cutoff pushing checks a bit further // If we are near beta then try to get a cutoff pushing checks a bit further
deepChecks = (depth == -OnePly && bestValue >= beta - PawnValueMidgame / 8); deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
// Futility pruning parameters, not needed when in check // Futility pruning parameters, not needed when in check
futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()]; futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()];
@ -1469,7 +1469,7 @@ namespace {
// Initialize a MovePicker object for the current position, and prepare // Initialize a MovePicker object for the current position, and prepare
// to search the moves. Because the depth is <= 0 here, only captures, // to search the moves. Because the depth is <= 0 here, only captures,
// queen promotions and checks (only if depth == 0 or depth == -OnePly // queen promotions and checks (only if depth == 0 or depth == -ONE_PLY
// and we are near beta) will be generated. // and we are near beta) will be generated.
MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H); MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H);
CheckInfo ci(pos); CheckInfo ci(pos);
@ -1523,7 +1523,7 @@ namespace {
// Make and search the move // Make and search the move
pos.do_move(move, st, ci, moveIsCheck); pos.do_move(move, st, ci, moveIsCheck);
value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-OnePly, ply+1); value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-ONE_PLY, ply+1);
pos.undo_move(move); pos.undo_move(move);
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
@ -1607,7 +1607,7 @@ namespace {
// Step 11. Decide the new search depth // Step 11. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
newDepth = sp->depth - OnePly + ext; newDepth = sp->depth - ONE_PLY + ext;
// Update current move // Update current move
ss->currentMove = move; ss->currentMove = move;
@ -1660,7 +1660,7 @@ namespace {
{ {
Value localAlpha = sp->alpha; Value localAlpha = sp->alpha;
Depth d = newDepth - ss->reduction; Depth d = newDepth - ss->reduction;
value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1)
: - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1); : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1);
doFullDepthSearch = (value > localAlpha); doFullDepthSearch = (value > localAlpha);
@ -1669,11 +1669,11 @@ namespace {
// The move failed high, but if reduction is very big we could // The move failed high, but if reduction is very big we could
// face a false positive, retry with a less aggressive reduction, // face a false positive, retry with a less aggressive reduction,
// if the move fails high again then go with full depth search. // if the move fails high again then go with full depth search.
if (doFullDepthSearch && ss->reduction > 2 * OnePly) if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
{ {
assert(newDepth - OnePly >= OnePly); assert(newDepth - ONE_PLY >= ONE_PLY);
ss->reduction = OnePly; ss->reduction = ONE_PLY;
Value localAlpha = sp->alpha; Value localAlpha = sp->alpha;
value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1); value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1);
doFullDepthSearch = (value > localAlpha); doFullDepthSearch = (value > localAlpha);
@ -1685,14 +1685,14 @@ namespace {
if (doFullDepthSearch) if (doFullDepthSearch)
{ {
Value localAlpha = sp->alpha; Value localAlpha = sp->alpha;
value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1) value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), sp->ply+1)
: - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1); : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1);
// Step extra. pv search (only in PV nodes) // Step extra. pv search (only in PV nodes)
// Search only for possible new PV nodes, if instead value >= beta then // Search only for possible new PV nodes, if instead value >= beta then
// parent node fails low with value <= alpha and tries another move. // parent node fails low with value <= alpha and tries another move.
if (PvNode && value > localAlpha && value < sp->beta) if (PvNode && value > localAlpha && value < sp->beta)
value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), sp->ply+1) value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), sp->ply+1)
: - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1); : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1);
} }
@ -1897,11 +1897,11 @@ namespace {
&& pos.type_of_piece_on(move_to(m)) != PAWN && pos.type_of_piece_on(move_to(m)) != PAWN
&& pos.see_sign(m) >= 0) && pos.see_sign(m) >= 0)
{ {
result += OnePly / 2; result += ONE_PLY / 2;
*dangerous = true; *dangerous = true;
} }
return Min(result, OnePly); return Min(result, ONE_PLY);
} }
@ -2043,7 +2043,7 @@ namespace {
std::stringstream s; std::stringstream s;
if (abs(v) < VALUE_MATE - PLY_MAX * OnePly) if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to pawn = 100 s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to pawn = 100
else else
s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 ); s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 );

2
src/uci.cpp
View file

@ -316,7 +316,7 @@ namespace {
tm = get_system_time(); tm = get_system_time();
n = perft(pos, depth * OnePly); n = perft(pos, depth * ONE_PLY);
tm = get_system_time() - tm; tm = get_system_time() - tm;
std::cout << "\nNodes " << n std::cout << "\nNodes " << n