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);
}
}
}
}
