internal Piece(Piece piece)
{
PieceColor = piece.PieceColor;
PieceType = piece.PieceType;
Moved = piece.Moved;
PieceValue = piece.PieceValue;
PieceActionValue = piece.PieceActionValue;
if (piece.ValidMoves != null)
LastValidMoveCount = piece.ValidMoves.Count;
}
private static void GenerateValidMovesKing(Piece piece, Board board, byte srcPosition)
{
if (piece == null)
{
return;
}
for (byte i = 0; i < MoveArrays.KingTotalMoves[srcPosition]; i++)
{
byte dstPos = MoveArrays.KingMoves[srcPosition].Moves[i];
if (piece.PieceColor == ChessPieceColor.White)
{
//I can't move where I am being attacked
if (BlackAttackBoard[dstPos])
{
WhiteAttackBoard[dstPos] = true;
continue;
}
}
else
{
if (WhiteAttackBoard[dstPos])
{
BlackAttackBoard[dstPos] = true;
continue;
}
}
AnalyzeMove(board, dstPos, piece);
}
}
private static void GenerateValidMovesKingCastle(Board board, Piece king)
{
if (king == null)
{
return;
}
if (king.Moved)
{
return;
}
if (king.PieceColor == ChessPieceColor.White &&
board.WhiteCastled)
{
return;
}
if (king.PieceColor == ChessPieceColor.Black &&
board.BlackCastled)
{
return;
}
if (king.PieceColor == ChessPieceColor.Black &&
board.BlackCheck)
{
return;
}
if (king.PieceColor == ChessPieceColor.White &&
board.WhiteCheck)
{
return;
}
//This code will add the castleling move to the pieces available moves
if (king.PieceColor == ChessPieceColor.White)
{
if (board.WhiteCheck)
{
return;
}
if (board.Squares[63].Piece != null)
{
//Check if the Right Rook is still in the correct position
if (board.Squares[63].Piece.PieceType == ChessPieceType.Rook)
{
if (board.Squares[63].Piece.PieceColor == king.PieceColor)
{
//Move one column to right see if its empty
if (board.Squares[62].Piece == null)
{
if (board.Squares[61].Piece == null)
{
if (BlackAttackBoard[61] == false &&
BlackAttackBoard[62] == false)
{
//Ok looks like move is valid lets add it
king.ValidMoves.Push(62);
WhiteAttackBoard[62] = true;
}
}
}
}
}
}
if (board.Squares[56].Piece != null)
{
//Check if the Left Rook is still in the correct position
if (board.Squares[56].Piece.PieceType == ChessPieceType.Rook)
{
if (board.Squares[56].Piece.PieceColor == king.PieceColor)
{
//Move one column to right see if its empty
if (board.Squares[57].Piece == null)
{
if (board.Squares[58].Piece == null)
{
if (board.Squares[59].Piece == null)
{
if (BlackAttackBoard[58] == false &&
BlackAttackBoard[59] == false)
{
//Ok looks like move is valid lets add it
king.ValidMoves.Push(58);
WhiteAttackBoard[58] = true;
}
}
}
}
}
}
}
}
else if (king.PieceColor == ChessPieceColor.Black)
{
if (board.BlackCheck)
{
return;
}
//There are two ways to castle, scenario 1:
if (board.Squares[7].Piece != null)
{
//Check if the Right Rook is still in the correct position
if (board.Squares[7].Piece.PieceType == ChessPieceType.Rook
&& !board.Squares[7].Piece.Moved)
{
if (board.Squares[7].Piece.PieceColor == king.PieceColor)
{
//Move one column to right see if its empty
if (board.Squares[6].Piece == null)
{
if (board.Squares[5].Piece == null)
{
if (WhiteAttackBoard[5] == false && WhiteAttackBoard[6] == false)
{
//Ok looks like move is valid lets add it
king.ValidMoves.Push(6);
BlackAttackBoard[6] = true;
}
}
}
}
}
}
//There are two ways to castle, scenario 2:
if (board.Squares[0].Piece != null)
{
//Check if the Left Rook is still in the correct position
if (board.Squares[0].Piece.PieceType == ChessPieceType.Rook &&
!board.Squares[0].Piece.Moved)
{
if (board.Squares[0].Piece.PieceColor ==
king.PieceColor)
{
//Move one column to right see if its empty
if (board.Squares[1].Piece == null)
{
if (board.Squares[2].Piece == null)
{
if (board.Squares[3].Piece == null)
{
if (WhiteAttackBoard[2] == false &&
WhiteAttackBoard[3] == false)
{
//Ok looks like move is valid lets add it
king.ValidMoves.Push(2);
BlackAttackBoard[2] = true;
}
}
}
}
}
}
}
}
}
private static void CheckValidMovesPawn(List<byte> moves, Piece pcMoving, byte srcPosition,
Board board, byte count)
{
for (byte i = 0; i < count; i++)
{
byte dstPos = moves[i];
if (dstPos%8 != srcPosition%8)
{
//If there is a piece there I can potentialy kill
AnalyzeMovePawn(board, dstPos, pcMoving);
if (pcMoving.PieceColor == ChessPieceColor.White)
{
WhiteAttackBoard[dstPos] = true;
}
else
{
BlackAttackBoard[dstPos] = true;
}
}
// if there is something if front pawns can't move there
else if (board.Squares[dstPos].Piece != null)
{
return;
}
//if there is nothing in front of me (blocked == false)
else
{
pcMoving.ValidMoves.Push(dstPos);
}
}
}
private static void AnalyzeMovePawn(Board board, byte dstPos, Piece pcMoving)
{
//Because Pawns only kill diagonaly we handle the En Passant scenario specialy
if (board.EnPassantPosition > 0)
{
if (pcMoving.PieceColor != board.EnPassantColor)
{
if (board.EnPassantPosition == dstPos)
{
//We have an En Passant Possible
pcMoving.ValidMoves.Push(dstPos);
if (pcMoving.PieceColor == ChessPieceColor.White)
{
WhiteAttackBoard[dstPos] = true;
}
else
{
BlackAttackBoard[dstPos] = true;
}
}
}
}
Piece pcAttacked = board.Squares[dstPos].Piece;
//If there no piece there I can potentialy kill
if (pcAttacked == null)
return;
//Regardless of what is there I am attacking this square
if (pcMoving.PieceColor == ChessPieceColor.White)
{
WhiteAttackBoard[dstPos] = true;
//if that piece is the same color
if (pcAttacked.PieceColor == pcMoving.PieceColor)
{
pcAttacked.DefendedValue += pcMoving.PieceActionValue;
return;
}
pcAttacked.AttackedValue += pcMoving.PieceActionValue;
//If this is a king set it in check
if (pcAttacked.PieceType == ChessPieceType.King)
{
board.BlackCheck = true;
}
else
{
//Add this as a valid move
pcMoving.ValidMoves.Push(dstPos);
}
}
else
{
BlackAttackBoard[dstPos] = true;
//if that piece is the same color
if (pcAttacked.PieceColor == pcMoving.PieceColor)
{
pcAttacked.DefendedValue += pcMoving.PieceActionValue;
return;
}
pcAttacked.AttackedValue += pcMoving.PieceActionValue;
//If this is a king set it in check
if (pcAttacked.PieceType == ChessPieceType.King)
{
board.WhiteCheck = true;
}
else
{
//Add this as a valid move
pcMoving.ValidMoves.Push(dstPos);
}
}
return;
}
private static bool AnalyzeMove(Board board, byte dstPos, Piece pcMoving)
{
//If I am not a pawn everywhere I move I can attack
if (pcMoving.PieceColor == ChessPieceColor.White)
{
WhiteAttackBoard[dstPos] = true;
}
else
{
BlackAttackBoard[dstPos] = true;
}
//If there no piece there I can potentialy kill just add the move and exit
if (board.Squares[dstPos].Piece == null)
{
pcMoving.ValidMoves.Push(dstPos);
return true;
}
Piece pcAttacked = board.Squares[dstPos].Piece;
//if that piece is a different color
if (pcAttacked.PieceColor != pcMoving.PieceColor)
{
pcAttacked.AttackedValue += pcMoving.PieceActionValue;
//If this is a king set it in check
if (pcAttacked.PieceType == ChessPieceType.King)
{
if (pcAttacked.PieceColor == ChessPieceColor.Black)
{
board.BlackCheck = true;
}
else
{
board.WhiteCheck = true;
}
}
else
{
//Add this as a valid move
pcMoving.ValidMoves.Push(dstPos);
}
//We don't continue movement past this piece
return false;
}
//Same Color I am defending
pcAttacked.DefendedValue += pcMoving.PieceActionValue;
//Since this piece is of my kind I can't move there
return false;
}
private static bool PromotePawns(Board board, Piece piece, byte dstPosition, ChessPieceType promoteToPiece)
{
if (piece.PieceType == ChessPieceType.Pawn)
{
if (dstPosition < 8)
{
board.Squares[dstPosition].Piece.PieceType = promoteToPiece;
return true;
}
if (dstPosition > 55)
{
board.Squares[dstPosition].Piece.PieceType = promoteToPiece;
return true;
}
}
return false;
}
private static void KingCastle(Board board, Piece piece, byte srcPosition, byte dstPosition)
{
if (piece.PieceType != ChessPieceType.King)
{
return;
}
//Lets see if this is a casteling move.
if (piece.PieceColor == ChessPieceColor.White && srcPosition == 60)
{
//Castle Right
if (dstPosition == 62)
{
//Ok we are casteling we need to move the Rook
if (board.Squares[63].Piece != null)
{
board.Squares[61].Piece = board.Squares[63].Piece;
board.Squares[63].Piece = null;
board.WhiteCastled = true;
board.LastMove.MovingPieceSecondary = new PieceMoving(board.Squares[61].Piece.PieceColor, board.Squares[61].Piece.PieceType, board.Squares[61].Piece.Moved, 63, 61);
board.Squares[61].Piece.Moved = true;
return;
}
}
//Castle Left
else if (dstPosition == 58)
{
//Ok we are casteling we need to move the Rook
if (board.Squares[56].Piece != null)
{
board.Squares[59].Piece = board.Squares[56].Piece;
board.Squares[56].Piece = null;
board.WhiteCastled = true;
board.LastMove.MovingPieceSecondary = new PieceMoving(board.Squares[59].Piece.PieceColor, board.Squares[59].Piece.PieceType, board.Squares[59].Piece.Moved, 56, 59);
board.Squares[59].Piece.Moved = true;
return;
}
}
}
else if (piece.PieceColor == ChessPieceColor.Black && srcPosition == 4)
{
if (dstPosition == 6)
{
//Ok we are casteling we need to move the Rook
if (board.Squares[7].Piece != null)
{
board.Squares[5].Piece = board.Squares[7].Piece;
board.Squares[7].Piece = null;
board.BlackCastled = true;
board.LastMove.MovingPieceSecondary = new PieceMoving(board.Squares[5].Piece.PieceColor, board.Squares[5].Piece.PieceType, board.Squares[5].Piece.Moved, 7, 5);
board.Squares[5].Piece.Moved = true;
return;
}
}
//Castle Left
else if (dstPosition == 2)
{
//Ok we are casteling we need to move the Rook
if (board.Squares[0].Piece != null)
{
board.Squares[3].Piece = board.Squares[0].Piece;
board.Squares[0].Piece = null;
board.BlackCastled = true;
board.LastMove.MovingPieceSecondary = new PieceMoving(board.Squares[3].Piece.PieceColor, board.Squares[3].Piece.PieceType, board.Squares[3].Piece.Moved, 0, 3);
board.Squares[3].Piece.Moved = true;
return;
}
}
}
return;
}
