public Texture GetTexture(int piece) { switch (Piece.GetPieceType(piece)) { case Piece.pawn: return(pawnSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); case Piece.rook: return(rookSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); case Piece.bishop: return(bishopSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); case Piece.knight: return(knightSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); case Piece.queen: return(queenSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); case Piece.king: return(kingSprite[Piece.GetPieceColor(piece) == Piece.white ? 0 : 1]); default: return(null); } }
public void MakeMove(Move move, bool testing = false) { move.sourcePiece = pieces[move.sourceSquare]; move.targetPiece = pieces[move.targetSquare]; pieces[move.targetSquare] = move.sourcePiece | Piece.moved; pieces[move.sourceSquare] = Piece.none; /* FLAGS */ if (move.canPromote) { pieces[move.targetSquare] = Piece.queen | Piece.GetPieceColor(move.sourcePiece) | Piece.moved; } else if (move.canCastle) { move.sourceRookPiece = pieces[move.rookSquareSource]; pieces[move.rookSquareTarget] = move.sourceRookPiece; pieces[move.rookSquareSource] = Piece.none; } /* ADD THE MOVE TO THE STACK */ previousMoves.Push(move); /* IF IS TESTING DO NOT SET THE LAST MOVE TO THIS MOVE */ if (!testing) { lastMove = move; } }
public static void GenerateSlidingMoves(Board board, int sourceSquare, List <Move> pseudoLegalMoves) { int piece = board.pieces[sourceSquare]; int startDirectionIndex = Piece.IsPieceType(piece, Piece.rook) || Piece.IsPieceType(piece, Piece.queen) ? 0 : 4; int endDirectionIndex = Piece.IsPieceType(piece, Piece.rook) ? 4 : 8; for (int d = startDirectionIndex; d < endDirectionIndex; d++) { for (int i = 0; i < numSquaresToEdge[sourceSquare][d]; i++) { int targetSquare = sourceSquare + (i + 1) * directions[d]; int targetPiece = board.pieces[targetSquare]; if (Piece.IsPieceType(targetPiece, Piece.none)) { pseudoLegalMoves.Add(new Move(sourceSquare, targetSquare)); } else if (Piece.IsPieceColor(targetPiece, Piece.GetPieceColor(piece))) { break; } else { pseudoLegalMoves.Add(new Move(sourceSquare, targetSquare)); break; } } } }
private int Evaluate(Board board) { int totalValueBlack = 0; int totalValueWhite = 0; for (int i = 0; i < 64; i++) { int piece = board.pieces[i]; if (!Piece.IsPieceType(piece, Piece.none)) { int pieceColor = Piece.GetPieceColor(piece); int pieceValue = 0; int index = (pieceColor == Piece.black) ? 63 - i : i; switch (Piece.GetPieceType(board.pieces[i])) { case Piece.pawn: pieceValue = pawnValue + bestPawnPositions[index]; break; case Piece.knight: pieceValue = knightValue + bestKnightPositions[index]; break; case Piece.bishop: pieceValue = bishopValue + bestBishopPositions[index]; break; case Piece.rook: pieceValue = rookValue + bestRookPositions[index]; break; case Piece.queen: pieceValue = queenValue + bestQueenPositions[index]; break; case Piece.king: pieceValue = kingValue + bestKingPositions[index]; break; } if (pieceColor == Piece.white) { totalValueWhite += pieceValue; } else { totalValueBlack += pieceValue; } } } return(totalValueBlack - totalValueWhite); }
public static void GenerateKnightMoves(Board board, int sourceSquare, List <Move> pseudoLegalMoves) { int piece = board.pieces[sourceSquare]; foreach (var square in preComputedKnightMoves[sourceSquare]) { if (Piece.IsPieceType(board.pieces[square], Piece.none)) { pseudoLegalMoves.Add(new Move(sourceSquare, square)); } else if (Piece.GetPieceColor(piece) != Piece.GetPieceColor(board.pieces[square])) { pseudoLegalMoves.Add(new Move(sourceSquare, square)); } } }
// TODO: optimize this public static bool IsInCheck(Board board, int color) { List <Move> enemyMoves = GenerateAllMoves(board, color == Piece.white ? Piece.black : Piece.white); foreach (var move in enemyMoves) { int piece = board.pieces[move.targetSquare]; if (Piece.IsPieceType(piece, Piece.king)) { if (Piece.GetPieceColor(piece) == color) { return(true); } } } return(false); }
public static List <Move> GenerateLegalMoves(Board board, int sourceSquare) { List <Move> pseudoLegalMoves = GeneratePieceMoves(board, sourceSquare); List <Move> legalMoves = new List <Move>(); int color = Piece.GetPieceColor(board.pieces[sourceSquare]); foreach (var move in pseudoLegalMoves) { board.MakeMove(move, true); if (!IsInCheck(board, color)) { legalMoves.Add(move); } board.UnMakeMove(true); } return(legalMoves); }
public static void GenerateKingMoves(Board board, int sourceSquare, List <Move> pseudoLegalMoves) { int piece = board.pieces[sourceSquare]; foreach (var square in preComputedKingMoves[sourceSquare]) { if (Piece.IsPieceType(board.pieces[square], Piece.none)) { pseudoLegalMoves.Add(new Move(sourceSquare, square)); } else if (Piece.GetPieceColor(piece) != Piece.GetPieceColor(board.pieces[square])) { pseudoLegalMoves.Add(new Move(sourceSquare, square)); } } /* CASTLELING */ if (!Piece.HasMoved(piece)) { /* LONG CASTLE */ if (Piece.IsPieceType(board.pieces[sourceSquare + directions[1]], Piece.none) && Piece.IsPieceType(board.pieces[sourceSquare + 2 * directions[1]], Piece.none) && Piece.IsPieceType(board.pieces[sourceSquare + 3 * directions[1]], Piece.none)) { int rookPiece = board.pieces[sourceSquare + 4 * directions[1]]; if (Piece.IsPieceType(rookPiece, Piece.rook)) { if (!Piece.HasMoved(rookPiece)) { Move move = new Move(sourceSquare, sourceSquare + 2 * directions[1]); move.canCastle = true; move.rookSquareSource = sourceSquare + 4 * directions[1]; move.rookSquareTarget = sourceSquare + directions[1]; pseudoLegalMoves.Add(move); } } } /* SHORT CASTLE */ if (Piece.IsPieceType(board.pieces[sourceSquare + directions[3]], Piece.none) && Piece.IsPieceType(board.pieces[sourceSquare + 2 * directions[3]], Piece.none)) { int rookPiece = board.pieces[sourceSquare + 3 * directions[3]]; if (Piece.IsPieceType(rookPiece, Piece.rook)) { if (!Piece.HasMoved(rookPiece)) { Move move = new Move(sourceSquare, sourceSquare + 2 * directions[3]); move.canCastle = true; move.rookSquareSource = sourceSquare + 3 * directions[3]; move.rookSquareTarget = sourceSquare + directions[3]; pseudoLegalMoves.Add(move); } } } } }
// TODO: this is messy, could be improved, also add en passant public static void GeneratePawnMoves(Board board, int sourceSquare, List <Move> pseudoLegalMoves) { int piece = board.pieces[sourceSquare]; int up = Piece.IsPieceColor(piece, Piece.black) ? directions[0] : directions[2]; if ((Piece.IsPieceColor(piece, Piece.black) && numSquaresToEdge[sourceSquare][0] > 0) || (Piece.IsPieceColor(piece, Piece.white) && numSquaresToEdge[sourceSquare][2] > 0)) { int targetSquareUp = sourceSquare + up; if (Piece.IsPieceType(board.pieces[targetSquareUp], Piece.none)) { Move move = new Move(sourceSquare, targetSquareUp); if ((Piece.IsPieceColor(piece, Piece.black) && numSquaresToEdge[sourceSquare][0] == 1) || (Piece.IsPieceColor(piece, Piece.white) && numSquaresToEdge[sourceSquare][2] == 1)) { move.canPromote = true; } pseudoLegalMoves.Add(move); if (!Piece.HasMoved(piece)) { int targetSquareDoubleUp = targetSquareUp + up; if (Piece.IsPieceType(board.pieces[targetSquareDoubleUp], Piece.none)) { pseudoLegalMoves.Add(new Move(sourceSquare, targetSquareDoubleUp)); } } } if (numSquaresToEdge[sourceSquare][1] > 0) { int targetSquareUpRight = targetSquareUp + directions[1]; if (!Piece.IsPieceType(board.pieces[targetSquareUpRight], Piece.none) && Piece.GetPieceColor(piece) != Piece.GetPieceColor(board.pieces[targetSquareUpRight])) { Move move = new Move(sourceSquare, targetSquareUpRight); if ((Piece.IsPieceColor(piece, Piece.black) && numSquaresToEdge[sourceSquare][0] == 1) || (Piece.IsPieceColor(piece, Piece.white) && numSquaresToEdge[sourceSquare][2] == 1)) { move.canPromote = true; } pseudoLegalMoves.Add(move); } } if (numSquaresToEdge[sourceSquare][3] > 0) { int targetSquareUpLeft = targetSquareUp + directions[3]; if (!Piece.IsPieceType(board.pieces[targetSquareUpLeft], Piece.none) && Piece.GetPieceColor(piece) != Piece.GetPieceColor(board.pieces[targetSquareUpLeft])) { Move move = new Move(sourceSquare, targetSquareUpLeft); if ((Piece.IsPieceColor(piece, Piece.black) && numSquaresToEdge[sourceSquare][0] == 1) || (Piece.IsPieceColor(piece, Piece.white) && numSquaresToEdge[sourceSquare][2] == 1)) { move.canPromote = true; } pseudoLegalMoves.Add(move); } } } }