// attackedBy[color][piece type] is a bitboard representing all squares

// attacked by a given color and piece type (can be also ALL_PIECES).

Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];

// kingRing[color] is the zone around the king which is considered

// by the king safety evaluation. This consists of the squares directly

// adjacent to the king, and the three (or two, for a king on an edge file)

// squares two ranks in front of the king. For instance, if black's king

// is on g8, kingRing[BLACK] is a bitboard containing the squares f8, h8,

// f7, g7, h7, f6, g6 and h6.

Bitboard kingRing[COLOR_NB];

// kingAttackersCount[color] is the number of pieces of the given color

// which attack a square in the kingRing of the enemy king.

int kingAttackersCount[COLOR_NB];

// kingAttackersWeight[color] is the sum of the "weight" of the pieces of the

// given color which attack a square in the kingRing of the enemy king. The

// weights of the individual piece types are given by the elements in the

// KingAttackWeights array.

int kingAttackersWeight[COLOR_NB];

// kingAdjacentZoneAttacksCount[color] is the number of attacks by the given

// color to squares directly adjacent to the enemy king. Pieces which attack

// more than one square are counted multiple times. For instance, if there is

// a white knight on g5 and black's king is on g8, this white knight adds 2

// to kingAdjacentZoneAttacksCount[WHITE].

int kingAdjacentZoneAttacksCount[COLOR_NB];

Bitboard pinnedPieces[COLOR_NB];

Pawns::Entry* pi;

const Color Them = (Us == WHITE ? BLACK : WHITE);

const Square Down = (Us == WHITE ? DELTA_S : DELTA_N);

ei.pinnedPieces[Us] = pos.pinned_pieces(Us);

Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.square<KING>(Them));

ei.attackedBy[Them][ALL_PIECES] |= b;

ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);

// Init king safety tables only if we are going to use them

if (pos.non_pawn_material(Us) >= QueenValueMg)

{

ei.kingRing[Them] = b | shift_bb<Down>(b);

b &= ei.attackedBy[Us][PAWN];

ei.kingAttackersCount[Us] = b ? popcount<Max15>(b) : 0;

ei.kingAdjacentZoneAttacksCount[Us] = ei.kingAttackersWeight[Us] = 0;

}

else

ei.kingRing[Them] = ei.kingAttackersCount[Us] = 0;

Bitboard b;

Square s;

Score score = SCORE_ZERO;

const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1));

const Color Them = (Us == WHITE ? BLACK : WHITE);

const Square* pl = pos.squares<Pt>(Us);

ei.attackedBy[Us][Pt] = 0;

while ((s = *pl++) != SQ_NONE)

{

// Find attacked squares, including x-ray attacks for bishops and rooks

b = Pt == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))

: Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))

: pos.attacks_from<Pt>(s);

if (ei.pinnedPieces[Us] & s)

b &= LineBB[pos.square<KING>(Us)][s];

ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b;

if (b & ei.kingRing[Them])

{

ei.kingAttackersCount[Us]++;

ei.kingAttackersWeight[Us] += KingAttackWeights[Pt];

Bitboard bb = b & ei.attackedBy[Them][KING];

if (bb)

ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);

}

if (Pt == QUEEN)

b &= ~( ei.attackedBy[Them][KNIGHT]

| ei.attackedBy[Them][BISHOP]

| ei.attackedBy[Them][ROOK]);

int mob = popcount<Pt == QUEEN ? Full : Max15>(b & mobilityArea[Us]);

mobility[Us] += MobilityBonus[Pt][mob];

if (Pt == BISHOP || Pt == KNIGHT)

{

// Bonus for outpost square

if ( relative_rank(Us, s) >= RANK_4

&& relative_rank(Us, s) <= RANK_6

&& !(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s)))

score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)];

// Bonus when behind a pawn

if ( relative_rank(Us, s) < RANK_5

&& (pos.pieces(PAWN) & (s + pawn_push(Us))))

score += MinorBehindPawn;

// Penalty for pawns on same color square of bishop

if (Pt == BISHOP)

score -= BishopPawns * ei.pi->pawns_on_same_color_squares(Us, s);

// An important Chess960 pattern: A cornered bishop blocked by a friendly

// pawn diagonally in front of it is a very serious problem, especially

