public void Count_UseCase_Equal()
{
EmptyBitBoard bb = new EmptyBitBoard();
bb.Bits = BoardSquare.H1 | BoardSquare.A8;
Assert.Equal(2, bb.Count); //General case
}
private static bool isOwnKingAttackable(ChessBoard cb, ColoredBitBoard legalMove, ChessPieceColors color)
{
List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
EmptyBitBoard blackPieces = new EmptyBitBoard();
EmptyBitBoard whitePieces = new EmptyBitBoard();
EmptyBitBoard allPieces = new EmptyBitBoard();
cb.Update(legalMove);
blackPieces = MoveGenUtils.SetBlackBoard(cb);
whitePieces = MoveGenUtils.SetWhiteBoard(cb);
allPieces = MoveGenUtils.SetWholeBoard(cb);
legalMoves.AddRange(GeneratePseudoLegalNonSlidingMoves(cb, color, blackPieces, whitePieces, allPieces));
legalMoves.AddRange(GeneratePseudoLegalSlidingMoves(cb, color, blackPieces, whitePieces, allPieces));
foreach (ColoredBitBoard cbb in legalMoves)
{
if (color == ChessPieceColors.White && (cb.BlackKing.Bits & cbb.Bits) != 0)
{
cb.Undo();
return(true);
}
else if (color == ChessPieceColors.Black && (cb.WhiteKing.Bits & cbb.Bits) != 0)
{
cb.Undo();
return(true);
}
}
cb.Undo();
return(false);
}
public void Handler_IsFirstMoveGoHandledCorrectly_NotEqual()
{
Winboard winboard = new Winboard();
winboard.Handler("new");
EmptyBitBoard WhitePieceStartPlacement = new EmptyBitBoard();
WhitePieceStartPlacement.Bits =
winboard.chessBoard.WhitePawn.Bits |
winboard.chessBoard.WhiteKnight.Bits |
winboard.chessBoard.WhiteBishop.Bits |
winboard.chessBoard.WhiteRook.Bits |
winboard.chessBoard.WhiteQueen.Bits |
winboard.chessBoard.WhiteKing.Bits;
winboard.Handler("go");
EmptyBitBoard WhitePieceAfterMovePlacement = new EmptyBitBoard();
WhitePieceAfterMovePlacement.Bits =
winboard.chessBoard.WhitePawn.Bits |
winboard.chessBoard.WhiteKnight.Bits |
winboard.chessBoard.WhiteBishop.Bits |
winboard.chessBoard.WhiteRook.Bits |
winboard.chessBoard.WhiteQueen.Bits |
winboard.chessBoard.WhiteKing.Bits;
Assert.NotEqual(WhitePieceStartPlacement.Bits, WhitePieceAfterMovePlacement.Bits);
}
public void Count_BoundaryMax_Equal()
{
EmptyBitBoard bb = new EmptyBitBoard();
bb.Bits = BoardSquare.A8;
Assert.Equal(1, bb.Count); //Boundary max case
}
public void Count_BoundaryMin_Equal()
{
EmptyBitBoard bb = new EmptyBitBoard();
bb.Bits = 0x0; //Empty bitboard
Assert.Equal(0, bb.Count); //Boundary min case
}
public static EmptyBitBoard SetWholeBoard(ChessBoard cb)
{
EmptyBitBoard result = new EmptyBitBoard();
result.Bits = (cb.WhiteBishop.Bits | cb.WhiteKing.Bits | cb.WhiteKnight.Bits | cb.WhitePawn.Bits | cb.WhiteQueen.Bits | cb.WhiteRook.Bits | cb.BlackBishop.Bits | cb.BlackKing.Bits | cb.BlackKnight.Bits | cb.BlackPawn.Bits | cb.BlackQueen.Bits | cb.BlackRook.Bits);
return(result);
}
public void Handler_IsBlackCorrectlyPlaced_NotEqual()
{
Winboard winboard = new Winboard();
winboard.Handler("new");
EmptyBitBoard BlackPieceStartPlacement = new EmptyBitBoard();
BlackPieceStartPlacement.Bits =
winboard.chessBoard.BlackPawn.Bits |
winboard.chessBoard.BlackKnight.Bits |
winboard.chessBoard.BlackBishop.Bits |
winboard.chessBoard.BlackRook.Bits |
winboard.chessBoard.BlackQueen.Bits |
winboard.chessBoard.BlackKing.Bits;
winboard.Handler("e2e4");
winboard.Handler("e4e5");
EmptyBitBoard BlackPieceAfterMovePlacement = new EmptyBitBoard();
BlackPieceAfterMovePlacement.Bits =
winboard.chessBoard.BlackPawn.Bits |
winboard.chessBoard.BlackKnight.Bits |
winboard.chessBoard.BlackBishop.Bits |
winboard.chessBoard.BlackRook.Bits |
winboard.chessBoard.BlackQueen.Bits |
winboard.chessBoard.BlackKing.Bits;
Assert.NotEqual(BlackPieceStartPlacement.Bits, BlackPieceAfterMovePlacement.Bits);
}
public void MinimumRaisedBit_IsCorrectBitBoardReturned_Equal()
{
EmptyBitBoard board = new EmptyBitBoard();
board.Bits = BoardSquare.A8 | BoardSquare.B7 | BoardSquare.C6 | BoardSquare.F3;
BoardSquare correctBitBoard = BoardSquare.F3;
Assert.Equal(correctBitBoard, board.MinimumRaisedBit);
}
public void MaximumRaisedBit_IsEmptyBitBoardReturned_Equal()
{
EmptyBitBoard board = new EmptyBitBoard();
board.Bits = BoardSquare.Empty;
BoardSquare correctBitBoard = BoardSquare.Empty;
Assert.Equal(correctBitBoard, board.MaximumRaisedBit);
}
public static int GetIndexFromBoardSquare(BoardSquare square)
{
var eb = new EmptyBitBoard();
eb.Bits = square;
System.Diagnostics.Debug.Assert(eb.Count == 1);
ulong nb = (ulong)square;
return(Convert.ToInt32(Math.Log((double)square, 2)));
}
public void Clear_IsBitBoardCleared_Equal()
{
EmptyBitBoard board = new EmptyBitBoard();
board.Bits = BoardSquare.Full;
board.Clear();
BoardSquare correctBitBoard = BoardSquare.Empty;
Assert.Equal(correctBitBoard, board.Bits);
}
private static bool isEnemyKingAttackable(ChessBoard cb, ColoredBitBoard legalMove, ChessPieceColors color)
{
List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
EmptyBitBoard blackPieces = new EmptyBitBoard();
EmptyBitBoard whitePieces = new EmptyBitBoard();
EmptyBitBoard allPieces = new EmptyBitBoard();
cb.Update(legalMove);
blackPieces = MoveGenUtils.SetBlackBoard(cb);
whitePieces = MoveGenUtils.SetWhiteBoard(cb);
allPieces = MoveGenUtils.SetWholeBoard(cb);
if (legalMove is PawnBitBoard)
{
legalMoves.AddRange(PawnMoveGen.PawnBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
else if (legalMove is BishopBitBoard)
{
legalMoves.AddRange(BishopMoveGen.BishopBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
else if (legalMove is KingBitBoard)
{
legalMoves.AddRange(KingMoveGen.KingBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
else if (legalMove is KnightBitBoard)
{
legalMoves.AddRange(KnightMoveGen.KnightBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
else if (legalMove is QueenBitBoard)
{
legalMoves.AddRange(QueenMoveGen.QueenBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
else if (legalMove is RookBitBoard)
{
legalMoves.AddRange(RookMoveGen.RookBitBoardResults(cb, color, blackPieces, whitePieces, allPieces));
}
foreach (ColoredBitBoard cbb in legalMoves)
{
if (color == ChessPieceColors.White && (cb.BlackKing.Bits & cbb.Bits) != 0)
{
cb.Undo();
return(true);
}
else if (color == ChessPieceColors.Black && (cb.WhiteKing.Bits & cbb.Bits) != 0)
{
cb.Undo();
return(true);
}
}
cb.Undo();
return(false);
}
private static PawnBitBoard ComputeWhitePawn(PawnBitBoard inputPawnBB, ChessBoard inputChessBoard, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
PawnBitBoard result = new PawnBitBoard(ChessPieceColors.White);
//moves
PawnBitBoard pawnOneStep = new PawnBitBoard(ChessPieceColors.White);
pawnOneStep.Bits = (BoardSquare)((ulong)inputPawnBB.Bits << 8) & ~allPieces.Bits;
PawnBitBoard pawnTwoSteps = new PawnBitBoard(ChessPieceColors.White);
if (((ulong)inputPawnBB.Bits & MoveGenUtils.RANK_2) != 0)
{
pawnTwoSteps.Bits = (BoardSquare)((ulong)pawnOneStep.Bits << 8) & ~allPieces.Bits;
}
//attacks
PawnBitBoard enPassantBB = new PawnBitBoard(ChessPieceColors.White);
PawnBitBoard pawnLeftAttack = new PawnBitBoard(ChessPieceColors.White);
PawnBitBoard pawnRightAttack = new PawnBitBoard(ChessPieceColors.White);
EmptyBitBoard pawnClipFILE_A = new EmptyBitBoard();
EmptyBitBoard pawnClipFILE_H = new EmptyBitBoard();
pawnClipFILE_A.Bits = (BoardSquare)((ulong)inputPawnBB.Bits & ~MoveGenUtils.FILE_A);
pawnClipFILE_H.Bits = (BoardSquare)((ulong)inputPawnBB.Bits & ~MoveGenUtils.FILE_H);
pawnLeftAttack.Bits = (BoardSquare)(((ulong)pawnClipFILE_A.Bits << 9) & (ulong)blackPieces.Bits);
pawnRightAttack.Bits = (BoardSquare)(((ulong)pawnClipFILE_H.Bits << 7) & (ulong)blackPieces.Bits);
//enPassantBB = PawnBitBoard.EnPassant();
if (inputChessBoard.BlackPawn.MovedTwoSquares != BoardSquare.Empty)
{
BoardSquare enemyPawn = new BoardSquare();
enemyPawn = inputChessBoard.BlackPawn.MovedTwoSquares;
if ((((ulong)inputPawnBB.Bits << 1) == (ulong)enemyPawn) && (((ulong)enemyPawn & MoveGenUtils.FILE_H) == 0))
{
enPassantBB.Bits = (BoardSquare)((ulong)inputPawnBB.Bits << 9);
}
if ((((ulong)inputPawnBB.Bits >> 1) == (ulong)enemyPawn) && (((ulong)enemyPawn & MoveGenUtils.FILE_A) == 0))
{
enPassantBB.Bits = (BoardSquare)((ulong)inputPawnBB.Bits << 7);
}
}
result.Bits = pawnOneStep.Bits | pawnTwoSteps.Bits | pawnLeftAttack.Bits | pawnRightAttack.Bits | enPassantBB.Bits;
return(result);
}
public static List <ColoredBitBoard> GenerateLegalMoves(ChessBoard inputChessBoard, ChessPieceColors color)
{
List <ColoredBitBoard> result = new List <ColoredBitBoard>();
EmptyBitBoard blackPieces = MoveGenUtils.SetBlackBoard(inputChessBoard);
EmptyBitBoard whitePieces = MoveGenUtils.SetWhiteBoard(inputChessBoard);
EmptyBitBoard allPieces = MoveGenUtils.SetWholeBoard(inputChessBoard);
result.AddRange(GeneratePseudoLegalNonSlidingMoves(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result.AddRange(GeneratePseudoLegalSlidingMoves(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result = RemoveOwnKingChecks(inputChessBoard, result, color);
result = SetDoesCheck(inputChessBoard, result, color);
var sortedMoves = MoveGenUtils.SortMoves(result, inputChessBoard, blackPieces, whitePieces);
return(sortedMoves);
}
private static KingBitBoard ComputeBlackKing(KingBitBoard inputKingBB, ChessBoard inputChessBoard, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
KingBitBoard result = new KingBitBoard(ChessPieceColors.Black);
EmptyBitBoard kingClipFILE_H = new EmptyBitBoard();
EmptyBitBoard kingClipFILE_A = new EmptyBitBoard();
EmptyBitBoard spot1 = new EmptyBitBoard();
EmptyBitBoard spot2 = new EmptyBitBoard();
EmptyBitBoard spot3 = new EmptyBitBoard();
EmptyBitBoard spot4 = new EmptyBitBoard();
EmptyBitBoard spot5 = new EmptyBitBoard();
EmptyBitBoard spot6 = new EmptyBitBoard();
EmptyBitBoard spot7 = new EmptyBitBoard();
EmptyBitBoard spot8 = new EmptyBitBoard();
EmptyBitBoard castling = new EmptyBitBoard();
kingClipFILE_A.Bits = (BoardSquare)((ulong)inputKingBB.Bits & ~MoveGenUtils.FILE_A);
kingClipFILE_H.Bits = (BoardSquare)((ulong)inputKingBB.Bits & ~MoveGenUtils.FILE_H);
spot1.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits << 9);
spot2.Bits = (BoardSquare)((ulong)inputKingBB.Bits << 8);
spot3.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits << 7);
spot4.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits >> 1);
spot5.Bits = (BoardSquare)((ulong)kingClipFILE_H.Bits >> 9);
spot6.Bits = (BoardSquare)((ulong)inputKingBB.Bits >> 8);
spot7.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits >> 7);
spot8.Bits = (BoardSquare)((ulong)kingClipFILE_A.Bits << 1);
if (!inputKingBB.HasMoved)
{
if (!inputChessBoard.BlackRook.HasMovedKingSide && ((ulong)(BoardSquare.F8 | BoardSquare.G8) & (ulong)blackPieces.Bits) == 0)
{
castling.Bits = (BoardSquare)((ulong)inputKingBB.Bits >> 2);
}
else if (!inputChessBoard.BlackRook.HasMovedQueenSide && ((ulong)(BoardSquare.D8 | BoardSquare.C8 | BoardSquare.B8) & (ulong)blackPieces.Bits) == 0)
{
castling.Bits = (BoardSquare)((ulong)inputKingBB.Bits << 2);
}
}
result.Bits = spot1.Bits | spot2.Bits | spot3.Bits | spot4.Bits | spot5.Bits | spot6.Bits | spot7.Bits | spot8.Bits | castling.Bits;
result.Bits = result.Bits & ~blackPieces.Bits;
return(result);
}
private static KnightBitBoard ComputeBlackKnight(ChessBoard inputChessBoard, BitBoard inputKnightBB, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
KnightBitBoard result = new KnightBitBoard(ChessPieceColors.Black);
EmptyBitBoard spot1_clip = new EmptyBitBoard();
EmptyBitBoard spot2_clip = new EmptyBitBoard();
EmptyBitBoard spot3_clip = new EmptyBitBoard();
EmptyBitBoard spot4_clip = new EmptyBitBoard();
EmptyBitBoard spot5_clip = new EmptyBitBoard();
EmptyBitBoard spot6_clip = new EmptyBitBoard();
EmptyBitBoard spot7_clip = new EmptyBitBoard();
EmptyBitBoard spot8_clip = new EmptyBitBoard();
EmptyBitBoard spot1 = new EmptyBitBoard();
EmptyBitBoard spot2 = new EmptyBitBoard();
EmptyBitBoard spot3 = new EmptyBitBoard();
EmptyBitBoard spot4 = new EmptyBitBoard();
EmptyBitBoard spot5 = new EmptyBitBoard();
EmptyBitBoard spot6 = new EmptyBitBoard();
EmptyBitBoard spot7 = new EmptyBitBoard();
EmptyBitBoard spot8 = new EmptyBitBoard();
spot1_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_A);
spot2_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_H);
spot3_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_G & ~MoveGenUtils.FILE_H);
spot4_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_G & ~MoveGenUtils.FILE_H);
spot5_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_H);
spot6_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_A);
spot7_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_A & ~MoveGenUtils.FILE_B);
spot8_clip.Bits = (BoardSquare)((ulong)inputKnightBB.Bits & ~MoveGenUtils.FILE_A & ~MoveGenUtils.FILE_B);
spot1.Bits = (BoardSquare)((ulong)spot1_clip.Bits << 17);
spot2.Bits = (BoardSquare)((ulong)spot2_clip.Bits << 15);
spot3.Bits = (BoardSquare)((ulong)spot3_clip.Bits << 6);
spot4.Bits = (BoardSquare)((ulong)spot4_clip.Bits >> 10);
spot5.Bits = (BoardSquare)((ulong)spot5_clip.Bits >> 17);
spot6.Bits = (BoardSquare)((ulong)spot6_clip.Bits >> 15);
spot7.Bits = (BoardSquare)((ulong)spot7_clip.Bits >> 6);
spot8.Bits = (BoardSquare)((ulong)spot8_clip.Bits << 10);
result.Bits = spot1.Bits | spot2.Bits | spot3.Bits | spot4.Bits | spot5.Bits | spot6.Bits | spot7.Bits | spot8.Bits;
result.Bits = result.Bits & ~blackPieces.Bits;
return(result);
}
public string ConvertBitBoardMoveToString(ColoredBitBoard bitBoard)
{
ColoredBitBoard toBitBoard = bitBoard.DeepCopy();
ColoredBitBoard fromBitBoard = _chessBoard.GetOldBitBoardFromBitBoard(toBitBoard);
System.Diagnostics.Debug.Assert(bitBoard.Bits != fromBitBoard.Bits);
EmptyBitBoard containerBitBoard = new EmptyBitBoard();
containerBitBoard.Bits = fromBitBoard.Bits;
fromBitBoard.Bits = (fromBitBoard.Bits | toBitBoard.Bits) ^ toBitBoard.Bits;
toBitBoard.Bits = (fromBitBoard.Bits | toBitBoard.Bits) ^ containerBitBoard.Bits;
string stringMove = fromBitBoard.Bits.ToString().ToLower() + toBitBoard.Bits.ToString().ToLower();
if (fromBitBoard is PawnBitBoard)
{
PawnBitBoard toPawnBitBoardPromotion = (PawnBitBoard)toBitBoard;
if (toPawnBitBoardPromotion.IsPromoted)
{
switch (toPawnBitBoardPromotion.Promotion)
{
case PawnBitBoard.PromotionPiece.Queen:
return(stringMove + "q");
case PawnBitBoard.PromotionPiece.Rook:
return(stringMove + "r");
case PawnBitBoard.PromotionPiece.Bishop:
return(stringMove + "b");
case PawnBitBoard.PromotionPiece.Knight:
return(stringMove + "n");
default:
throw new ArgumentOutOfRangeException("A promoted pawn bit board must contain a promotion type.");
}
}
}
return(stringMove);
}
private static List <ColoredBitBoard> GeneratePseudoLegalNonSlidingMoves(ChessBoard inputChessBoard, ChessPieceColors color, EmptyBitBoard blackPieces, EmptyBitBoard whitePieces, EmptyBitBoard allPieces)
{
List <ColoredBitBoard> result = new List <ColoredBitBoard>();
result.AddRange(PawnMoveGen.PawnBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result.AddRange(KingMoveGen.KingBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result.AddRange(KnightMoveGen.KnightBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
return(result);
}
private static List <ColoredBitBoard> GeneratePseudoLegalSlidingMoves(ChessBoard inputChessBoard, ChessPieceColors color, EmptyBitBoard blackPieces, EmptyBitBoard whitePieces, EmptyBitBoard allPieces)
{
List <ColoredBitBoard> result = new List <ColoredBitBoard>();
result.AddRange(RookMoveGen.RookBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result.AddRange(BishopMoveGen.BishopBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
result.AddRange(QueenMoveGen.QueenBitBoardResults(inputChessBoard, color, blackPieces, whitePieces, allPieces));
return(result);
}
