public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
var positionOpeningScore = board.Position[color][GamePhase.Opening];
var positionEndingScore = board.Position[color][GamePhase.Ending];
return(TaperedEvaluation.AdjustToPhase(positionOpeningScore, positionEndingScore, openingPhase, endingPhase));
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
var kingSidePawnsPattern = color == Color.White ? KingSideWhitePawnsPattern : KingSideBlackPawnsPattern;
var kingSideBishopPattern = color == Color.White ? KingSideWhiteBishopPattern : KingSideBlackBishopPattern;
var queenSidePawnsPattern = color == Color.White ? QueenSideWhitePawnsPattern : QueenSideBlackPawnsPattern;
var queenSideBishopPattern = color == Color.White ? QueenSideWhiteBishopPattern : QueenSideBlackBishopPattern;
var pawns = board.Pieces[color][Piece.Pawn];
var bishops = board.Pieces[color][Piece.Bishop];
var fianchettoOpeningScore = EvaluationConstants.Fianchetto;
var fianchettoPenaltyOpeningScore = EvaluationConstants.FianchettoWithoutBishop;
if ((pawns & kingSidePawnsPattern) == kingSidePawnsPattern)
{
if ((bishops & kingSideBishopPattern) == kingSideBishopPattern)
{
return(TaperedEvaluation.AdjustToPhase(fianchettoOpeningScore, 0, openingPhase, endingPhase));
}
return(TaperedEvaluation.AdjustToPhase(fianchettoPenaltyOpeningScore, 0, openingPhase, endingPhase));
}
if ((pawns & queenSidePawnsPattern) == queenSidePawnsPattern)
{
if ((bishops & queenSideBishopPattern) == queenSideBishopPattern)
{
return(TaperedEvaluation.AdjustToPhase(fianchettoOpeningScore, 0, openingPhase, endingPhase));
}
return(TaperedEvaluation.AdjustToPhase(fianchettoPenaltyOpeningScore, 0, openingPhase, endingPhase));
}
return(0);
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
var pairOfBishops = 0;
if (BitOperations.Count(board.Pieces[color][Piece.Bishop]) > 1)
{
pairOfBishops = 1;
}
var fianchettos = 0;
var fianchettosWithoutBishop = 0;
var kingPattern = color == Color.White ? WhiteKingFianchettoPattern : BlackKingFianchettoPatteren;
var pawnsPattern = color == Color.White ? WhitePawnsFianchettoPattern : BlackPawnsFianchettoPattern;
var bishopPattern = color == Color.White ? WhiteBishopFianchettoPattern : BlackBishopFianchettoPattern;
if (board.CastlingDone[color] && (board.Pieces[color][Piece.King] & kingPattern) != 0 && (board.Pieces[color][Piece.Pawn] & pawnsPattern) == pawnsPattern)
{
if ((board.Pieces[color][Piece.Bishop] & bishopPattern) == bishopPattern)
{
fianchettos++;
}
else
{
fianchettosWithoutBishop++;
}
}
var pairOfBishopsOpeningScore = pairOfBishops * EvaluationConstants.PairOfBishops;
var fianchettosScore = fianchettos * EvaluationConstants.Fianchetto;
var fianchettosWithoutBishopScore = fianchettosWithoutBishop * EvaluationConstants.FianchettoWithoutBishop;
var openingScore = pairOfBishopsOpeningScore + fianchettosScore + fianchettosWithoutBishopScore;
return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
}
public static int EvaluateWithoutCache(BoardState board, EvaluationStatistics statistics, int openingPhase, int endingPhase)
{
var(openingWhiteScore, endingWhiteScore) = Evaluate(board, Color.White, openingPhase, endingPhase);
var(openingBlackScore, endingBlackScore) = Evaluate(board, Color.Black, openingPhase, endingPhase);
var openingScore = openingWhiteScore - openingBlackScore;
var endingScore = endingWhiteScore - endingBlackScore;
return(TaperedEvaluation.AdjustToPhase(openingScore, endingScore, openingPhase, endingPhase));
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase, ref ulong fieldsAttackedByColor)
{
var mobility = KnightOperator.GetMobility(board, color, ref fieldsAttackedByColor) +
BishopOperator.GetMobility(board, color, ref fieldsAttackedByColor) +
RookOperator.GetMobility(board, color, ref fieldsAttackedByColor) +
QueenOperator.GetMobility(board, color, ref fieldsAttackedByColor);
var mobilityOpeningScore = mobility * EvaluationConstants.Mobility;
return(TaperedEvaluation.AdjustToPhase(mobilityOpeningScore, 0, openingPhase, endingPhase));
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
var doubledRooks = 0;
var rooksOnOpenFile = 0;
var pairOfBishops = 0;
var enemyColor = ColorOperations.Invert(color);
var rooks = board.Pieces[color][Piece.Rook];
while (rooks != 0)
{
var lsb = BitOperations.GetLsb(rooks);
var field = BitOperations.BitScan(lsb);
rooks = BitOperations.PopLsb(rooks);
var file = FilePatternGenerator.GetPattern(field) | lsb;
var rooksOnFile = file & board.Pieces[color][Piece.Rook];
var friendlyPawnsOnFile = file & board.Pieces[color][Piece.Pawn];
var enemyPawnsOnFile = file & board.Pieces[enemyColor][Piece.Pawn];
if (BitOperations.Count(rooksOnFile) > 1)
{
// We don't assume that there will be more than two rooks - even if, then this color is probably anyway winning
doubledRooks = 1;
}
if (friendlyPawnsOnFile == 0 && enemyPawnsOnFile == 0)
{
rooksOnOpenFile++;
}
}
var bishops = board.Pieces[color][Piece.Bishop];
if (BitOperations.Count(bishops) > 1)
{
pairOfBishops = 1;
}
var doubledRooksOpeningScore = doubledRooks * EvaluationConstants.DoubledRooks;
var doubledRooksAdjusted = TaperedEvaluation.AdjustToPhase(doubledRooksOpeningScore, 0, openingPhase, endingPhase);
var rooksOnOpenFileOpeningScore = rooksOnOpenFile * EvaluationConstants.RookOnOpenFile;
var rooksOnOpenFileAdjusted = TaperedEvaluation.AdjustToPhase(rooksOnOpenFileOpeningScore, 0, openingPhase, endingPhase);
var pairOfBishopsOpeningScore = pairOfBishops * EvaluationConstants.PairOfBishops;
var pairOfBishopsAdjusted = TaperedEvaluation.AdjustToPhase(pairOfBishopsOpeningScore, 0, openingPhase, endingPhase);
return(doubledRooksAdjusted + rooksOnOpenFileAdjusted + pairOfBishopsAdjusted);
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase, ref ulong fieldsAttackedByColor)
{
var(knightCenter, knightOutside) = KnightOperator.GetMobility(board, color, ref fieldsAttackedByColor);
var(bishopCenter, bishopOutside) = BishopOperator.GetMobility(board, color, ref fieldsAttackedByColor);
var(rookCenter, rookOutside) = RookOperator.GetMobility(board, color, ref fieldsAttackedByColor);
var(queenCenter, queenOutside) = QueenOperator.GetMobility(board, color, ref fieldsAttackedByColor);
var centerMobility = knightCenter + bishopCenter + rookCenter + queenCenter;
var centerMobilityScore = centerMobility * EvaluationConstants.CenterMobilityModifier;
var outsideMobility = knightOutside + bishopOutside + rookOutside + queenOutside;
var outsideMobilityScore = outsideMobility * EvaluationConstants.OutsideMobilityModifier;
var openingScore = centerMobilityScore + outsideMobilityScore;
return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
if (board.CastlingDone[color])
{
var openingScore = EvaluationConstants.CastlingDone;
return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
}
if (color == Color.White && (board.Castling & Castling.WhiteCastling) == 0 ||
color == Color.Black && (board.Castling & Castling.BlackCastling) == 0)
{
var openingScore = EvaluationConstants.CastlingFailed;
return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
}
return(0);
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase, ulong fieldsAttackedByEnemy)
{
var king = board.Pieces[color][Piece.King];
var kingField = BitOperations.BitScan(king);
var fieldsAroundKing = _kingSafetyMask[color][kingField];
var attackedFieldsAroundKing = fieldsAroundKing & fieldsAttackedByEnemy;
var attackersCount = (int)BitOperations.Count(attackedFieldsAroundKing);
var pawnsNearKing = fieldsAroundKing & board.Pieces[color][Piece.Pawn];
var pawnShield = (int)BitOperations.Count(pawnsNearKing);
var attackersCountOpeningScore = attackersCount * EvaluationConstants.KingInDanger;
var attackersCountAdjusted = TaperedEvaluation.AdjustToPhase(attackersCountOpeningScore, 0, openingPhase, endingPhase);
var pawnShieldOpeningScore = pawnShield * EvaluationConstants.PawnShield;
var pawnShieldAdjusted = TaperedEvaluation.AdjustToPhase(pawnShieldOpeningScore, 0, openingPhase, endingPhase);
return(attackersCountAdjusted + pawnShieldAdjusted);
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase, ulong fieldsAttackedByEnemy)
{
var enemyColor = ColorOperations.Invert(color);
var king = board.Pieces[color][Piece.King];
var kingField = BitOperations.BitScan(king);
var kingPosition = Position.FromFieldIndex(kingField);
var fieldsAroundKing = ForwardBoxPatternGenerator.GetPattern(color, kingField);
var attackedFieldsAroundKing = fieldsAroundKing & fieldsAttackedByEnemy;
var attackersCount = (int)BitOperations.Count(attackedFieldsAroundKing);
var attackersCountOpeningScore = attackersCount * EvaluationConstants.KingInDanger;
var pawnShieldOpeningScore = 0;
var openFilesNextToKingScore = 0;
if (board.CastlingDone[color])
{
var pawnsNearKing = fieldsAroundKing & board.Pieces[color][Piece.Pawn];
var pawnShield = (int)BitOperations.Count(pawnsNearKing);
pawnShieldOpeningScore = pawnShield * EvaluationConstants.PawnShield;
var openFileCheckFrom = Math.Max(0, kingPosition.X - 1);
var openFileCheckTo = Math.Min(7, kingPosition.X + 1);
for (var file = openFileCheckFrom; file <= openFileCheckTo; file++)
{
if ((FilePatternGenerator.GetPatternForFile(7 - file) & board.Pieces[color][Piece.Pawn]) == 0)
{
openFilesNextToKingScore += EvaluationConstants.OpenFileNextToKing;
}
}
}
var openingScore = pawnShieldOpeningScore + attackersCountOpeningScore + openFilesNextToKingScore;
return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
}
public static int Evaluate(BoardState board, EvaluationStatistics statistics, int openingPhase, int endingPhase)
{
var entry = PawnHashTable.Get(board.PawnHash);
if (entry.IsKeyValid(board.PawnHash))
{
#if DEBUG
statistics.PHTHits++;
#endif
return(TaperedEvaluation.AdjustToPhase(entry.OpeningScore, entry.EndingScore, openingPhase, endingPhase));
}
#if DEBUG
else
{
statistics.PHTNonHits++;
if (entry.Key != 0 || entry.OpeningScore != 0 || entry.EndingScore != 0)
{
statistics.PHTReplacements++;
}
}
#endif
var(openingWhiteScore, endingWhiteScore) = Evaluate(board, Color.White, openingPhase, endingPhase);
var(openingBlackScore, endingBlackScore) = Evaluate(board, Color.Black, openingPhase, endingPhase);
var openingScore = openingWhiteScore - openingBlackScore;
var endingScore = endingWhiteScore - endingBlackScore;
var result = TaperedEvaluation.AdjustToPhase(openingScore, endingScore, openingPhase, endingPhase);
PawnHashTable.Add(board.PawnHash, (short)openingScore, (short)endingScore);
#if DEBUG
statistics.PHTAddedEntries++;
#endif
return(result);
}
public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
{
var doubledPawns = 0;
var isolatedPawns = 0;
var chainedPawns = 0;
var passingPawns = 0;
var enemyColor = ColorOperations.Invert(color);
for (var file = 0; file < 8; file++)
{
var friendlyPawnsOnInnerMask = board.Pieces[color][Piece.Pawn] & _innerFileMasks[file];
var friendlyPawnsOnOuterMask = board.Pieces[color][Piece.Pawn] & _outerFileMasks[file];
var enemyPawnsOnInnerMask = board.Pieces[enemyColor][Piece.Pawn] & _innerFileMasks[file];
var enemyPawnsOnOuterMask = board.Pieces[enemyColor][Piece.Pawn] & _outerFileMasks[file];
var pawnsCount = BitOperations.Count(friendlyPawnsOnInnerMask);
if (pawnsCount > 1)
{
doubledPawns += (int)(pawnsCount - 1);
}
if (friendlyPawnsOnInnerMask != 0)
{
if (friendlyPawnsOnOuterMask == 0)
{
isolatedPawns += (int)BitOperations.Count(pawnsCount);
}
if (enemyPawnsOnInnerMask == 0 && enemyPawnsOnOuterMask == 0)
{
passingPawns++;
}
}
}
var pieces = board.Pieces[color][Piece.Pawn];
while (pieces != 0)
{
var lsb = BitOperations.GetLsb(pieces);
var field = BitOperations.BitScan(lsb);
pieces = BitOperations.PopLsb(pieces);
var chain = _chainMasks[field] & board.Pieces[color][Piece.Pawn];
if (chain != 0)
{
chainedPawns += (int)BitOperations.Count(chain);
}
}
var doubledPawnsOpeningScore = doubledPawns * EvaluationConstants.DoubledPawns[GamePhase.Opening];
var doubledPawnsEndingScore = doubledPawns * EvaluationConstants.DoubledPawns[GamePhase.Ending];
var doubledPawnsAdjusted = TaperedEvaluation.AdjustToPhase(doubledPawnsOpeningScore, doubledPawnsEndingScore, openingPhase, endingPhase);
var isolatedPawnsOpeningScore = isolatedPawns * EvaluationConstants.IsolatedPawns[GamePhase.Opening];
var isolatedPawnsEndingScore = isolatedPawns * EvaluationConstants.IsolatedPawns[GamePhase.Ending];
var isolatedPawnsAdjusted = TaperedEvaluation.AdjustToPhase(isolatedPawnsOpeningScore, isolatedPawnsEndingScore, openingPhase, endingPhase);
var chainedPawnsOpeningScore = chainedPawns * EvaluationConstants.ChainedPawns[GamePhase.Opening];
var chainedPawnsEndingScore = chainedPawns * EvaluationConstants.ChainedPawns[GamePhase.Ending];
var chainedPawnsAdjusted = TaperedEvaluation.AdjustToPhase(chainedPawnsOpeningScore, chainedPawnsEndingScore, openingPhase, endingPhase);
var passingPawnsOpeningScore = passingPawns * EvaluationConstants.PassingPawns[GamePhase.Opening];
var passingPawnsEndingScore = passingPawns * EvaluationConstants.PassingPawns[GamePhase.Ending];
var passingPawnsAdjusted = TaperedEvaluation.AdjustToPhase(passingPawnsOpeningScore, passingPawnsEndingScore, openingPhase, endingPhase);
return(doubledPawnsAdjusted + isolatedPawnsAdjusted + chainedPawnsAdjusted + passingPawnsAdjusted);
}
