public static List <KingBitBoard> KingBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
List <KingBitBoard> result = new List <KingBitBoard>();
KingBitBoard legalWhiteKingMoves = new KingBitBoard(ChessPieceColors.White);
KingBitBoard legalBlackKingMoves = new KingBitBoard(ChessPieceColors.Black);
List <KingBitBoard> sepKingsOutput = new List <KingBitBoard>();
if (color == ChessPieceColors.White)
{
legalWhiteKingMoves = ComputeWhiteKing(inputChessBoard.WhiteKing, inputChessBoard, blackPieces, whitePieces, allPieces);
sepKingsOutput = ColoredBitBoard.SplitBitBoard(legalWhiteKingMoves).ToList();
foreach (KingBitBoard sepKBB in sepKingsOutput)
{
result.Add(sepKBB);
}
_numberOfWhiteKingMoves = result.Count;
}
else
{
legalBlackKingMoves = ComputeBlackKing(inputChessBoard.BlackKing, inputChessBoard, blackPieces, whitePieces, allPieces);
sepKingsOutput = ColoredBitBoard.SplitBitBoard(legalBlackKingMoves).ToList();
foreach (KingBitBoard sepKBB in sepKingsOutput)
{
result.Add(sepKBB);
}
_numberOfBlackKingMoves = result.Count;
}
return(result);
}
public void SplitBitboard_IfCountZero_Equal()
{
PawnBitBoard bb = new PawnBitBoard(ChessPieceColors.Black);
bb.Bits = 0x0;
PawnBitBoard[] bbArr = new PawnBitBoard[0];
Assert.Equal(bbArr, ColoredBitBoard.SplitBitBoard(bb));
}
public static List <BishopBitBoard> BishopBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
List <BishopBitBoard> result = new List <BishopBitBoard>();
List <Tuple <BishopBitBoard, BishopBitBoard> > legalBishopMoves = new List <Tuple <BishopBitBoard, BishopBitBoard> >();
List <BishopBitBoard> sepBishopsInput = new List <BishopBitBoard>();
List <BishopBitBoard> sepBishopsOutput = new List <BishopBitBoard>();
if (color == ChessPieceColors.White)
{
sepBishopsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.WhiteBishop).ToList();
foreach (BishopBitBoard sepBishopBB in sepBishopsInput)
{
legalBishopMoves.Add(new Tuple <BishopBitBoard, BishopBitBoard>(sepBishopBB, ComputeWhiteBishop(sepBishopBB, whitePieces, allPieces)));
}
for (int i = 0; i < legalBishopMoves.Count; i++)
{
sepBishopsOutput = ColoredBitBoard.SplitBitBoard(legalBishopMoves[i].Item2).ToList();
foreach (BishopBitBoard sepBishopOutBB in sepBishopsOutput)
{
BishopBitBoard boardResult = new BishopBitBoard(color);
boardResult.Bits = (inputChessBoard.WhiteBishop.Bits ^ legalBishopMoves[i].Item1.Bits) | sepBishopOutBB.Bits;
result.Add(boardResult);
}
}
}
else
{
sepBishopsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.BlackBishop).ToList();
foreach (BishopBitBoard sepBishopBB in sepBishopsInput)
{
legalBishopMoves.Add(new Tuple <BishopBitBoard, BishopBitBoard>(sepBishopBB, ComputeBlackBishop(sepBishopBB, blackPieces, allPieces)));
}
for (int i = 0; i < legalBishopMoves.Count; i++)
{
sepBishopsOutput = ColoredBitBoard.SplitBitBoard(legalBishopMoves[i].Item2).ToList();
foreach (BishopBitBoard sepBishopOutBB in sepBishopsOutput)
{
BishopBitBoard boardResult = new BishopBitBoard(color);
boardResult.Bits = (inputChessBoard.BlackBishop.Bits ^ legalBishopMoves[i].Item1.Bits) | sepBishopOutBB.Bits;
result.Add(boardResult);
}
}
}
return(result);
}
public static List <KnightBitBoard> KnightBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
List <KnightBitBoard> result = new List <KnightBitBoard>();
List <Tuple <KnightBitBoard, KnightBitBoard> > legalKnightMoves = new List <Tuple <KnightBitBoard, KnightBitBoard> >();
List <KnightBitBoard> sepKnightsInput = new List <KnightBitBoard>();
List <KnightBitBoard> sepKnightsOutput = new List <KnightBitBoard>();
if (color == ChessPieceColors.White)
{
sepKnightsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.WhiteKnight).ToList();
foreach (KnightBitBoard sepKnightBB in sepKnightsInput)
{
legalKnightMoves.Add(new Tuple <KnightBitBoard, KnightBitBoard>(sepKnightBB, ComputeWhiteKnight(inputChessBoard, sepKnightBB, blackPieces, whitePieces, allPieces)));
}
for (int i = 0; i < legalKnightMoves.Count; i++)
{
sepKnightsOutput = ColoredBitBoard.SplitBitBoard(legalKnightMoves[i].Item2).ToList();
foreach (KnightBitBoard sepKnightOutBB in sepKnightsOutput)
{
KnightBitBoard boardResult = new KnightBitBoard(color);
boardResult.Bits = (inputChessBoard.WhiteKnight.Bits ^ legalKnightMoves[i].Item1.Bits) | sepKnightOutBB.Bits;
result.Add(boardResult);
}
}
}
else
{
sepKnightsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.BlackKnight).ToList();
foreach (KnightBitBoard sepKnightBB in sepKnightsInput)
{
legalKnightMoves.Add(new Tuple <KnightBitBoard, KnightBitBoard>(sepKnightBB, ComputeBlackKnight(inputChessBoard, sepKnightBB, blackPieces, whitePieces, allPieces)));
}
for (int i = 0; i < legalKnightMoves.Count; i++)
{
sepKnightsOutput = ColoredBitBoard.SplitBitBoard(legalKnightMoves[i].Item2).ToList();
foreach (KnightBitBoard sepKnightOutBB in sepKnightsOutput)
{
KnightBitBoard boardResult = new KnightBitBoard(color);
boardResult.Bits = (inputChessBoard.BlackKnight.Bits ^ legalKnightMoves[i].Item1.Bits) | sepKnightOutBB.Bits;
result.Add(boardResult);
}
}
}
return(result);
}
public void SplitBitboard_UseCase_Equal()
{
PawnBitBoard bb = new PawnBitBoard(ChessPieceColors.Black);
bb.Bits = BoardSquare.H1 | BoardSquare.G1 | BoardSquare.E1;
PawnBitBoard bb_1 = new PawnBitBoard(ChessPieceColors.Black);
bb_1.Bits = BoardSquare.H1;
PawnBitBoard bb_2 = new PawnBitBoard(ChessPieceColors.Black);
bb_2.Bits = BoardSquare.G1;
PawnBitBoard bb_4 = new PawnBitBoard(ChessPieceColors.Black);
bb_4.Bits = BoardSquare.E1;
IEnumerable <BitBoard> splits = ColoredBitBoard.SplitBitBoard(bb);
Assert.Equal(3, splits.Count());
Assert.Contains(bb_1, splits, new BitBoardEqualityComparer());
Assert.Contains(bb_2, splits, new BitBoardEqualityComparer());
Assert.Contains(bb_4, splits, new BitBoardEqualityComparer());
}
public static List <PawnBitBoard> PawnBitBoardResults(ChessBoard inputChessBoard, ChessPieceColors color, BitBoard blackPieces, BitBoard whitePieces, BitBoard allPieces)
{
List <PawnBitBoard> result = new List <PawnBitBoard>();
List <Tuple <PawnBitBoard, PawnBitBoard> > legalPawnMoves = new List <Tuple <PawnBitBoard, PawnBitBoard> >();
List <PawnBitBoard> sepPawnsInput = new List <PawnBitBoard>();
List <PawnBitBoard> sepPawnsOutput = new List <PawnBitBoard>();
if (color == ChessPieceColors.White)
{
sepPawnsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.WhitePawn).ToList();
foreach (PawnBitBoard spb in sepPawnsInput)
{
var newMove = new Tuple <PawnBitBoard, PawnBitBoard>(spb, ComputeWhitePawn(spb, inputChessBoard, blackPieces, whitePieces, allPieces));
legalPawnMoves.Add(newMove);
}
for (int i = 0; i < legalPawnMoves.Count; i++)
{
sepPawnsOutput = ColoredBitBoard.SplitBitBoard(legalPawnMoves[i].Item2).ToList();
foreach (PawnBitBoard sepPBB in sepPawnsOutput)
{
if ((sepPBB.Bits & (BoardSquare)MoveGenUtils.RANK_8) != BoardSquare.Empty)
{
PawnBitBoard boardResult_B = new PawnBitBoard(color);
PawnBitBoard boardResult_R = new PawnBitBoard(color);
PawnBitBoard boardResult_N = new PawnBitBoard(color);
PawnBitBoard boardResult_Q = new PawnBitBoard(color);
boardResult_B.Bits = sepPBB.Bits;
boardResult_R.Bits = sepPBB.Bits;
boardResult_N.Bits = sepPBB.Bits;
boardResult_Q.Bits = sepPBB.Bits;
boardResult_B.Promote(PawnBitBoard.PromotionPiece.Bishop);
boardResult_R.Promote(PawnBitBoard.PromotionPiece.Rook);
boardResult_N.Promote(PawnBitBoard.PromotionPiece.Knight);
boardResult_Q.Promote(PawnBitBoard.PromotionPiece.Queen);
boardResult_B.Bits = (inputChessBoard.WhitePawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_R.Bits = (inputChessBoard.WhitePawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_N.Bits = (inputChessBoard.WhitePawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_Q.Bits = (inputChessBoard.WhitePawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
result.Add(boardResult_B);
result.Add(boardResult_R);
result.Add(boardResult_N);
result.Add(boardResult_Q);
}
else
{
PawnBitBoard boardResult = new PawnBitBoard(color);
boardResult.Bits = (inputChessBoard.WhitePawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
var oldBoard = inputChessBoard.GetOldBitBoardFromBitBoard(inputChessBoard.WhitePawn);
BoardSquare bitsDiff = (BoardSquare)((ulong)oldBoard.Bits ^ (ulong)boardResult.Bits);
System.Diagnostics.Debug.Assert(new EmptyBitBoard((BoardSquare)((ulong)oldBoard.Bits ^ (ulong)boardResult.Bits)).Count == 2, "More than one piece moved");
result.Add(boardResult);
}
}
}
}
else
{
sepPawnsInput = ColoredBitBoard.SplitBitBoard(inputChessBoard.BlackPawn).ToList();
foreach (PawnBitBoard spb in sepPawnsInput)
{
legalPawnMoves.Add(new Tuple <PawnBitBoard, PawnBitBoard>(spb, ComputeBlackPawn(spb, inputChessBoard, blackPieces, whitePieces, allPieces)));
}
for (int i = 0; i < legalPawnMoves.Count; i++)
{
sepPawnsOutput = ColoredBitBoard.SplitBitBoard(legalPawnMoves[i].Item2).ToList();
foreach (PawnBitBoard sepPBB in sepPawnsOutput)
{
if ((sepPBB.Bits & (BoardSquare)MoveGenUtils.RANK_1) != BoardSquare.Empty)
{
PawnBitBoard boardResult_B = new PawnBitBoard(color);
PawnBitBoard boardResult_R = new PawnBitBoard(color);
PawnBitBoard boardResult_N = new PawnBitBoard(color);
PawnBitBoard boardResult_Q = new PawnBitBoard(color);
boardResult_B.Bits = sepPBB.Bits;
boardResult_R.Bits = sepPBB.Bits;
boardResult_N.Bits = sepPBB.Bits;
boardResult_Q.Bits = sepPBB.Bits;
boardResult_B.Promote(PawnBitBoard.PromotionPiece.Bishop);
boardResult_R.Promote(PawnBitBoard.PromotionPiece.Rook);
boardResult_N.Promote(PawnBitBoard.PromotionPiece.Knight);
boardResult_Q.Promote(PawnBitBoard.PromotionPiece.Queen);
boardResult_B.Bits = (inputChessBoard.BlackPawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_R.Bits = (inputChessBoard.BlackPawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_N.Bits = (inputChessBoard.BlackPawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
boardResult_Q.Bits = (inputChessBoard.BlackPawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
result.Add(boardResult_B);
result.Add(boardResult_R);
result.Add(boardResult_N);
result.Add(boardResult_Q);
}
else
{
PawnBitBoard boardResult = new PawnBitBoard(color);
boardResult.Bits = (inputChessBoard.BlackPawn.Bits ^ legalPawnMoves[i].Item1.Bits) | sepPBB.Bits;
result.Add(boardResult);
}
}
}
}
return(result);
}
public void SplitBitboard_IfInputNull_Exception()
{
PawnBitBoard bb = null;
Assert.Throws <BitBoard.BitboardException>((Assert.ThrowsDelegate)(() => ColoredBitBoard.SplitBitBoard(bb)));
}
