const Value FutilityMarginQS = Value(0x80);
// Each move futility margin is decreased
- const Value IncrementalFutilityMargin = Value(0xA);
+ const Value IncrementalFutilityMargin = Value(0x8);
// Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
const Value FutilityMargins[12] = { Value(0x100), Value(0x120), Value(0x200), Value(0x220), Value(0x250), Value(0x270),
Value id_loop(const Position& pos, Move searchMoves[]);
Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta);
Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
- Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID);
+ Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move forbiddenMove = MOVE_NONE);
Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
void sp_search(SplitPoint* sp, int threadID);
void sp_search_pv(SplitPoint* sp, int threadID);
// search() is the search function for zero-width nodes.
Value search(Position& pos, SearchStack ss[], Value beta, Depth depth,
- int ply, bool allowNullmove, int threadID) {
+ int ply, bool allowNullmove, int threadID, Move forbiddenMove) {
assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
assert(ply >= 0 && ply < PLY_MAX);
if (value_mate_in(ply + 1) < beta)
return beta - 1;
+ // Position key calculation
+ Key posKey = pos.get_key();
+
+ if (forbiddenMove != MOVE_NONE)
+ posKey ^= Position::zobExclusion;
+
// Transposition table lookup
- tte = TT.retrieve(pos.get_key());
+ tte = TT.retrieve(posKey);
ttMove = (tte ? tte->move() : MOVE_NONE);
if (tte && ok_to_use_TT(tte, depth, beta, ply))
{
assert(move_is_ok(move));
+ if (move == forbiddenMove)
+ continue;
+
singleReply = (isCheck && mp.number_of_evasions() == 1);
moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
&& move != ttMove)
{
//std::cout << std::endl;
- //for (int d = 2; d <= 14; d+=2)
- // std::cout << d / 2 << ", " << 3+(1 << (3*d/8)) << std::endl;
+ //for (int d = 2; d < 14; d++)
+ // std::cout << d << ", " << 64*(1+bitScanReverse32(d*d)) << std::endl;
+
//std::cout << std::endl;
/*
+ 64*(1+bitScanReverse32(d*d))
+
+ 2 -> 256 - 256
+ 3 -> 288 - 320
+ 4 -> 512 - 384
+ 5 -> 544 - 384
+ 6 -> 592 - 448
+ 7 -> 624 - 448
+ 8 -> 672 - 512
+ 9 -> 704 - 512
+ 10 -> 832 - 512
+ 11 -> 864 - 512
+ 12 -> 928 - 576
+ 13 -> 960 - 576
+
+ 300 + 2*(1 << (3*d/4))
+
+ 2 -> 256 - 304
+ 3 -> 288 - 308
+ 4 -> 512 - 316
+ 5 -> 544 - 316
+ 6 -> 592 - 332
+ 7 -> 624 - 364
+ 8 -> 672 - 428
+ 9 -> 704 - 428
+ 10 -> 832 - 556
+ 11 -> 864 - 812
+ 12 -> 928 - 1324
+ 13 -> 960 - 1324
+
+
3 + (1 << (3*int(depth)/8))
1 * onePly - > moveCount >= 4
{
if (futilityValue == VALUE_NONE)
futilityValue = evaluate(pos, ei, threadID)
- + FutilityMargins[int(depth) - 2]
- + 4*IncrementalFutilityMargin;
+ + 64*(2+bitScanReverse32(int(depth) * int(depth)));
futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
// All legal moves have been searched. A special case: If there were
// no legal moves, it must be mate or stalemate.
if (moveCount == 0)
- return (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
+ return (forbiddenMove == MOVE_NONE ? (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW) : beta - 1);
// If the search is not aborted, update the transposition table,
// history counters, and killer moves.
return bestValue;
if (bestValue < beta)
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
+ TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
else
{
BetaCounter.add(pos.side_to_move(), depth, threadID);
update_history(pos, move, depth, movesSearched, moveCount);
update_killers(move, ss[ply]);
}
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
+ TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
}
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);