// when that pawn is also blocked.

if ( Pt == BISHOP

&& pos.is_chess960()

&& (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))

{

Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);

if (pos.piece_on(s + d) == make_piece(Us, PAWN))

score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4

: pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2

: TrappedBishopA1H1;

}

}

if (Pt == ROOK)

{

// Bonus for aligning with enemy pawns on the same rank/file

if (relative_rank(Us, s) >= RANK_5)

{

Bitboard alignedPawns = pos.pieces(Them, PAWN) & PseudoAttacks[ROOK][s];

if (alignedPawns)

score += popcount<Max15>(alignedPawns) * RookOnPawn;

}

// Bonus when on an open or semi-open file

if (ei.pi->semiopen_file(Us, file_of(s)))

score += ei.pi->semiopen_file(Them, file_of(s)) ? RookOnOpenFile : RookOnSemiOpenFile;

// Penalize when trapped by the king, even more if king cannot castle

if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s)))

{

Square ksq = pos.square<KING>(Us);

if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))

&& (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1)

&& !ei.pi->semiopen_side(Us, file_of(ksq), file_of(s) < file_of(ksq)))

score -= (TrappedRook - make_score(mob * 22, 0)) * (1 + !pos.can_castle(Us));

}

}

}

if (DoTrace)

Trace::add(Pt, Us, score);

// Recursively call evaluate_pieces() of next piece type until KING excluded

return score - evaluate_pieces<NextPt, Them, DoTrace>(pos, ei, mobility, mobilityArea);

const Color Them = (Us == WHITE ? BLACK : WHITE);

Bitboard undefended, b, b1, b2, safe;

int attackUnits;

const Square ksq = pos.square<KING>(Us);

// King shelter and enemy pawns storm

Score score = ei.pi->king_safety<Us>(pos, ksq);

// Main king safety evaluation

if (ei.kingAttackersCount[Them])

{

// Find the attacked squares around the king which have no defenders

// apart from the king itself

undefended = ei.attackedBy[Them][ALL_PIECES]

& ei.attackedBy[Us][KING]

& ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]

| ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]

| ei.attackedBy[Us][QUEEN]);

// Initialize the 'attackUnits' variable, which is used later on as an

// index into the KingDanger[] array. The initial value is based on the

// 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(72, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them])

+ 9 * ei.kingAdjacentZoneAttacksCount[Them]

+ 27 * popcount<Max15>(undefended)

+ 11 * !!ei.pinnedPieces[Us]

- 64 * !pos.count<QUEEN>(Them)

- mg_value(score) / 8;

// Analyse the enemy's safe queen contact checks. Firstly, find the

// undefended squares around the king reachable by the enemy queen...

b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces(Them);

if (b)

{

// ...and then remove squares not supported by another enemy piece

b &= ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]

| ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]

| ei.attackedBy[Them][KING];

if (b)

attackUnits += QueenContactCheck * popcount<Max15>(b);

}

// Analyse the enemy's safe distance checks for sliders and knights

safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them));

b1 = pos.attacks_from<ROOK >(ksq) & safe;

b2 = pos.attacks_from<BISHOP>(ksq) & safe;

// Enemy queen safe checks

b = (b1 | b2) & ei.attackedBy[Them][QUEEN];

if (b)

{

attackUnits += QueenCheck * popcount<Max15>(b);

score -= Checked;

}

// Enemy rooks safe checks

b = b1 & ei.attackedBy[Them][ROOK];

if (b)

{

attackUnits += RookCheck * popcount<Max15>(b);

score -= Checked;

}

// Enemy bishops safe checks

b = b2 & ei.attackedBy[Them][BISHOP];

if (b)

{

attackUnits += BishopCheck * popcount<Max15>(b);

score -= Checked;

}

// Enemy knights safe checks

b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;

if (b)

{

attackUnits += KnightCheck * popcount<Max15>(b);

score -= Checked;

}

// Finally, extract the king danger score from the KingDanger[]

// array and subtract the score from evaluation.

score -= KingDanger[std::max(std::min(attackUnits, 399), 0)];

}

if (DoTrace)

Trace::add(KING, Us, score);

return score;

const Color Them = (Us == WHITE ? BLACK : WHITE);

const Square Up = (Us == WHITE ? DELTA_N : DELTA_S);

