private static void GenerateMove(ChessPositionIndex squareFrom, ChessPositionIndex squareTo, ChessPieceType pieceType, ChessPieceType promotionPieceType, List <ChessMove> moveList)
{
ChessMove move = new ChessMove(squareFrom, squareTo, pieceType);
move.PromotionPieceType = promotionPieceType;
moveList.Add(move);
}
public ChessMoveInfo()
{
this.MovedBy = ChessPieceColor.None;
this.CapturedPiecePos = ChessPositionIndex.None;
this.SecondaryFromIndex = ChessPositionIndex.None;
this.SecondaryToIndex = ChessPositionIndex.None;
}
public void CapturePiece(ChessPositionIndex index)
{
ChessPiece piece = new ChessPiece();
if (GetPiece(index, ref piece))
{
capturedPieces.Add(piece);
}
SetEmpty(index);
}
public bool IsTypeAndColor(ChessPositionIndex index, ChessPieceType type, ChessPieceColor color)
{
bool res = false;
ChessPiece piece = new ChessPiece();
if (GetPiece(index, ref piece))
{
res = (piece.PieceColor == color && piece.PieceType == type);
}
return(res);
}
public bool IsPiece(ChessPositionIndex index, ChessPieceType pieceType, ChessPieceColor pieceColor)
{
bool res = false;
ChessPiece piece = new ChessPiece();
if (GetPiece(index, ref piece))
{
if (piece.PieceColor == pieceColor && piece.PieceType == pieceType)
{
res = true;
}
}
return(res);
}
internal void GetKing(ChessPieceColor chessPieceColor, out ChessPositionIndex kingIndex)
{
kingIndex = ChessPositionIndex.A1;
Byte piece = (Byte)((Byte)ChessPieceType.King | (Byte)chessPieceColor);
UInt64 pos = 1;
for (ChessPositionIndex index = ChessPositionIndex.A1; index <= ChessPositionIndex.H8; index++, pos <<= 1)
{
if ((GetBoardState(chessPieceColor).King & pos) != 0)
{
kingIndex = index;
break;
}
}
}
public static List <ChessMove> GetPossibleMovesFrom(ChessBoard board, ChessPositionIndex index)
{
List <ChessMove> moveList = new List <ChessMove>();
List <ChessMove> moves = new List <ChessMove>();
ChessPiece piece = new ChessPiece();
if (board.GetPiece(index, ref piece))
{
switch (piece.PieceType)
{
case ChessPieceType.Pawn:
AddOnePawnMoves(board, piece.PieceColor, (uint)index, moveList);
break;
case ChessPieceType.Knight:
AddOneKnightMoves(board, piece.PieceColor, (uint)index, moveList);
break;
case ChessPieceType.Bishop:
AddOneBishopMoves(board, piece.PieceColor, (uint)index, moveList);
break;
case ChessPieceType.Rook:
AddOneRookMoves(board, piece.PieceColor, (uint)index, moveList);
break;
case ChessPieceType.Queen:
AddOneQueenMoves(board, piece.PieceColor, (uint)index, moveList);
break;
case ChessPieceType.King:
AddKingMoves(board, piece.PieceColor, moveList, 0);
break;
}
// Check so the moves do not put own king in check.
foreach (ChessMove move in moveList)
{
ChessBoard resBoard = new ChessBoard(board);
resBoard.ApplyMove(piece.PieceColor, move, null);
if (!IsInCheck(resBoard, piece.PieceColor))
{
moves.Add(move);
}
}
}
return(moves);
}
public bool GetPiece(ChessPositionIndex index, out ChessPieceType pieceType, out ChessPieceColor pieceColor)
{
bool res = false;
UInt64 pos = (UInt64)1 << (int)index;
pieceType = ChessPieceType.None;
pieceColor = ChessPieceColor.None;
for (ChessPieceColor color = ChessPieceColor.White; color <= ChessPieceColor.Black; color++)
{
ChessBoardColorState boardState = GetBoardState(color);
if ((boardState.Pieces & pos) != 0)
{
pieceColor = color;
if ((boardState.Pawns & pos) != 0)
{
pieceType = ChessPieceType.Pawn;
}
else if ((boardState.Knights & pos) != 0)
{
pieceType = ChessPieceType.Knight;
}
else if ((boardState.Bishops & pos) != 0)
{
pieceType = ChessPieceType.Bishop;
}
else if ((boardState.Rooks & pos) != 0)
{
pieceType = ChessPieceType.Rook;
}
else if ((boardState.Queens & pos) != 0)
{
pieceType = ChessPieceType.Queen;
}
else if ((boardState.King & pos) != 0)
{
pieceType = ChessPieceType.King;
}
res = true;
break;
}
}
return(res);
}
public bool GetPiece(ChessPositionIndex index, ref ChessPiece piece)
{
ChessPieceType pieceType;
ChessPieceColor pieceColor;
bool res = GetPiece(index, out pieceType, out pieceColor);
if (res)
{
piece.PieceType = pieceType;
piece.PieceColor = pieceColor;
}
else
{
piece.PieceType = ChessPieceType.None;
piece.PieceColor = ChessPieceColor.None;
}
return(res);
}
private void MoveRookWhenCastling(ChessPieceColor color, ChessPositionIndex fromIndex, ChessPositionIndex toIndex, ChessMoveInfo moveInfo)
{
ulong rookFromPos = Precomputed.IndexToBitBoard[(int)fromIndex];
ulong rookToPos = Precomputed.IndexToBitBoard[(int)toIndex];
ChessBoardColorState boardState = GetBoardState(color);
boardState.Pieces &= ~rookFromPos;
boardState.Pieces |= rookToPos;
boardState.Rooks &= ~rookFromPos;
boardState.Rooks |= rookToPos;
if (moveInfo != null)
{
moveInfo.SecondaryFromIndex = fromIndex;
moveInfo.SecondaryToIndex = toIndex;
}
}
internal void SetEmpty(ChessPositionIndex index)
{
UInt64 pos = ~((UInt64)1 << (int)index);
whiteBoardState.Pieces &= pos;
whiteBoardState.Pawns &= pos;
whiteBoardState.Knights &= pos;
whiteBoardState.Bishops &= pos;
whiteBoardState.Rooks &= pos;
whiteBoardState.Queens &= pos;
whiteBoardState.King &= pos;
blackBoardState.Pieces &= pos;
blackBoardState.Pawns &= pos;
blackBoardState.Knights &= pos;
blackBoardState.Bishops &= pos;
blackBoardState.Rooks &= pos;
blackBoardState.Queens &= pos;
blackBoardState.King &= pos;
}
public void SetPiece(ChessPositionIndex index, ChessPieceType pieceType, ChessPieceColor pieceColor)
{
UInt64 pos = (UInt64)1 << (int)index;
if (pieceColor == ChessPieceColor.None)
{
SetEmpty(index);
}
else
{
ChessBoardColorState boardState = GetBoardState(pieceColor);
boardState.Pieces |= pos;
switch (pieceType)
{
case ChessPieceType.Pawn:
boardState.Pawns |= pos;
break;
case ChessPieceType.Knight:
boardState.Knights |= pos;
break;
case ChessPieceType.Bishop:
boardState.Bishops |= pos;
break;
case ChessPieceType.Rook:
boardState.Rooks |= pos;
break;
case ChessPieceType.Queen:
boardState.Queens |= pos;
break;
case ChessPieceType.King:
boardState.King |= pos;
break;
}
}
}
public bool MakeMove(int fromX, int fromY, int toX, int toY, ChessPieceType promotionPieceType, bool validateOnly)
{
if (fromX < 0 || fromX > 7 || fromY < 0 || fromY > 7 ||
toX < 0 || toX > 7 || toY < 0 || toY > 7)
{
throw new Exception("Invalid index");
}
ChessPositionIndex fromIndex = (ChessPositionIndex)fromX + 8 * fromY;
ChessPositionIndex toIndex = (ChessPositionIndex)toX + 8 * toY;
ChessPiece piece = new ChessPiece();
if (!Board.GetPiece(fromIndex, ref piece))
{
throw new Exception("Piece not found");
}
ChessMove move = new ChessMove(fromIndex, toIndex, piece.PieceType);
move.PromotionPieceType = promotionPieceType;
return(MakeMove(move, validateOnly));
}
public bool IsEmpty(ChessPositionIndex index)
{
UInt64 pos = (UInt64)1 << (int)index;
return((whiteBoardState.Pieces & pos) == 0 && (blackBoardState.Pieces & pos) == 0);
}
public static int GetColumnFromIndex(ChessPositionIndex index)
{
return((int)index % 8);
}
public static int GetRowFromIndex(ChessPositionIndex index)
{
return((int)index / 8);
}
public int GetRow(ChessPositionIndex index)
{
return((int)index / 8);
}
public bool Equals(ChessPositionIndex fromIndex, ChessPositionIndex toIndex)
{
return(this.FromIndex == fromIndex && this.ToIndex == toIndex);
}
public ChessMove(ChessPositionIndex fromIndex, ChessPositionIndex toIndex, ChessPieceType pieceType)
{
this.FromIndex = fromIndex;
this.ToIndex = toIndex;
this.PieceType = pieceType;
}
public int GetColumn(ChessPositionIndex index)
{
return((int)index % 8);
}
public bool IsColor(ChessPositionIndex index, ChessPieceColor color)
{
UInt64 pos = (UInt64)1 << (int)index;
return((GetBoardState(color).Pieces & pos) != 0);
}
