// Evaluation weights, indexed by evaluation term
enum { Mobility, PawnStructure, PassedPawns, Space, KingSafety };
const struct Weight { int mg, eg; } Weights[] = {
- {289, 344}, {233, 201}, {221, 273}, {46, 0}, {321, 0}
+ {289, 344}, {233, 201}, {221, 273}, {46, 0}, {324, 0}
};
#define V(v) Value(v)
// index to KingDanger[].
//
// KingAttackWeights[PieceType] contains king attack weights by piece type
- const int KingAttackWeights[] = { 0, 0, 6, 2, 5, 5 };
+ const int KingAttackWeights[] = { 0, 0, 8, 4, 4, 1 };
// Bonuses for enemy's safe checks
- const int QueenContactCheck = 92;
- const int RookContactCheck = 68;
- const int QueenCheck = 50;
- const int RookCheck = 36;
- const int BishopCheck = 7;
- const int KnightCheck = 14;
+ const int QueenContactCheck = 89;
+ const int RookContactCheck = 72;
+ const int QueenCheck = 51;
+ const int RookCheck = 38;
+ const int BishopCheck = 5;
+ const int KnightCheck = 16;
// KingDanger[attackUnits] contains the actual king danger weighted
// scores, indexed by a calculated integer number.
// number and types of the enemy's attacking pieces, the number of
// attacked and undefended squares around our king and the quality of
// the pawn shelter (current 'score' value).
- attackUnits = std::min(77, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
- + 10 * ei.kingAdjacentZoneAttacksCount[Them]
- + 19 * popcount<Max15>(undefended)
- + 9 * (ei.pinnedPieces[Us] != 0)
- - mg_value(score) * 63 / 512
+ attackUnits = std::min(74, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])
+ + 9 * ei.kingAdjacentZoneAttacksCount[Them]
+ + 25 * popcount<Max15>(undefended)
+ + 10 * (ei.pinnedPieces[Us] != 0)
+ - mg_value(score) / 8
- !pos.count<QUEEN>(Them) * 60;
// Analyse the enemy's safe queen contact checks. Firstly, find the
void init() {
- const double MaxSlope = 7.5;
+ const double MaxSlope = 8.5;
const double Peak = 1280;
double t = 0.0;
for (int i = 1; i < 400; ++i)
{
- t = std::min(Peak, std::min(0.025 * i * i, t + MaxSlope));
+ t = std::min(Peak, std::min(0.027 * i * i, t + MaxSlope));
KingDanger[i] = apply_weight(make_score(int(t), 0), Weights[KingSafety]);
}
}
// Weakness of our pawn shelter in front of the king by [distance from edge][rank]
const Value ShelterWeakness[][RANK_NB] = {
- { V(100), V(13), V(24), V(64), V(89), V( 93), V(104) },
- { V(110), V( 1), V(29), V(75), V(96), V(102), V(107) },
- { V(102), V( 0), V(39), V(74), V(88), V(101), V( 98) },
- { V( 88), V( 4), V(33), V(67), V(92), V( 94), V(107) } };
+ { V( 99), V(23), V(24), V(54), V(85), V( 93), V(107) },
+ { V(119), V( 2), V(28), V(72), V(96), V(104), V(114) },
+ { V(103), V( 6), V(47), V(74), V(84), V(103), V( 94) },
+ { V( 78), V(10), V(41), V(64), V(88), V( 92), V(115) } };
// Danger of enemy pawns moving toward our king by [type][distance from edge][rank]
const Value StormDanger[][4][RANK_NB] = {
- { { V( 0), V( 63), V( 128), V(43), V(27) },
- { V( 0), V( 62), V( 131), V(44), V(26) },
- { V( 0), V( 59), V( 121), V(50), V(28) },
- { V( 0), V( 62), V( 127), V(54), V(28) } },
- { { V(24), V( 40), V( 93), V(42), V(22) },
- { V(24), V( 28), V( 101), V(38), V(20) },
- { V(24), V( 32), V( 95), V(36), V(23) },
- { V(27), V( 24), V( 99), V(36), V(24) } },
- { { V( 0), V( 0), V( 81), V(16), V( 6) },
- { V( 0), V( 0), V( 165), V(29), V( 9) },
- { V( 0), V( 0), V( 163), V(23), V(12) },
- { V( 0), V( 0), V( 161), V(28), V(13) } },
- { { V( 0), V(-296), V(-299), V(55), V(25) },
- { V( 0), V( 67), V( 131), V(46), V(21) },
- { V( 0), V( 65), V( 135), V(50), V(31) },
- { V( 0), V( 62), V( 128), V(51), V(24) } } };
+ { { V( 0), V( 65), V( 125), V(37), V(30) },
+ { V( 0), V( 57), V( 136), V(39), V(24) },
+ { V( 0), V( 50), V( 114), V(45), V(29) },
+ { V( 0), V( 58), V( 129), V(56), V(34) } },
+ { { V(20), V( 45), V( 91), V(47), V(20) },
+ { V(25), V( 23), V( 105), V(38), V(14) },
+ { V(21), V( 37), V( 99), V(35), V(21) },
+ { V(30), V( 18), V( 105), V(38), V(28) } },
+ { { V( 0), V( 0), V( 81), V(13), V( 4) },
+ { V( 0), V( 0), V( 169), V(30), V( 4) },
+ { V( 0), V( 0), V( 166), V(24), V( 6) },
+ { V( 0), V( 0), V( 164), V(24), V(11) } },
+ { { V( 0), V(-289), V(-297), V(57), V(29) },
+ { V( 0), V( 66), V( 136), V(43), V(16) },
+ { V( 0), V( 66), V( 141), V(50), V(31) },
+ { V( 0), V( 63), V( 126), V(52), V(23) } } };
// Max bonus for king safety. Corresponds to start position with all the pawns
// in front of the king and no enemy pawn on the horizon.
- const Value MaxSafetyBonus = V(257);
+ const Value MaxSafetyBonus = V(252);
#undef S
#undef V
lever = theirPawns & pawnAttacksBB[s];
// Test for backward pawn.
- // If the pawn is passed, isolated, or connected it cannot be
+ // If the pawn is passed, isolated, connected or a lever it cannot be
// backward. If there are friendly pawns behind on adjacent files
- // or if it can capture an enemy pawn it cannot be backward either.
- if ( (passed | isolated | connected)
- || (ourPawns & pawn_attack_span(Them, s))
- || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
+ // it cannot be backward either.
+ if ( (passed | isolated | connected | lever)
+ || (ourPawns & pawn_attack_span(Them, s)))
backward = false;
else
{
sync_cout << "bestmove " << UCI::move(RootMoves[0].pv[0], RootPos.is_chess960());
- if (RootMoves[0].pv.size() > 1)
+ if (RootMoves[0].pv.size() > 1 || RootMoves[0].extract_ponder_from_tt(RootPos))
std::cout << " ponder " << UCI::move(RootMoves[0].pv[1], RootPos.is_chess960());
std::cout << sync_endl;
// When failing high/low give some update (without cluttering
// the UI) before a re-search.
- if ( (bestValue <= alpha || bestValue >= beta)
+ if ( multiPV == 1
+ && (bestValue <= alpha || bestValue >= beta)
&& Time::now() - SearchTime > 3000)
sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
newDepth = depth - ONE_PLY + extension;
// Step 13. Pruning at shallow depth
- if ( !captureOrPromotion
+ if ( !RootNode
+ && !captureOrPromotion
&& !inCheck
&& !dangerous
&& bestValue > VALUE_MATED_IN_MAX_PLY)
{
int score = RootMoves[i].score;
- // Don't allow crazy blunders even at very low skills
- if (i > 0 && RootMoves[i - 1].score > score + 2 * PawnValueMg)
- break;
-
// This is our magic formula
score += ( weakness * int(RootMoves[0].score - score)
+ variance * (rng.rand<unsigned>() % weakness)) / 128;
}
+/// RootMove::extract_ponder_from_tt() is called in case we have no ponder move before
+/// exiting the search, for instance in case we stop the search during a fail high at
+/// root. We try hard to have a ponder move to return to the GUI, otherwise in case of
+/// 'ponder on' we have nothing to think on.
+
+Move RootMove::extract_ponder_from_tt(Position& pos)
+{
+ StateInfo st;
+ bool found;
+
+ assert(pv.size() == 1);
+
+ pos.do_move(pv[0], st);
+ TTEntry* tte = TT.probe(pos.key(), found);
+ Move m = found ? tte->move() : MOVE_NONE;
+ if (!MoveList<LEGAL>(pos).contains(m))
+ m = MOVE_NONE;
+
+ pos.undo_move(pv[0]);
+ pv.push_back(m);
+ return m;
+}
+
+
/// Thread::idle_loop() is where the thread is parked when it has no work to do
void Thread::idle_loop() {