const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE);

const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);

const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB);

const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);

enum { Minor, Rook };

Bitboard b, weak, defended, safeThreats;

Score score = SCORE_ZERO;

// Non-pawn enemies attacked by a pawn

weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN];

if (weak)

{

b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES]

| ei.attackedBy[Us][ALL_PIECES]);

safeThreats = (shift_bb<Right>(b) | shift_bb<Left>(b)) & weak;

if (weak ^ safeThreats)

score += ThreatenedByHangingPawn;

while (safeThreats)

score += ThreatenedByPawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))];

}

// Non-pawn enemies defended by a pawn

defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN];

// Enemies not defended by a pawn and under our attack

weak = pos.pieces(Them)

& ~ei.attackedBy[Them][PAWN]

& ei.attackedBy[Us][ALL_PIECES];

// Add a bonus according to the kind of attacking pieces

if (defended | weak)

{

b = (defended | weak) & (ei.attackedBy[Us][KNIGHT] | ei.attackedBy[Us][BISHOP]);

while (b)

score += Threat[Minor][type_of(pos.piece_on(pop_lsb(&b)))];

b = (pos.pieces(Them, QUEEN) | weak) & ei.attackedBy[Us][ROOK];

while (b)

score += Threat[Rook ][type_of(pos.piece_on(pop_lsb(&b)))];

b = weak & ~ei.attackedBy[Them][ALL_PIECES];

if (b)

score += Hanging * popcount<Max15>(b);

b = weak & ei.attackedBy[Us][KING];

if (b)

score += more_than_one(b) ? KingOnMany : KingOnOne;

}

// Bonus if some pawns can safely push and attack an enemy piece

b = pos.pieces(Us, PAWN) & ~TRank7BB;

b = shift_bb<Up>(b | (shift_bb<Up>(b & TRank2BB) & ~pos.pieces()));

b &= ~pos.pieces()

& ~ei.attackedBy[Them][PAWN]

& (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);

b = (shift_bb<Left>(b) | shift_bb<Right>(b))

& pos.pieces(Them)

& ~ei.attackedBy[Us][PAWN];

if (b)

score += popcount<Max15>(b) * PawnAttackThreat;

if (DoTrace)

Trace::add(THREAT, Us, score);

return score;

const Color Them = (Us == WHITE ? BLACK : WHITE);

Bitboard b, squaresToQueen, defendedSquares, unsafeSquares;

Score score = SCORE_ZERO;

b = ei.pi->passed_pawns(Us);

while (b)

{

Square s = pop_lsb(&b);

assert(pos.pawn_passed(Us, s));

int r = relative_rank(Us, s) - RANK_2;

int rr = r * (r - 1);

Value mbonus = Passed[MG][r], ebonus = Passed[EG][r];

if (rr)

{

Square blockSq = s + pawn_push(Us);

// Adjust bonus based on the king's proximity

ebonus += distance(pos.square<KING>(Them), blockSq) * 5 * rr

- distance(pos.square<KING>(Us ), blockSq) * 2 * rr;

// If blockSq is not the queening square then consider also a second push

if (relative_rank(Us, blockSq) != RANK_8)

ebonus -= distance(pos.square<KING>(Us), blockSq + pawn_push(Us)) * rr;

// If the pawn is free to advance, then increase the bonus

if (pos.empty(blockSq))

{

// If there is a rook or queen attacking/defending the pawn from behind,

// consider all the squaresToQueen. Otherwise consider only the squares

// in the pawn's path attacked or occupied by the enemy.

defendedSquares = unsafeSquares = squaresToQueen = forward_bb(Us, s);

Bitboard bb = forward_bb(Them, s) & pos.pieces(ROOK, QUEEN) & pos.attacks_from<ROOK>(s);

if (!(pos.pieces(Us) & bb))

defendedSquares &= ei.attackedBy[Us][ALL_PIECES];

if (!(pos.pieces(Them) & bb))

unsafeSquares &= ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them);

// If there aren't any enemy attacks, assign a big bonus. Otherwise

// assign a smaller bonus if the block square isn't attacked.

int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0;

// If the path to queen is fully defended, assign a big bonus.

// Otherwise assign a smaller bonus if the block square is defended.

if (defendedSquares == squaresToQueen)

k += 6;

else if (defendedSquares & blockSq)

k += 4;

mbonus += k * rr, ebonus += k * rr;

}

else if (pos.pieces(Us) & blockSq)

mbonus += rr * 3 + r * 2 + 3, ebonus += rr + r * 2;

} // rr != 0

