public static bool isOwnKingAttackable_TEST(ChessBoard cb, ColoredBitBoard legalMove, ChessPieceColors color)
{
bool flag;
flag = isOwnKingAttackable(cb, legalMove, color);
return(flag);
}
public void BestMoveTest_WhiteDepth2()
{
ChessBoard input = new ChessBoard();
input.InitializeScenario(new ScenarioList {
{ BoardSquare.C2, ChessPieceType.Pawn, ChessPieceColors.White },
{ BoardSquare.B3, ChessPieceType.Pawn, ChessPieceColors.Black },
{ BoardSquare.H1, ChessPieceType.King, ChessPieceColors.White },
{ BoardSquare.B4, ChessPieceType.King, ChessPieceColors.Black },
{ BoardSquare.D3, ChessPieceType.Pawn, ChessPieceColors.Black }
});
//Used for depth 2
bool depth2MoveEqual = false;
ColoredBitBoard depth2Test = NegaMax.GetBestMove(input, 2, ChessPieceColors.White, GenerateStaticMoves_Depth12, GetStaticMaterialValueDepth2_White);
PawnBitBoard optimalMove = new PawnBitBoard(ChessPieceColors.White);
optimalMove.Bits = BoardSquare.D3;
if (depth2Test is PawnBitBoard)
{
depth2Test = (PawnBitBoard)depth2Test;
if (depth2Test.Bits == optimalMove.Bits)
{
depth2MoveEqual = true;
}
}
Assert.True(depth2MoveEqual);
}
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 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 ConvertStringMoveToBitBoard_IsNullReturned_Equal()
{
ChessBoard chessBoard = new ChessBoard();
StringBitboardConverter converter = new StringBitboardConverter(chessBoard, ChessPieceColors.White);
string stringMove = "e4e5";
ColoredBitBoard correctMoveBitBoard = converter.ConvertStringMoveToBitBoard(stringMove);
Assert.Equal(null, correctMoveBitBoard);
}
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));
}
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);
}
public void Update(
ChessPieceType pieceType,
ColoredBitBoard oldBoard,
ColoredBitBoard newBoard)
{
ulong difference = (ulong)oldBoard.Bits ^ (ulong)newBoard.Bits;
ulong from = difference & (ulong)oldBoard.Bits;
ulong to = difference & (ulong)newBoard.Bits;
Update(pieceType, oldBoard.Color, (BoardSquare)to, (BoardSquare)from);
}
public void Undo_BlackRookRank2Forward_Equal()
{
ChessBoard testBoard = new ChessBoard();
testBoard.InitializeGame();
ColoredBitBoard[] InitMoves = new ColoredBitBoard[] {
new PawnBitBoard(ChessPieceColors.White),
new PawnBitBoard(ChessPieceColors.Black),
new PawnBitBoard(ChessPieceColors.White),
new RookBitBoard(ChessPieceColors.Black),
new PawnBitBoard(ChessPieceColors.White),
new RookBitBoard(ChessPieceColors.Black),
new PawnBitBoard(ChessPieceColors.White),
new RookBitBoard(ChessPieceColors.Black),
new PawnBitBoard(ChessPieceColors.White)
};
InitMoves[0].Bits = testBoard.WhitePawn.Bits ^ BoardSquare.H2 ^ BoardSquare.H4;
InitMoves[1].Bits = testBoard.BlackPawn.Bits ^ BoardSquare.A7 ^ BoardSquare.A5;
InitMoves[2].Bits = InitMoves[0].Bits ^ BoardSquare.H4 ^ BoardSquare.H5;
InitMoves[3].Bits = testBoard.BlackRook.Bits ^ BoardSquare.A8 ^ BoardSquare.A6;
InitMoves[4].Bits = InitMoves[2].Bits ^ BoardSquare.H5 ^ BoardSquare.H6;
InitMoves[5].Bits = InitMoves[3].Bits ^ BoardSquare.A6 ^ BoardSquare.D6;
InitMoves[6].Bits = InitMoves[4].Bits ^ BoardSquare.G2 ^ BoardSquare.G4;
InitMoves[7].Bits = InitMoves[5].Bits ^ BoardSquare.D6 ^ BoardSquare.D4;
InitMoves[8].Bits = InitMoves[6].Bits ^ BoardSquare.G4 ^ BoardSquare.G5;
int MoveNo = 0;
foreach (ColoredBitBoard CBB_Mobil in InitMoves)
{
ulong expectedHashKey = testBoard.BoardHash.Key;
testBoard.Update(CBB_Mobil);
testBoard.Undo();
Assert.Equal(expectedHashKey, testBoard.BoardHash.Key);
testBoard.Update(CBB_Mobil);
MoveNo++;
}
ulong expectedKey = testBoard.BoardHash.Key;
RookBitBoard move = new RookBitBoard(ChessPieceColors.Black);
move.Bits = InitMoves[7].Bits ^ BoardSquare.D4 ^ BoardSquare.D6;
testBoard.Update(move);
testBoard.Undo();
Assert.Equal(expectedKey, testBoard.BoardHash.Key);
}
public TranspositionEntry(
ulong hash,
int depth,
double score,
bool ancient,
EntryType nodeType)
{
Hash = hash;
Depth = depth;
Score = score;
Ancient = ancient;
NodeType = nodeType;
BestMove = null;
}
public TranspositionEntry(
ulong hash,
int depth,
double score,
int ancient,
TranspositionEntryType nodeType,
ColoredBitBoard move)
{
Hash = hash;
Depth = depth;
Score = score;
Ancient = ancient;
NodeType = nodeType;
Move = move;
}
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 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);
}
private static void EvalFail()
{
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A2 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.E2 | BoardSquare.F2 | BoardSquare.G2 | BoardSquare.H3;
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.D7 | BoardSquare.E7 | BoardSquare.F5 | BoardSquare.G7 | BoardSquare.H7;
lolBoard.Update(pawnWhite);
lolBoard.Update(pawnBlack);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
}
public void ConvertStringMoveToBitBoard_IsCorrectBitBoardReturned_Equals()
{
ChessBoard chessBoard = new ChessBoard();
chessBoard.BlackKnight.Bits = BoardSquare.B8 | BoardSquare.G8;
string stringMove = "b8c6";
StringBitboardConverter converter = new StringBitboardConverter(chessBoard, ChessPieceColors.Black);
ColoredBitBoard currentMoveBitBoard = converter.ConvertStringMoveToBitBoard(stringMove);
ColoredBitBoard correctMoveBitBoard = new KnightBitBoard(ChessPieceColors.Black);
correctMoveBitBoard.Bits = BoardSquare.C6 | BoardSquare.G8;
Assert.Equal(currentMoveBitBoard.GetType(), correctMoveBitBoard.GetType());
Assert.Equal(currentMoveBitBoard.Bits, correctMoveBitBoard.Bits);
}
public void Undo_WhiteRookRank2Backward_Equal()
{
ChessBoard testBoard = new ChessBoard();
testBoard.InitializeGame();
ColoredBitBoard[] InitMoves = new ColoredBitBoard[] {
new PawnBitBoard(ChessPieceColors.White),
new KnightBitBoard(ChessPieceColors.Black),
new RookBitBoard(ChessPieceColors.White),
new KnightBitBoard(ChessPieceColors.Black),
new RookBitBoard(ChessPieceColors.White),
new KnightBitBoard(ChessPieceColors.Black),
new RookBitBoard(ChessPieceColors.White),
new KnightBitBoard(ChessPieceColors.Black)
};
InitMoves[0].Bits = testBoard.WhitePawn.Bits ^ BoardSquare.H2 ^ BoardSquare.H4;
InitMoves[1].Bits = testBoard.BlackKnight.Bits ^ BoardSquare.B8 ^ BoardSquare.A6;
InitMoves[2].Bits = testBoard.WhiteRook.Bits ^ BoardSquare.H1 ^ BoardSquare.H3;
InitMoves[3].Bits = InitMoves[1].Bits ^ BoardSquare.A6 ^ BoardSquare.B8;
InitMoves[4].Bits = InitMoves[2].Bits ^ BoardSquare.H3 ^ BoardSquare.D3;
InitMoves[5].Bits = InitMoves[3].Bits ^ BoardSquare.B8 ^ BoardSquare.A6;
InitMoves[6].Bits = InitMoves[4].Bits ^ BoardSquare.D3 ^ BoardSquare.D4;
InitMoves[7].Bits = InitMoves[5].Bits ^ BoardSquare.A6 ^ BoardSquare.B8;
foreach (ColoredBitBoard CBB_Mobil in InitMoves)
{
testBoard.Update(CBB_Mobil);
}
ulong expectedKey = testBoard.BoardHash.Key;
RookBitBoard move = new RookBitBoard(ChessPieceColors.White);
move.Bits = InitMoves[6].Bits ^ BoardSquare.D4 ^ BoardSquare.D2;
testBoard.Update(move);
testBoard.Undo();
Assert.Equal(expectedKey, testBoard.BoardHash.Key);
}
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);
}
/// <summary>
/// Decides the best move for the player given by the color parameter, with a search
/// of the given depth.
/// </summary>
public static ColoredBitBoard GetBestMove(ChessBoard board, int depth, ChessPieceColors color, GenerateMoveDelegate GenerateMoves, GetMaterialDelegate GetMaterialValue)
{
Debug.Assert(board != null);
Debug.Assert(depth > 0);
Debug.Assert(GenerateMoves != null);
Debug.Assert(GetMaterialValue != null);
//Alpha, have to add one to change symbol later otherwise overflow.
double a = int.MinValue + 1;
//Beta value.
double b = int.MaxValue;
double val = 0;
ColoredBitBoard bestMove = null;
List <ColoredBitBoard> moves = GenerateMoves(board, color);
var ttEntry = new TranspositionEntry(board.BoardHash.Key, depth, val, false, EntryType.Exact);
foreach (ColoredBitBoard move in moves)
{
board.Update(move);
if (color == ChessPieceColors.Black)
{
val = -NegaMaxAlgorithm(board, depth - 1, -b, -a, ChessPieceColors.White, GenerateMoves, GetMaterialValue);
}
else if (color == ChessPieceColors.White)
{
val = -NegaMaxAlgorithm(board, depth - 1, -b, -a, ChessPieceColors.Black, GenerateMoves, GetMaterialValue);
}
if (val > a)
{
a = val;
bestMove = move;
ttEntry.BestMove = move;
ttEntry.Score = a;
}
board.Undo();
}
TranspositionTable.TranspositionCache.Add(ttEntry);
return(bestMove);
}
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());
}
private static double EvaluatePosition(ChessBoard board)
{
List <int> indexes;
double blackResult = 0;
double whiteResult = 0;
double result = 0;
List <BitBoard> blackEnumerator = new List <BitBoard>()
{
board.BlackBishop, board.BlackKing, board.BlackKnight,
board.BlackPawn, board.BlackQueen, board.BlackRook,
};
List <BitBoard> whiteEnumerator = new List <BitBoard>()
{
board.WhiteBishop, board.WhiteKing, board.WhiteKnight,
board.WhitePawn, board.WhiteQueen, board.WhiteRook,
};
foreach (ColoredBitBoard bb in blackEnumerator)
{
indexes = BitBoard.PositionIndexFromBoardSquare(ColoredBitBoard.SplitBitBoardToBoardSquares(bb).ToList());
foreach (int index in indexes)
{
blackResult += bb.PositionValues[index - 1];
}
}
foreach (ColoredBitBoard bb in whiteEnumerator)
{
indexes = BitBoard.PositionIndexFromBoardSquare(ColoredBitBoard.SplitBitBoardToBoardSquares(bb).ToList());
foreach (int index in indexes)
{
whiteResult += bb.PositionValues[index - 1];
}
}
result = whiteResult - blackResult;
return(result);
}
public static List <ColoredBitBoard> SortMovesByPV(List <ColoredBitBoard> legalMoves, ChessBoard inputChessBoard, BitBoard blackMoves, BitBoard whiteMoves)
{
TranspositionEntry entry = TranspositionTable.TranspositionCache[inputChessBoard.BoardHash.Key];
if (entry == null || entry.BestMove == null)
{
return(legalMoves);
}
ColoredBitBoard bestmove = entry.BestMove;
if (bestmove is PawnBitBoard && ((PawnBitBoard)bestmove).Color == ChessPieceColors.White && legalMoves[0].Color == ChessPieceColors.White)
{
Debug.Assert(bestmove.Bits != inputChessBoard.WhitePawn.Bits);
}
ColoredBitBoard bestmoveInLegalMoves = legalMoves.Find(p => p.Equals(bestmove));
if (bestmoveInLegalMoves != null)
{
legalMoves.Remove(bestmoveInLegalMoves);
legalMoves.Insert(0, bestmove);
}
return(legalMoves);
}
/// <summary>
/// Implementation of the NegaMax algorithm.
/// <param name="board"></param>
/// <param name="depth"></param>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="color"></param>
/// <param name="GenerateMoves"></param>
/// <param name="GetMaterialValue"></param>
/// <returns></returns>
public static double NegaMaxAlgorithm(
ChessBoard board,
int depth, double a, double b,
ChessPieceColors color,
GenerateMoveDelegate GenerateMoves,
GetMaterialDelegate GetMaterialValue
)
{
ColoredBitBoard bestMove = null;
var hashBeforeTermCondition = board.BoardHash.Key;
var termCondition = IsTerminal(board, color, GenerateMoves);
Debug.Assert(hashBeforeTermCondition == board.BoardHash.Key);
if (termCondition == TerminalConditions.Win ||
termCondition == TerminalConditions.Draw ||
depth == 0)
{
return((int)color * (GetMaterialValue(board)));
}
else
{
bool usingTT = false;
ulong hash_beforeMove = board.BoardHash.Key;
var ttEntry = TranspositionTable.TranspositionCache[board.BoardHash.Key];
if (ttEntry != null &&
ttEntry.Hash == board.BoardHash.Key &&
ttEntry.Depth >= depth
)
{
if (ttEntry.NodeType == EntryType.Alpha && ttEntry.Score <= a)
{
return(a);
}
if (ttEntry.NodeType == EntryType.Beta && ttEntry.Score >= b)
{
return(b);
}
if (ttEntry.NodeType == EntryType.Exact)
{
return(ttEntry.Score);
}
usingTT = true;
}
TranspositionEntry newEntry = new TranspositionEntry(board.BoardHash.Key, depth, 0, false, EntryType.Alpha);
List <ColoredBitBoard> moves = new List <ColoredBitBoard>();
moves = GenerateMoves(board, color);
foreach (ColoredBitBoard move in moves)
{
double val = 0;
board.Update(move);
var hashBeforeRec = board.BoardHash.Key;
if (color == ChessPieceColors.White)
{
val = -NegaMaxAlgorithm(board, depth - 1, -b, -a, ChessPieceColors.Black, GenerateMoves, GetMaterialValue);
}
else if (color == ChessPieceColors.Black)
{
val = -NegaMaxAlgorithm(board, depth - 1, -b, -a, ChessPieceColors.White, GenerateMoves, GetMaterialValue);
}
Debug.Assert(hashBeforeRec == board.BoardHash.Key);
board.Undo();
usingTT = false;
if (val >= b)
{
if (!usingTT)
{
newEntry.NodeType = EntryType.Beta;
newEntry.Score = val;
TranspositionTable.TranspositionCache.Add(newEntry);
Debug.Assert(hash_beforeMove == board.BoardHash.Key, "Board hash changed during update/undo");
}
return(val);
}
if (val >= a)
{
a = val;
bestMove = move;
newEntry.NodeType = EntryType.Exact;
}
Debug.Assert(hash_beforeMove == board.BoardHash.Key, "Board hash changed during update/undo");
}
if (!usingTT)
{
if (newEntry.NodeType == EntryType.Exact)
{
newEntry.BestMove = bestMove;
}
newEntry.Score = a;
TranspositionTable.TranspositionCache.Add(newEntry);
}
return(a);
}
}
/* private static void WinBoardCastlingFAIL( ChessBoard chessBoard, ChessPieceColors winboardColor ) {
* _winboardConverter = new StringBitboardConverter( chessBoard, winboardColor );
* ColoredBitBoard bitBoardMoveRecived = _winboardConverter.ConvertStringMoveToBitBoard( "E8G8" );
* chessBoard.Update( bitBoardMoveRecived );
* }*/
private static void FAILFAILtest()
{
ChessBoard lolboard = new ChessBoard();
lolboard.InitializeGame();
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.E4 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.H2 | BoardSquare.G2 | BoardSquare.F2 | BoardSquare.A2;
lolboard.Update(pawnWhite);
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.D7 | BoardSquare.E5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
lolboard.Update(pawnBlack);
KnightBitBoard lilleKnejtWhite = new KnightBitBoard(ChessPieceColors.White);
lilleKnejtWhite.Bits = BoardSquare.C3 | BoardSquare.G1;
lolboard.Update(lilleKnejtWhite);
KnightBitBoard lilleKnejtBlack = new KnightBitBoard(ChessPieceColors.Black);
lilleKnejtBlack.Bits = BoardSquare.C6 | BoardSquare.G8;
lolboard.Update(lilleKnejtBlack);
KnightBitBoard lilleKnejtWhitenummer2 = new KnightBitBoard(ChessPieceColors.White);
lilleKnejtWhitenummer2.Bits = BoardSquare.C3 | BoardSquare.F3;
lolboard.Update(lilleKnejtWhitenummer2);
PawnBitBoard pawnBlacknummerto = new PawnBitBoard(ChessPieceColors.Black);
pawnBlacknummerto.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.D5 | BoardSquare.E5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
lolboard.Update(pawnBlacknummerto);
//INGEN FEJL!
PawnBitBoard pawnWhitenummerto = new PawnBitBoard(ChessPieceColors.White);
pawnWhitenummerto.Bits = BoardSquare.A2 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.D5 | BoardSquare.G2 | BoardSquare.F2 | BoardSquare.H2;
lolboard.Update(pawnWhitenummerto);
//Måske fejl?
KnightBitBoard lilleKnejtBlacknummerto = new KnightBitBoard(ChessPieceColors.Black);
lilleKnejtBlacknummerto.Bits = BoardSquare.B4 | BoardSquare.G8;
lolboard.Update(lilleKnejtBlacknummerto);
KnightBitBoard lilleKnejtWhitenummer3 = new KnightBitBoard(ChessPieceColors.White);
lilleKnejtWhitenummer3.Bits = BoardSquare.C3 | BoardSquare.E5;
lolboard.Update(lilleKnejtWhitenummer3);
KnightBitBoard lilleKnejtBlacknummertre = new KnightBitBoard(ChessPieceColors.Black);
lilleKnejtBlacknummertre.Bits = BoardSquare.B4 | BoardSquare.F6;
lolboard.Update(lilleKnejtBlacknummertre);
BishopBitBoard lillebishopruner = new BishopBitBoard(ChessPieceColors.White);
lillebishopruner.Bits = BoardSquare.C1 | BoardSquare.B5;
lolboard.Update(lillebishopruner);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolboard, 2, ChessPieceColors.Black, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
}
private static void anotherIllegalMoveFromMovegen()
{
//Winboard winboard = new Winboard();
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A3 | BoardSquare.C3 | BoardSquare.C4 | BoardSquare.F4 | BoardSquare.G4 | BoardSquare.H3;
BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);
bishopWhite.Bits = 0;
KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);
kingWhite.Bits = BoardSquare.C2;
RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);
rookWhite.Bits = BoardSquare.A1 | BoardSquare.E2;
KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);
knightWhite.Bits = BoardSquare.B1;
QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);
queenWhite.Bits = 0;
//Black
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C6 | BoardSquare.E7 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);
rookBlack.Bits = BoardSquare.D8 | BoardSquare.H8;
BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);
bishopBlack.Bits = BoardSquare.F8;
QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);
queenBlack.Bits = BoardSquare.D1;
KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);
kingBlack.Bits = BoardSquare.C8;
KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);
knightBlack.Bits = 0;
//RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
//badMove.Bits = BoardSquare.B8;
lolBoard.Update(pawnWhite);
lolBoard.Update(knightWhite);
lolBoard.Update(queenWhite);
lolBoard.Update(rookWhite);
lolBoard.Update(bishopWhite);
lolBoard.Update(kingWhite);
lolBoard.Update(pawnBlack);
lolBoard.Update(rookBlack);
lolBoard.Update(bishopBlack);
lolBoard.Update(queenBlack);
lolBoard.Update(kingBlack);
lolBoard.Update(knightBlack);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
}
private static void sacrificeQueenDebugStuffSomethingTestMethod()
{
//Winboard winboard = new Winboard();
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A4 | BoardSquare.C2 | BoardSquare.D3 | BoardSquare.E4 | BoardSquare.F2 | BoardSquare.G2;
BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);
bishopWhite.Bits = BoardSquare.E2 | BoardSquare.H4;
KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);
kingWhite.Bits = BoardSquare.E1;
RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);
rookWhite.Bits = BoardSquare.B1 | BoardSquare.H1;
KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);
knightWhite.Bits = BoardSquare.D2;
QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);
queenWhite.Bits = BoardSquare.D1;
//Black
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.E5 | BoardSquare.H5;
RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);
rookBlack.Bits = BoardSquare.A8 | BoardSquare.H7;
BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);
bishopBlack.Bits = BoardSquare.C8 | BoardSquare.F8;
QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);
queenBlack.Bits = BoardSquare.B4;
KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);
kingBlack.Bits = BoardSquare.F7;
KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);
knightBlack.Bits = BoardSquare.B8;
//RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
//badMove.Bits = BoardSquare.B8;
lolBoard.Update(pawnWhite);
lolBoard.Update(knightWhite);
lolBoard.Update(queenWhite);
lolBoard.Update(rookWhite);
lolBoard.Update(bishopWhite);
lolBoard.Update(kingWhite);
lolBoard.Update(pawnBlack);
lolBoard.Update(rookBlack);
lolBoard.Update(bishopBlack);
lolBoard.Update(queenBlack);
lolBoard.Update(kingBlack);
lolBoard.Update(knightBlack);
List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
legalMoves = MoveGen.GenerateLegalMoves(lolBoard, ChessPieceColors.Black);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.Black, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
Console.Write(legalMoves.ToString() + bestMove.ToString());
}
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);
}
private static void anotherBlackQueenSideCastleFail()
{
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A2 | BoardSquare.C3 | BoardSquare.E3 | BoardSquare.H3;
BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);
bishopWhite.Bits = 0;
RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);
rookWhite.Bits = BoardSquare.A1;
KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);
knightWhite.Bits = BoardSquare.B1;
QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);
queenWhite.Bits = BoardSquare.E2;
KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);
kingWhite.Bits = BoardSquare.D2;
//black
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H5;
BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);
bishopBlack.Bits = BoardSquare.E4 | BoardSquare.F8;
RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);
rookBlack.Bits = BoardSquare.A8 | BoardSquare.H8;
KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);
knightBlack.Bits = BoardSquare.F4;
QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);
queenBlack.Bits = BoardSquare.H3;
KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);
kingBlack.Bits = BoardSquare.C8;
//Update
lolBoard.Update(pawnWhite);
lolBoard.Update(knightWhite);
lolBoard.Update(queenWhite);
lolBoard.Update(rookWhite);
lolBoard.Update(bishopWhite);
lolBoard.Update(kingWhite);
lolBoard.Update(pawnBlack);
lolBoard.Update(rookBlack);
lolBoard.Update(bishopBlack);
lolBoard.Update(queenBlack);
lolBoard.Update(kingBlack);
lolBoard.Update(knightBlack);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
}
public static bool isEnemyKingAttackable_TEST(ChessBoard cb, ColoredBitBoard legalMove, ChessPieceColors color)
{
return(isEnemyKingAttackable(cb, legalMove, color));
}
private static void f3d5failmove()
{
//Winboard winboard = new Winboard();
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A3 | BoardSquare.B3 | BoardSquare.C3 | BoardSquare.D3 | BoardSquare.H4;
BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);
bishopWhite.Bits = BoardSquare.C1;
KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);
kingWhite.Bits = BoardSquare.F2;
RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);
rookWhite.Bits = BoardSquare.A1 | BoardSquare.H1;
KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);
knightWhite.Bits = BoardSquare.B1 | BoardSquare.G1;
QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);
queenWhite.Bits = BoardSquare.F3;
//Black
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C5 | BoardSquare.D7 | BoardSquare.G7 | BoardSquare.G4 | BoardSquare.H7;
RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);
rookBlack.Bits = BoardSquare.A8 | BoardSquare.F8;
BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);
bishopBlack.Bits = BoardSquare.C8 | BoardSquare.D6;
QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);
queenBlack.Bits = BoardSquare.G6;
KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);
kingBlack.Bits = BoardSquare.G8;
KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);
knightBlack.Bits = BoardSquare.D5;
//RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
//badMove.Bits = BoardSquare.B8;
lolBoard.Update(pawnWhite);
lolBoard.Update(knightWhite);
lolBoard.Update(queenWhite);
lolBoard.Update(rookWhite);
lolBoard.Update(bishopWhite);
lolBoard.Update(kingWhite);
lolBoard.Update(pawnBlack);
lolBoard.Update(rookBlack);
lolBoard.Update(bishopBlack);
lolBoard.Update(queenBlack);
lolBoard.Update(kingBlack);
lolBoard.Update(knightBlack);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
}
private static void blackqueensidecastle()
{
//Winboard winboard = new Winboard();
ChessBoard lolBoard = new ChessBoard();
lolBoard.InitializeGame();
//White
PawnBitBoard pawnWhite = new PawnBitBoard(ChessPieceColors.White);
pawnWhite.Bits = BoardSquare.A2 | BoardSquare.B2 | BoardSquare.C2 | BoardSquare.D2 | BoardSquare.E4 | BoardSquare.H3;
BishopBitBoard bishopWhite = new BishopBitBoard(ChessPieceColors.White);
bishopWhite.Bits = BoardSquare.C1;
KingBitBoard kingWhite = new KingBitBoard(ChessPieceColors.White);
kingWhite.Bits = BoardSquare.D3;
RookBitBoard rookWhite = new RookBitBoard(ChessPieceColors.White);
rookWhite.Bits = BoardSquare.A1 | BoardSquare.H1;
KnightBitBoard knightWhite = new KnightBitBoard(ChessPieceColors.White);
knightWhite.Bits = BoardSquare.D2;
QueenBitBoard queenWhite = new QueenBitBoard(ChessPieceColors.White);
queenWhite.Bits = BoardSquare.D1;
//Black
PawnBitBoard pawnBlack = new PawnBitBoard(ChessPieceColors.Black);
pawnBlack.Bits = BoardSquare.A7 | BoardSquare.B7 | BoardSquare.C7 | BoardSquare.C6 | BoardSquare.F7 | BoardSquare.G7 | BoardSquare.H7;
RookBitBoard rookBlack = new RookBitBoard(ChessPieceColors.Black);
rookBlack.Bits = BoardSquare.A8 | BoardSquare.H8;
BishopBitBoard bishopBlack = new BishopBitBoard(ChessPieceColors.Black);
bishopBlack.Bits = BoardSquare.F5 | BoardSquare.H4;
QueenBitBoard queenBlack = new QueenBitBoard(ChessPieceColors.Black);
queenBlack.Bits = BoardSquare.F2;
KingBitBoard kingBlack = new KingBitBoard(ChessPieceColors.Black);
kingBlack.Bits = BoardSquare.E8;
KnightBitBoard knightBlack = new KnightBitBoard(ChessPieceColors.Black);
knightBlack.Bits = BoardSquare.H6;
//RookBitBoard badMove = new RookBitBoard( ChessPieceColors.Black );
//badMove.Bits = BoardSquare.B8;
lolBoard.Update(pawnWhite);
lolBoard.Update(knightWhite);
lolBoard.Update(queenWhite);
lolBoard.Update(rookWhite);
lolBoard.Update(bishopWhite);
lolBoard.Update(kingWhite);
lolBoard.Update(pawnBlack);
lolBoard.Update(rookBlack);
lolBoard.Update(bishopBlack);
lolBoard.Update(queenBlack);
lolBoard.Update(kingBlack);
lolBoard.Update(knightBlack);
KingBitBoard test = new KingBitBoard(ChessPieceColors.Black);
test.Bits = BoardSquare.C8;
lolBoard.Update(test);
List <ColoredBitBoard> legalMoves = new List <ColoredBitBoard>();
legalMoves = MoveGen.GenerateLegalMoves(lolBoard, ChessPieceColors.Black);
ColoredBitBoard bestMove = NegaMax.GetBestMove(lolBoard, 3, ChessPieceColors.White, MoveGen.GenerateLegalMoves, Eval.EvaluateState);
Console.Write(legalMoves.ToString() + bestMove.ToString());
}
