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)); }