/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
struct EvalInfo {
// Pointers to material and pawn hash table entries
- MaterialEntry* mi;
- PawnEntry* pi;
+ Material::Entry* mi;
+ Pawns::Entry* pi;
// attackedBy[color][piece type] is a bitboard representing all squares
- // attacked by a given color and piece type, attackedBy[color][0] contains
- // all squares attacked by the given color.
+ // attacked by a given color and piece type, attackedBy[color][ALL_PIECES]
+ // contains all squares attacked by the given color.
Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
// kingRing[color] is the zone around the king which is considered
//
// Values modified by Joona Kiiski
const Score WeightsInternal[] = {
- S(252, 344), S(216, 266), S(46, 0), S(247, 0), S(259, 0)
+ S(289, 344), S(221, 273), S(46, 0), S(271, 0), S(307, 0)
};
// MobilityBonus[PieceType][attacked] contains mobility bonuses for middle and
#undef S
+ const Score BishopPinBonus = make_score(66, 11);
+
// Bonus for having the side to move (modified by Joona Kiiski)
const Score Tempo = make_score(24, 11);
// Rooks and queens on the 7th rank
- const Score RookOn7thBonus = make_score(3, 20);
- const Score QueenOn7thBonus = make_score(1, 8);
+ const Score RookOn7thBonus = make_score(11, 20);
+ const Score QueenOn7thBonus = make_score( 3, 8);
// Rooks and queens attacking pawns on the same rank
- const Score RookOnPawnBonus = make_score(3, 48);
- const Score QueenOnPawnBonus = make_score(1, 40);
+ const Score RookOnPawnBonus = make_score(10, 28);
+ const Score QueenOnPawnBonus = make_score( 4, 20);
// Rooks on open files (modified by Joona Kiiski)
const Score RookOpenFileBonus = make_score(43, 21);
// right to castle.
const Value TrappedRookPenalty = Value(180);
+ // Penalty for bishop with pawns on the same coloured squares
+ const Score BishopPawnsPenalty = make_score(8, 12);
+
// Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
// a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
// happen in Chess960 games.
Weights[KingDangerUs] = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
Weights[KingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
- // King safety is asymmetrical. Our king danger level is weighted by
- // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
- // If running in analysis mode, make sure we use symmetrical king safety. We
- // do this by replacing both Weights[kingDangerUs] and Weights[kingDangerThem]
- // by their average.
- if (Options["UCI_AnalyseMode"])
- Weights[KingDangerUs] = Weights[KingDangerThem] = (Weights[KingDangerUs] + Weights[KingDangerThem]) / 2;
-
const int MaxSlope = 30;
const int Peak = 1280;
template<bool Trace>
Value do_evaluate(const Position& pos, Value& margin) {
- assert(!pos.in_check());
+ assert(!pos.checkers());
EvalInfo ei;
Value margins[COLOR_NB];
Score score, mobilityWhite, mobilityBlack;
+ Thread* th = pos.this_thread();
// margins[] store the uncertainty estimation of position's evaluation
// that typically is used by the search for pruning decisions.
score = pos.psq_score() + (pos.side_to_move() == WHITE ? Tempo : -Tempo);
// Probe the material hash table
- ei.mi = pos.this_thread()->materialTable.probe(pos);
+ ei.mi = Material::probe(pos, th->materialTable, th->endgames);
score += ei.mi->material_value();
// If we have a specialized evaluation function for the current material
}
// Probe the pawn hash table
- ei.pi = pos.this_thread()->pawnTable.probe(pos);
+ ei.pi = Pawns::probe(pos, th->pawnsTable);
score += ei.pi->pawns_value();
// Initialize attack and king safety bitboards
// Init king safety tables only if we are going to use them
if ( pos.piece_count(Us, QUEEN)
- && pos.non_pawn_material(Us) >= QueenValueMg + RookValueMg)
+ && pos.non_pawn_material(Us) > QueenValueMg + PawnValueMg)
{
ei.kingRing[Them] = (b | (Us == WHITE ? b >> 8 : b << 8));
b &= ei.attackedBy[Us][PAWN];
mobility += MobilityBonus[Piece][mob];
- // Add a bonus if a slider is pinning an enemy piece
- if ( (Piece == BISHOP || Piece == ROOK || Piece == QUEEN)
- && (PseudoAttacks[Piece][pos.king_square(Them)] & s))
- {
- b = BetweenBB[s][pos.king_square(Them)] & pos.pieces();
-
- assert(b);
-
- if (!more_than_one(b) && (b & pos.pieces(Them)))
- score += ThreatBonus[Piece][type_of(pos.piece_on(lsb(b)))];
- }
-
// Decrease score if we are attacked by an enemy pawn. Remaining part
// of threat evaluation must be done later when we have full attack info.
if (ei.attackedBy[Them][PAWN] & s)
score -= ThreatenedByPawnPenalty[Piece];
+ // Otherwise give a bonus if we are a bishop and can pin a piece or
+ // can give a discovered check through an x-ray attack.
+ else if ( Piece == BISHOP
+ && (PseudoAttacks[Piece][pos.king_square(Them)] & s)
+ && !more_than_one(BetweenBB[s][pos.king_square(Them)] & pos.pieces()))
+ score += BishopPinBonus;
+
+ // Penalty for bishop with same coloured pawns
+ if (Piece == BISHOP)
+ score -= BishopPawnsPenalty * ei.pi->pawns_on_same_color_squares(Us, s);
+
// Bishop and knight outposts squares
if ( (Piece == BISHOP || Piece == KNIGHT)
&& !(pos.pieces(Them, PAWN) & attack_span_mask(Us, s)))
// Undefended minors get penalized even if not under attack
undefendedMinors = pos.pieces(Them)
& (pos.pieces(BISHOP) | pos.pieces(KNIGHT))
- & ~ei.attackedBy[Them][0];
+ & ~ei.attackedBy[Them][ALL_PIECES];
if (undefendedMinors)
- score += more_than_one(undefendedMinors) ? UndefendedMinorPenalty * 2
- : UndefendedMinorPenalty;
+ score += UndefendedMinorPenalty;
// Enemy pieces not defended by a pawn and under our attack
weakEnemies = pos.pieces(Them)
& ~ei.attackedBy[Them][PAWN]
- & ei.attackedBy[Us][0];
+ & ei.attackedBy[Us][ALL_PIECES];
if (!weakEnemies)
return score;
Score score = mobility = SCORE_ZERO;
// Do not include in mobility squares protected by enemy pawns or occupied by our pieces
- const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us));
+ const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces(Us, PAWN, KING));
score += evaluate_pieces<KNIGHT, Us, Trace>(pos, ei, mobility, mobilityArea);
score += evaluate_pieces<BISHOP, Us, Trace>(pos, ei, mobility, mobilityArea);
score += evaluate_pieces<QUEEN, Us, Trace>(pos, ei, mobility, mobilityArea);
// Sum up all attacked squares
- ei.attackedBy[Us][0] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
- | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
- | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
+ ei.attackedBy[Us][ALL_PIECES] = ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
+ | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
+ | ei.attackedBy[Us][QUEEN] | ei.attackedBy[Us][KING];
return score;
}
{
// Find the attacked squares around the king which has no defenders
// apart from the king itself
- undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
+ undefended = ei.attackedBy[Them][ALL_PIECES] & ei.attackedBy[Us][KING];
undefended &= ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
| ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
| ei.attackedBy[Us][QUEEN]);
}
// Analyse enemy's safe distance checks for sliders and knights
- safe = ~(pos.pieces(Them) | ei.attackedBy[Us][0]);
+ safe = ~(pos.pieces(Them) | ei.attackedBy[Us][ALL_PIECES]);
b1 = pos.attacks_from<ROOK>(ksq) & safe;
b2 = pos.attacks_from<BISHOP>(ksq) & safe;
if (pos.is_empty(blockSq))
{
squaresToQueen = forward_bb(Us, s);
- defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
+ defendedSquares = squaresToQueen & ei.attackedBy[Us][ALL_PIECES];
// If there is an enemy rook or queen attacking the pawn from behind,
// add all X-ray attacks by the rook or queen. Otherwise consider only
&& (forward_bb(Them, s) & pos.pieces(Them, ROOK, QUEEN) & pos.attacks_from<ROOK>(s)))
unsafeSquares = squaresToQueen;
else
- unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces(Them));
+ unsafeSquares = squaresToQueen & (ei.attackedBy[Them][ALL_PIECES] | pos.pieces(Them));
// If there aren't enemy attacks or pieces along the path to queen give
// huge bonus. Even bigger if we protect the pawn's path.
// Compute plies to queening and check direct advancement
movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
- pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
+ pathDefended = ((ei.attackedBy[c][ALL_PIECES] & queeningPath) == queeningPath);
if (movesToGo >= oppMovesToGo && !pathDefended)
continue;
// Opponent king cannot block because path is defended and position
// is not in check. So only friendly pieces can be blockers.
- assert(!pos.in_check());
+ assert(!pos.checkers());
assert((queeningPath & pos.pieces()) == (queeningPath & pos.pieces(c)));
// Add moves needed to free the path from friendly pieces and retest condition
Bitboard safe = SpaceMask[Us]
& ~pos.pieces(Us, PAWN)
& ~ei.attackedBy[Them][PAWN]
- & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
+ & (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);
- return popcount<Max15>(safe) + popcount<Max15>(behind & safe);
+ // 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
+ return popcount<Full>((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe));
}
projects / stockfish / blobdiff