if (pos.count<PAWN>(Us) < pos.count<PAWN>(Them))

ebonus += ebonus / 4;

score += make_score(mbonus, ebonus) + PassedFile[file_of(s)];

}

if (DoTrace)

Trace::add(PASSED, Us, score * Weights[PassedPawns]);

// Add the scores to the middlegame and endgame eval

return score * Weights[PassedPawns];

const Color Them = (Us == WHITE ? BLACK : WHITE);

// Find the safe squares for our pieces inside the area defined by

// SpaceMask[]. A square is unsafe if it is attacked by an enemy

// pawn, or if it is undefended and attacked by an enemy piece.

Bitboard safe = SpaceMask[Us]

& ~pos.pieces(Us, PAWN)

& ~ei.attackedBy[Them][PAWN]

& (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]);

// Find all squares which are at most three squares behind some friendly pawn

Bitboard behind = pos.pieces(Us, PAWN);

behind |= (Us == WHITE ? behind >> 8 : behind << 8);

behind |= (Us == WHITE ? behind >> 16 : behind << 16);

// Since SpaceMask[Us] is fully on our half of the board...

assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0);

// ...count safe + (behind & safe) with a single popcount

int bonus = popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));

int weight = pos.count<KNIGHT>(Us) + pos.count<BISHOP>(Us)

+ pos.count<KNIGHT>(Them) + pos.count<BISHOP>(Them);

return make_score(bonus * weight * weight, 0);

int kingDistance = distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK));

int pawns = pos.count<PAWN>(WHITE) + pos.count<PAWN>(BLACK);

// Compute the initiative bonus for the attacking side

int initiative = 8 * (pawns + asymmetry + kingDistance - 15);

// Now apply the bonus: note that we find the attacking side by extracting

// the sign of the endgame value, and that we carefully cap the bonus so

// that the endgame score will never be divided by more than two.

int value = ((eg > 0) - (eg < 0)) * std::max(initiative, -abs(eg / 2));

return make_score(0, value);

assert(!pos.checkers());

EvalInfo ei;

Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };

// Initialize score by reading the incrementally updated scores included

// in the position object (material + piece square tables).

// Score is computed from the point of view of white.

score = pos.psq_score();

// Probe the material hash table

Material::Entry* me = Material::probe(pos);

score += me->imbalance();

// If we have a specialized evaluation function for the current material

// configuration, call it and return.

if (me->specialized_eval_exists())

return me->evaluate(pos);

// Probe the pawn hash table

ei.pi = Pawns::probe(pos);

score += ei.pi->pawns_score() * Weights[PawnStructure];

// Initialize attack and king safety bitboards

ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0;

init_eval_info<WHITE>(pos, ei);

init_eval_info<BLACK>(pos, ei);

// Pawns blocked or on ranks 2 and 3. Will be excluded from the mobility area

Bitboard blockedPawns[] = {

pos.pieces(WHITE, PAWN) & (shift_bb<DELTA_S>(pos.pieces()) | Rank2BB | Rank3BB),

pos.pieces(BLACK, PAWN) & (shift_bb<DELTA_N>(pos.pieces()) | Rank7BB | Rank6BB)

};

// Do not include in mobility squares protected by enemy pawns, or occupied

// by our blocked pawns or king.

Bitboard mobilityArea[] = {

~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square<KING>(WHITE)),

~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square<KING>(BLACK))

};

// Evaluate pieces and mobility

score += evaluate_pieces<KNIGHT, WHITE, DoTrace>(pos, ei, mobility, mobilityArea);

score += (mobility[WHITE] - mobility[BLACK]) * Weights[Mobility];

// Evaluate kings after all other pieces because we need complete attack

// information when computing the king safety evaluation.

score += evaluate_king<WHITE, DoTrace>(pos, ei)

- evaluate_king<BLACK, DoTrace>(pos, ei);

// Evaluate tactical threats, we need full attack information including king

