#include <iostream>
#include <iomanip>
#include <sstream>
+#include <algorithm>
#include "bitcount.h"
#include "evaluate.h"
//
// Values modified by Joona Kiiski
const Score WeightsInternal[] = {
- S(248, 271), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
+ S(252, 344), S(216, 266), S(46, 0), S(247, 0), S(259, 0)
};
// MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
- ei.mi = Threads[pos.thread()].materialTable.get_material_info(pos);
+ ei.mi = Threads[pos.thread()].materialTable.material_info(pos);
score += ei.mi->material_value();
// If we have a specialized evaluation function for the current material
}
// Probe the pawn hash table
- ei.pi = Threads[pos.thread()].pawnTable.get_pawn_info(pos);
+ ei.pi = Threads[pos.thread()].pawnTable.pawn_info(pos);
score += ei.pi->pawns_value();
// Initialize attack and king safety bitboards
// no minor piece which can exchange the outpost piece.
if (bonus && bit_is_set(ei.attackedBy[Us][PAWN], s))
{
- if ( pos.pieces(KNIGHT, Them) == EmptyBoardBB
- && (SquaresByColorBB[color_of(s)] & pos.pieces(BISHOP, Them)) == EmptyBoardBB)
+ if ( !pos.pieces(KNIGHT, Them)
+ && !(SquaresByColorBB[color_of(s)] & pos.pieces(BISHOP, Them)))
bonus += bonus + bonus / 2;
else
bonus += bonus / 2;
const Color Them = (Us == WHITE ? BLACK : WHITE);
const Square* pl = pos.piece_list(Us, Piece);
- ei.attackedBy[Us][Piece] = EmptyBoardBB;
+ ei.attackedBy[Us][Piece] = 0;
while ((s = *pl++) != SQ_NONE)
{
// the number and types of the enemy's attacking pieces, the number of
// attacked and undefended squares around our king, the square of the
// king, and the quality of the pawn shelter.
- attackUnits = Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ attackUnits = std::min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
+ 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s<Max15>(undefended))
+ InitKingDanger[relative_square(Us, ksq)]
- mg_value(ei.pi->king_shelter<Us>(pos, ksq)) / 32;
attackUnits += KnightCheckBonus * count_1s<Max15>(b);
// To index KingDangerTable[] attackUnits must be in [0, 99] range
- attackUnits = Min(99, Max(0, attackUnits));
+ attackUnits = std::min(99, std::max(0, attackUnits));
// Finally, extract the king danger score from the KingDangerTable[]
// array and subtract the score from evaluation. Set also margins[]
Square blockSq = s + pawn_push(Us);
// Adjust bonus based on kings proximity
- ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * rr);
- ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * rr);
+ ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 5 * rr);
+ ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 2 * rr);
// If blockSq is not the queening square then consider also a second push
if (rank_of(blockSq) != (Us == WHITE ? RANK_8 : RANK_1))
// If yes, big bonus (but smaller than when there are no enemy attacks),
// if no, somewhat smaller bonus.
ebonus += Value(rr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
-
- // At last, add a small bonus when there are no *friendly* pieces
- // in the pawn's path.
- if (!(squaresToQueen & pos.pieces(Us)))
- ebonus += Value(rr);
}
} // rr != 0
// Increase the bonus if the passed pawn is supported by a friendly pawn
// on the same rank and a bit smaller if it's on the previous rank.
- supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
+ supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(file_of(s));
if (supportingPawns & rank_bb(s))
ebonus += Value(r * 20);
+
else if (supportingPawns & rank_bb(s - pawn_push(Us)))
ebonus += Value(r * 12);
continue;
pliesToGo = 2 * movesToGo - int(c == pos.side_to_move());
- pliesToQueen[c] = Min(pliesToQueen[c], pliesToGo);
+ pliesToQueen[c] = std::min(pliesToQueen[c], pliesToGo);
}
}
pliesToGo = 2 * movesToGo - int(loserSide == pos.side_to_move());
// Generate list of blocking pawns and supporters
- supporters = neighboring_files_bb(s) & candidates;
+ supporters = neighboring_files_bb(file_of(s)) & candidates;
opposed = squares_in_front_of(loserSide, s) & pos.pieces(PAWN, winnerSide);
blockers = passed_pawn_mask(loserSide, s) & pos.pieces(PAWN, winnerSide);
while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
{
d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
- movesToGo = Min(movesToGo, d);
+ movesToGo = std::min(movesToGo, d);
}
}
while (b2) // This while-loop could be replaced with LSB/MSB (depending on color)
{
d = square_distance(blockSq, pop_1st_bit(&b2)) - 2;
- movesToGo = Min(movesToGo, d);
+ movesToGo = std::min(movesToGo, d);
}
// If obstacle can be destroyed with an immediate pawn exchange / sacrifice,
// Plies needed for the king to capture all the blocking pawns
d = square_distance(pos.king_square(loserSide), blockSq);
- minKingDist = Min(minKingDist, d);
+ minKingDist = std::min(minKingDist, d);
kingptg = (minKingDist + blockersCount) * 2;
}
t[i] = Value(int(0.4 * i * i));
if (i > 0)
- t[i] = Min(t[i], t[i - 1] + MaxSlope);
+ t[i] = std::min(t[i], t[i - 1] + MaxSlope);
- t[i] = Min(t[i], Peak);
+ t[i] = std::min(t[i], Peak);
}
// Then apply the weights and get the final KingDangerTable[] array
projects / stockfish / blobdiff