public int EvaluateSlidingPiece(Position position, int color, int pieceType, int materialValue, int mobilityMultiplier, ref Bitboard destinationBitboard)
{
Bitboard pieces = position.GetPieceBitboard(color, pieceType);
int score = 0;
while (pieces != 0)
{
score += materialValue;
int square = pieces.BitScanForward();
Bitboards.PopLsb(ref pieces);
Bitboard attacks = 0;
if (pieceType == Position.ROOK || pieceType == Position.QUEEN)
{
attacks = Bitboards.GetRookMoveBitboard(square, position.AllPiecesBitboard);
}
if (pieceType == Position.BISHOP || pieceType == Position.QUEEN)
{
attacks |= Bitboards.GetBishopMoveBitboard(square, position.AllPiecesBitboard);
}
attacks &= destinationBitboard;
score += Bitboards.CountBits(attacks) * mobilityMultiplier;
}
return(score);
}
public void CalculatesCorrectly()
{
Assert.AreEqual(Position.A1, Bitboards.GetSquareFromName("a1"));
Assert.AreEqual(Position.A7, Bitboards.GetSquareFromName("a7"));
Assert.AreEqual(Position.H8, Bitboards.GetSquareFromName("h8"));
Assert.AreEqual(Position.G3, Bitboards.GetSquareFromName("g3"));
}
public void EvaluateKnight(ref Position position, ref int square, ref int color, ref int score)
{
Bitboard destinations = Bitboards.KnightBitboards[square];
Bitboard myPieces = position.GetPieceBitboard(color, Position.ALL_PIECES);
score += materialValues[Position.KNIGHT];
while (destinations != 0)
{
int attackSquare = destinations.BitScanForward();
Bitboards.PopLsb(ref destinations);
int attackedPiece = position.GetPieceSquares()[attackSquare];
if (attackedPiece == Position.EMPTY)
{
score += 1; // Base mobility bonus
}
// Bonuses for attacking opponent pieces
else if ((Bitboards.SquareBitboards[attackSquare] & myPieces) == 0)
{
score += 2;
}
// Bonuses for defending own pieces
else
{
score += attackBonus[attackedPiece];
}
}
}
public int EvaluatePawns(ref Position position, int color)
{
int score = 0;
Bitboard myPawns = position.GetPieceBitboard(color, Position.PAWN);
Bitboard myPieces = position.GetPieceBitboard(color, Position.ALL_PIECES);
Bitboard opponentPawns =
position.GetPieceBitboard(color == Position.WHITE ? Position.BLACK : Position.WHITE, Position.PAWN);
Bitboard allPawns = myPawns | opponentPawns;
Bitboard pawns = myPawns;
while (pawns != 0)
{
score += materialValues[Position.PAWN];
int currSquare = pawns.BitScanForward();
Bitboards.PopLsb(ref pawns);
// Add bonus based on file of pawn (to promote taking towards the center)
score += pawnFileBonus[Bitboards.GetColumn(currSquare)];
// Analyze stacked pawns
Bitboard filePawns = Bitboards.ColumnBitboards[currSquare] & myPawns;
if ((filePawns & (filePawns - 1)) != 0) // More than 1 pawn in this rank
{
score -= stackedPawnPenalty;
}
// Analyze isolated pawns
if ((Bitboards.IsolatedPawnBitboards[currSquare] & myPawns) == 0)
{
score -= isolatedPawnPenalty;
}
// Analyze passed pawns
if ((Bitboards.PassedPawnBitboards[color, currSquare] & allPawns) == 0)
{
score += passedPawnBonus[color, Bitboards.GetRow(currSquare)];
}
Bitboard pawnAttacks = Bitboards.PawnBitboards[color, currSquare];
while (pawnAttacks != 0)
{
int attackSquare = pawnAttacks.BitScanForward();
Bitboards.PopLsb(ref pawnAttacks);
int attackedPiece = position.GetPieceSquares()[attackSquare];
if (attackedPiece == Position.EMPTY || (myPieces & Bitboards.SquareBitboards[attackSquare]) != 0)
{
continue;
}
score += attackBonus[attackedPiece];
}
}
return(score);
}
static int[] GenerateShifts(Bitboard[] occupancyBBs)
{
int[] result = new int[64];
for (int i = 0; i < 64; i++)
{
result[i] = 64 - Bitboards.CountBits(occupancyBBs[i]);
}
return(result);
}
public int EvaluateSliders(ref Position position, int color, int pieceType)
{
Bitboard sliders = position.GetPieceBitboard(color, pieceType);
int score = 0;
while (sliders != 0)
{
int sliderSquare = sliders.BitScanForward();
Bitboards.PopLsb(ref sliders);
EvaluateSlider(ref position, ref color, ref pieceType, ref sliderSquare, ref score);
}
return(score);
}
public int EvaluateKnights(ref Position position, int color)
{
Bitboard knights = position.GetPieceBitboard(color, Position.KNIGHT);
int score = 0;
while (knights != 0)
{
int knightSquare = knights.BitScanForward();
Bitboards.PopLsb(ref knights);
EvaluateKnight(ref position, ref knightSquare, ref color, ref score);
}
return(score);
}
public int EvaluateKnights(Position position, int color, int mobilityMultiplier, ref Bitboard destinationBitboard)
{
Bitboard pieces = position.GetPieceBitboard(color, Position.KNIGHT);
int score = 0;
while (pieces != 0)
{
score += 300; // Material value
int square = pieces.BitScanForward();
Bitboards.PopLsb(ref pieces);
score += mobilityMultiplier * (Bitboards.CountBits(destinationBitboard & Bitboards.KnightBitboards[square]));
}
return(score);
}
public void CalculatesCorrectly()
{
Bitboard occupancyBitboard = 0x2C479CB67DA469UL;
int square = Position.G1;
Assert.AreEqual(0x202020DUL, Bitboards.GetRookMoveBitboard(square, occupancyBitboard));
occupancyBitboard = 0xC5C100D915991UL;
square = Position.B4;
Assert.AreEqual(0x4040B8404000UL, Bitboards.GetRookMoveBitboard(square, occupancyBitboard));
occupancyBitboard = 0;
square = Position.E8;
Assert.AreEqual(0xF708080808080808UL, Bitboards.GetRookMoveBitboard(square, occupancyBitboard));
}
public void CalculatesCorrectly()
{
Bitboard occupancyBitboard = 0x780B2201E661F5UL;
int square = Position.D3;
Assert.AreEqual(0x824428002804UL, Bitboards.GetBishopMoveBitboard(square, occupancyBitboard));
occupancyBitboard = 0x2103A24FEA64C6D8UL;
square = Position.A1;
Assert.AreEqual(0x4000UL, Bitboards.GetBishopMoveBitboard(square, occupancyBitboard));
occupancyBitboard = 0x356A829C31CABB6AUL;
square = Position.D5;
Assert.AreEqual(0x244280028040200UL, Bitboards.GetBishopMoveBitboard(square, occupancyBitboard));
}
public void SetAllSquares()
{
view.ResetSquares();
for (int color = 0; color < 2; color++)
{
for (int piece = 0; piece < 6; piece++)
{
Bitboard b = model.GetPieceBitboard(color, piece);
while (b != 0)
{
int square = b.BitScanForward();
Bitboards.PopLsb(ref b);
view.SetPiece(square, color, piece);
}
}
}
}
public int EvaluatePosition(Position position)
{
int score = 0;
Bitboard notWhite = ~position.GetPieceBitboard(Position.WHITE, Position.ALL_PIECES);
Bitboard notBlack = ~position.GetPieceBitboard(Position.BLACK, Position.ALL_PIECES);
// King mobility
int whiteKingSquare = Bitboards.BitScanForward(position.GetPieceBitboard(Position.WHITE, Position.KING));
int blackKingSquare = Bitboards.BitScanForward(position.GetPieceBitboard(Position.BLACK, Position.KING));
int whiteKing = Bitboards.CountBits(notWhite & Bitboards.KingBitboards[whiteKingSquare]);
int blackKing = Bitboards.CountBits(notBlack & Bitboards.KingBitboards[blackKingSquare]);
// Queen evalution
int whiteQueen = EvaluateSlidingPiece(position, Position.WHITE, Position.QUEEN, 900, 1, ref notWhite);
int blackQueen = EvaluateSlidingPiece(position, Position.BLACK, Position.QUEEN, 900, 1, ref notBlack);
// Rook Evaluation
int whiteRook = EvaluateSlidingPiece(position, Position.WHITE, Position.ROOK, 500, 3, ref notWhite);
int blackRook = EvaluateSlidingPiece(position, Position.BLACK, Position.ROOK, 500, 3, ref notBlack);
// Bishop Evaluation
int whiteBishop = EvaluateSlidingPiece(position, Position.WHITE, Position.BISHOP, 325, 8, ref notWhite);
int blackBishop = EvaluateSlidingPiece(position, Position.BLACK, Position.BISHOP, 325, 8, ref notBlack);
// Knight Evaluation
int whiteKnight = EvaluateKnights(position, Position.WHITE, 8, ref notWhite);
int blackKnight = EvaluateKnights(position, Position.BLACK, 8, ref notBlack);
// For now, do not include pawn mobility
int whitePawn = 100 * Bitboards.CountBits(position.GetPieceBitboard(Position.WHITE, Position.PAWN));
int blackPawn = 100 * Bitboards.CountBits(position.GetPieceBitboard(Position.BLACK, Position.PAWN));
score = whitePawn + whiteKnight + whiteBishop + whiteRook + whiteQueen + whiteKing;
score -= (blackPawn + blackKnight + blackBishop + blackRook + blackQueen + blackKing);
if (position.PlayerToMove == Position.BLACK)
{
score *= -1;
}
return(score);
}
public int EvaluatePawnStructure(Position position, int color)
{
int score = 0;
Bitboard myPawns = position.GetPieceBitboard(color, Position.PAWN);
Bitboard opponentPawns =
position.GetPieceBitboard(color == Position.WHITE ? Position.BLACK : Position.WHITE, Position.PAWN);
Bitboard allPawns = myPawns | opponentPawns;
Bitboard pawns = myPawns;
while (pawns != 0)
{
int currSquare = pawns.BitScanForward();
Bitboards.PopLsb(ref pawns);
// Add bonus based on file of pawn (to promote taking towards the center)
score += pawnFileBonus[Bitboards.GetColumn(currSquare)];
// Analyze stacked pawns
Bitboard filePawns = Bitboards.ColumnBitboards[currSquare] & myPawns;
if ((filePawns & (filePawns - 1)) != 0) // More than 1 pawn in this rank
{
score -= stackedPawnPenalty;
}
// Analyze isolated pawns
if ((Bitboards.IsolatedPawnBitboards[currSquare] & myPawns) == 0)
{
score -= isolatedPawnPenalty;
}
// Analyze passed pawns
if ((Bitboards.PassedPawnBitboards[color, currSquare] & allPawns) == 0)
{
score += passedPawnBonus[color, Bitboards.GetRow(currSquare)];
}
}
return(score);
}
public int EvaluatePosition(Position position)
{
int score = 0;
Bitboard notWhite = ~position.GetPieceBitboard(Position.WHITE, Position.ALL_PIECES);
Bitboard notBlack = ~position.GetPieceBitboard(Position.BLACK, Position.ALL_PIECES);
// King mobility
int whiteKingSquare = Bitboards.BitScanForward(position.GetPieceBitboard(Position.WHITE, Position.KING));
int blackKingSquare = Bitboards.BitScanForward(position.GetPieceBitboard(Position.BLACK, Position.KING));
int whiteKing = Bitboards.CountBits(notWhite & Bitboards.KingBitboards[whiteKingSquare]);
int blackKing = Bitboards.CountBits(notBlack & Bitboards.KingBitboards[blackKingSquare]);
// Queen evalution
int whiteQueen = EvaluateSliders(ref position, Position.WHITE, Position.QUEEN);
int blackQueen = EvaluateSliders(ref position, Position.BLACK, Position.QUEEN);
// Rook Evaluation
int whiteRook = EvaluateSliders(ref position, Position.WHITE, Position.ROOK);
int blackRook = EvaluateSliders(ref position, Position.BLACK, Position.ROOK);
// Bishop Evaluation
int whiteBishop = EvaluateSliders(ref position, Position.WHITE, Position.BISHOP);
int blackBishop = EvaluateSliders(ref position, Position.BLACK, Position.BISHOP);
// Knight Evaluation
int whiteKnight = EvaluateKnights(ref position, Position.WHITE);
int blackKnight = EvaluateKnights(ref position, Position.BLACK);
int whitePawn = EvaluatePawns(ref position, Position.WHITE);
int blackPawn = EvaluatePawns(ref position, Position.BLACK);
score = whitePawn + whiteKnight + whiteBishop + whiteRook + whiteQueen + whiteKing;
score -= (blackPawn + blackKnight + blackBishop + blackRook + blackQueen + blackKing);
if (position.PlayerToMove == Position.BLACK)
{
score *= -1;
}
return(score);
}
public void CalculatesCorrectly()
{
Assert.AreEqual(Position.C1, Bitboards.BitScanForward(0x3789237839373920UL));
Assert.AreEqual(Position.H5, Bitboards.BitScanForward(0x3578900000000UL));
}
public void CalculatesCorrectly()
{
Assert.AreEqual(10, Bitboards.CountBits(0x3578900000000UL));
Assert.AreEqual(0, Bitboards.CountBits(0));
Assert.AreEqual(64, Bitboards.CountBits(0xFFFFFFFFFFFFFFFFUL));
}
public void CalculatesCorrectly()
{
Assert.AreEqual("a8", Bitboards.GetNameFromSquare(Position.A8));
Assert.AreEqual("d4", Bitboards.GetNameFromSquare(Position.D4));
Assert.AreEqual("g6", Bitboards.GetNameFromSquare(Position.G6));
}