score += evaluate_threats<WHITE, DoTrace>(pos, ei)

- evaluate_threats<BLACK, DoTrace>(pos, ei);

// Evaluate passed pawns, we need full attack information including king

score += evaluate_passed_pawns<WHITE, DoTrace>(pos, ei)

- evaluate_passed_pawns<BLACK, DoTrace>(pos, ei);

// If both sides have only pawns, score for potential unstoppable pawns

if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK))

{

Bitboard b;

if ((b = ei.pi->passed_pawns(WHITE)) != 0)

score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable;

if ((b = ei.pi->passed_pawns(BLACK)) != 0)

score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable;

}

// Evaluate space for both sides, only during opening

if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222)

score += (evaluate_space<WHITE>(pos, ei) - evaluate_space<BLACK>(pos, ei)) * Weights[Space];

// Evaluate position potential for the winning side

score += evaluate_initiative(pos, ei.pi->pawn_asymmetry(), eg_value(score));

// Scale winning side if position is more drawish than it appears

Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK;

ScaleFactor sf = me->scale_factor(pos, strongSide);

// If we don't already have an unusual scale factor, check for certain

// types of endgames, and use a lower scale for those.

if ( me->game_phase() < PHASE_MIDGAME

&& (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN))

{

if (pos.opposite_bishops())

{

// Endgame with opposite-colored bishops and no other pieces (ignoring pawns)

// is almost a draw, in case of KBP vs KB is even more a draw.

if ( pos.non_pawn_material(WHITE) == BishopValueMg

&& pos.non_pawn_material(BLACK) == BishopValueMg)

sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9);

// Endgame with opposite-colored bishops, but also other pieces. Still

// a bit drawish, but not as drawish as with only the two bishops.

else

sf = ScaleFactor(46 * sf / SCALE_FACTOR_NORMAL);

}

// Endings where weaker side can place his king in front of the opponent's

// pawns are drawish.

else if ( abs(eg_value(score)) <= BishopValueEg

&& ei.pi->pawn_span(strongSide) <= 1

&& !pos.pawn_passed(~strongSide, pos.square<KING>(~strongSide)))

sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(51) : ScaleFactor(37);

}

// Interpolate between a middlegame and a (scaled by 'sf') endgame score

Value v = mg_value(score) * int(me->game_phase())

+ eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL;

v /= int(PHASE_MIDGAME);

// In case of tracing add all single evaluation terms

if (DoTrace)

{

Trace::add(MATERIAL, pos.psq_score());

Trace::add(IMBALANCE, me->imbalance());

Trace::add(PAWN, ei.pi->pawns_score());

Trace::add(MOBILITY, mobility[WHITE] * Weights[Mobility]

, mobility[BLACK] * Weights[Mobility]);

Trace::add(SPACE, evaluate_space<WHITE>(pos, ei) * Weights[Space]

, evaluate_space<BLACK>(pos, ei) * Weights[Space]);

Trace::add(TOTAL, score);

}

return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view

std::memset(scores, 0, sizeof(scores));

Value v = evaluate<true>(pos);

v = pos.side_to_move() == WHITE ? v : -v; // White's point of view

std::stringstream ss;

ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)

<< " Eval term | White | Black | Total \n"

<< " | MG EG | MG EG | MG EG \n"

<< "----------------+-------------+-------------+-------------\n"

<< " Material | " << Term(MATERIAL)

<< " Imbalance | " << Term(IMBALANCE)

<< " Pawns | " << Term(PAWN)

<< " Knights | " << Term(KNIGHT)

<< " Bishop | " << Term(BISHOP)

<< " Rooks | " << Term(ROOK)

<< " Queens | " << Term(QUEEN)

<< " Mobility | " << Term(MOBILITY)

<< " King safety | " << Term(KING)

<< " Threats | " << Term(THREAT)

<< " Passed pawns | " << Term(PASSED)

<< " Space | " << Term(SPACE)

<< "----------------+-------------+-------------+-------------\n"

<< " Total | " << Term(TOTAL);

ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n";

return ss.str();

const int MaxSlope = 8700;

const int Peak = 1280000;

int t = 0;

for (int i = 0; i < 400; ++i)

{

t = std::min(Peak, std::min(i * i * 27, t + MaxSlope));

KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety];

}