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 static List <Move> GeneratePieceMoves(Board board, int sourceSquare)
{
List <Move> pseudoLegalMoves = new List <Move>();
int piece = board.pieces[sourceSquare];
switch (Piece.GetPieceType(piece))
{
case Piece.pawn:
GeneratePawnMoves(board, sourceSquare, pseudoLegalMoves);
break;
case Piece.knight:
GenerateKnightMoves(board, sourceSquare, pseudoLegalMoves);
break;
case Piece.bishop:
GenerateSlidingMoves(board, sourceSquare, pseudoLegalMoves);
break;
case Piece.queen:
GenerateSlidingMoves(board, sourceSquare, pseudoLegalMoves);
break;
case Piece.rook:
GenerateSlidingMoves(board, sourceSquare, pseudoLegalMoves);
break;
case Piece.king:
GenerateKingMoves(board, sourceSquare, pseudoLegalMoves);
break;
}
return(pseudoLegalMoves);
}
private int GetPieceValue(int piece)
{
switch (Piece.GetPieceType(piece))
{
case Piece.pawn:
return(pawnValue);
case Piece.rook:
return(rookValue);
case Piece.bishop:
return(bishopValue);
case Piece.knight:
return(knightValue);
case Piece.queen:
return(queenValue);
case Piece.king:
return(kingValue);
}
return(0);
}
/*********************************************************************
* IsCheckMate
* Loop through the board and for each piece we check if they can kill
* the king if they can we end and return true.
*********************************************************************/
public bool IsCheckMate()
{
for (int r = 0; r < 8; r++)
{
for (int c = 0; c < 8; c++)
{
Piece piece = board[r, c].GetPiece();
if (piece != null && piece.GetTeam() != turn && piece.GetPieceType() == "King")
{
Piece king = board[r, c].GetPiece();
Piece killer = null;
king.CalcPossMoves(board);
bool Check = false;
int checkCount = 0;
int vulnerableChecks = 0;
if (IsCheck(r, c, ref killer))
{
Check = true;
checkCount++;
if (IsKillable(killer.GetRow(), killer.GetColumn(), turn))
{
vulnerableChecks++;
}
}
if (Check)
{
for (int i = 0; i < king.GetPossMoves().Count; i++)
{
if (IsCheck(king.GetPossMoves()[i].row, king.GetPossMoves()[i].col, ref killer))
{
checkCount++;
if (IsKillable(killer.GetRow(), killer.GetColumn(), turn))
{
vulnerableChecks++;
}
}
}
}
if (checkCount > 0 && checkCount == king.GetPossMoves().Count)
{
checkText.Text = "CHECKMATE";
return(true);
}
else if (checkCount == 0 || checkCount == vulnerableChecks)
{
checkText.Text = "";
}
else if (Check)
{
MessageBox.Show("king is checked");
checkText.Text = "CHECK";
}
}
}
}
return(false);
}
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 bool ParseLine(String line, out String message)
{
string placingPattern = "^([KQBNRP])([ld])([a-h, A-H][1-8])$";
string movingPattern = "^([a-h,A-H][1-8])\\s([a-h,A-H][1-8])$";
string doubleMovePattern = "^([a-h,A-H][1-8])\\s([a-h,A-H][1-8])\\s([a-h,A-H][1-8])\\s([a-h,A-H][1-8])$";
message = "";
if (Regex.IsMatch(line, placingPattern))
{
char piece = line.ElementAt(0);
char color = line.ElementAt(1);
char rank = line.ElementAt(2);
char file = line.ElementAt(3);
Piece p = new Piece(piece, color);
message = string.Concat("Place the ", p.GetColor(), " ", p.GetPieceType(), " at ", rank, file, "\n");
validPlacements.Add(line);
return(true);
}
else if (Regex.IsMatch(line, movingPattern))
{
char startingRank = line.ElementAt(0);
char startingFile = line.ElementAt(1);
char endingRank = line.ElementAt(3);
char endingFile = line.ElementAt(4);
message = string.Concat("Move the piece at ", startingRank, startingFile, " to ", endingRank, endingFile, "\n");
validMoves.Add(line);
return(true);
}
else if (Regex.IsMatch(line, doubleMovePattern))
{
char firstStartingRank = line.ElementAt(0);
char firstStartingFile = line.ElementAt(1);
char firstEndingRank = line.ElementAt(3);
char firstEndingFile = line.ElementAt(4);
char secondStartingRank = line.ElementAt(6);
char secondStartingFile = line.ElementAt(7);
char secondEndingRank = line.ElementAt(9);
char secondEndingFile = line.ElementAt(10);
message = string.Concat("Move the piece at ", firstStartingRank, firstStartingFile, " to ", firstEndingRank, firstEndingFile, " and the piece at ", secondStartingRank, secondStartingFile, " to ", secondEndingRank, secondEndingFile, "\n");
validMoves.Add(line);
return(true);
}
else if (!Regex.IsMatch(line, "^($)"))
{
PrintInfo(line, "This line is invalid input.");
return(false);
}
return(false);
}
public bool Move(string movement)
{
//return to bool eventually
/*
* piece.move() pass x and y for new space
*/
if (movement.Length == 5)
{
int currentFile = CharToInt(movement[0]);
int currentRank = int.Parse(movement[1].ToString()) - 1;
int newFile = CharToInt(movement[3]);
int newRank = int.Parse(movement[4].ToString()) - 1;
if (boardSpaces[currentRank, currentFile].HasPiece())
{
Piece movingPiece = boardSpaces[currentRank, currentFile].GetPiece();
if (movingPiece.Move(movingPiece.GetPieceType(), currentRank, currentFile, newRank, newFile))
{
string pieceString = movingPiece.GetPieceString();
boardSpaces[newRank, newFile].AddPiece(pieceString[1], pieceString[0]);
boardSpaces[currentRank, currentFile].RemovePiece();
return(true);
}
else
{
Parser.PrintInfo(movement, "This is an invalid move.\n");
return(false);
}
}
else
{
Parser.PrintInfo(movement, "The stating space does not contain a piece to move.\n");
return(false);
}
}
else
{
string firstMove = string.Concat(movement[0], movement[1], movement[3], movement[4]);
string secondMove = string.Concat(movement[6], movement[7], movement[9], movement[10]);
if (Move(firstMove) && Move(secondMove))
{
return(true);
}
else
{
return(false);
}
}
}
public static bool ParseLine(String line, out String message)
{
string placingPattern = "^([KQBNRP])([ld])([a-h, A-H][1-8])$";
string movingPattern = "^([a-h,A-H][1-8])\\s([a-h,A-H][1-8])$";
string doubleMovePattern = "^([a-h,A-H][1-8])\\s([a-h,A-H][1-8])\\s([a-h,A-H][1-8])\\s([a-h,A-H][1-8])$";
message = "";
if (Regex.IsMatch(line, placingPattern))
{
char piece = line.ElementAt(0);
char color = line.ElementAt(1);
char rank = line.ElementAt(2);
char file = line.ElementAt(3);
Piece p = new Piece(piece, color);
message = string.Concat("Place the ", p.GetColor(), " ", p.GetPieceType(), " at ", rank, file, "\n");
validPlacements.Add(line);
return true;
}
else if (Regex.IsMatch(line, movingPattern))
{
char startingRank = line.ElementAt(0);
char startingFile = line.ElementAt(1);
char endingRank = line.ElementAt(3);
char endingFile = line.ElementAt(4);
message = string.Concat("Move the piece at ", startingRank, startingFile, " to ", endingRank, endingFile, "\n");
validMoves.Add(line);
return true;
}
else if (Regex.IsMatch(line, doubleMovePattern))
{
char firstStartingRank = line.ElementAt(0);
char firstStartingFile = line.ElementAt(1);
char firstEndingRank = line.ElementAt(3);
char firstEndingFile = line.ElementAt(4);
char secondStartingRank = line.ElementAt(6);
char secondStartingFile = line.ElementAt(7);
char secondEndingRank = line.ElementAt(9);
char secondEndingFile = line.ElementAt(10);
message = string.Concat("Move the piece at ", firstStartingRank, firstStartingFile, " to ", firstEndingRank, firstEndingFile, " and the piece at ", secondStartingRank, secondStartingFile, " to ", secondEndingRank, secondEndingFile,"\n");
validMoves.Add(line);
return true;
}
else if (!Regex.IsMatch(line, "^($)"))
{
PrintInfo(line, "This line is invalid input.");
return false;
}
return false;
}
/*********************************************************************
* SetPiece
* Parameters
* piece - the piece that will now be on this space
* Set the new piece for this space
*********************************************************************/
public void SetPiece(Piece piece)
{
this.piece = piece;
if (piece != null)
{
BackColor = BackColor;
ForeColor = piece.GetTextColor();
image = piece.GetImage();
this.Text = piece.GetPieceType();
piece.SetCol(col);
piece.SetRow(row);
ForeColor = piece.GetTextColor();
isEmpty = false;
}
}
public static List <Move> GenerateAllMoves(Board board, int color)
{
List <Move> pseudoLegalMoves = new List <Move>();
for (int i = 0; i < 64; i++)
{
int piece = board.pieces[i];
if (!Piece.IsPieceType(piece, Piece.none))
{
if (Piece.IsPieceColor(piece, color))
{
switch (Piece.GetPieceType(piece))
{
case Piece.pawn:
GeneratePawnMoves(board, i, pseudoLegalMoves);
break;
case Piece.knight:
GenerateKnightMoves(board, i, pseudoLegalMoves);
break;
case Piece.bishop:
GenerateSlidingMoves(board, i, pseudoLegalMoves);
break;
case Piece.queen:
GenerateSlidingMoves(board, i, pseudoLegalMoves);
break;
case Piece.rook:
GenerateSlidingMoves(board, i, pseudoLegalMoves);
break;
case Piece.king:
GenerateKingMoves(board, i, pseudoLegalMoves);
break;
}
}
}
}
return(pseudoLegalMoves);
}
