// Check if piece has legal moves
public bool HasLegalMove(Pieces piece)
{
FindLegalMoves(piece);
foreach (Cell cell in Board)
{
if (cell.IsLegal)
{
return(true);
}
}
return(false);
}
// Check if piece can make aggressive moves
public bool HasAggressiveMove(Pieces piece)
{
FindLegalMoves(piece);
foreach (Cell cell in Board)
{
if (cell.IsLegal && cell.IsOccupied)
{
return(true);
}
}
return(false);
}
public void MovePiece(Pieces piece, Cell cell)
{
ClearMarkedLegalMoves();
FindLegalMoves(piece);
if (cell.IsLegal)
{
piece.Position.ChangeStatus();
piece.Position = cell;
cell.piece = piece;
if (!cell.IsOccupied)
{
cell.ChangeStatus();
}
}
}
// Method to move in any direction until obstructed
public void LineMovement(Pieces piece, int rowMovement, int columnMovement)
{
bool Unobstructed = true;
do
{
int desitinationRow = piece.Position.Row + rowMovement;
int destinationColumn = piece.Position.Column + columnMovement;
if (IsOnBoard(desitinationRow, destinationColumn))
{
if (Board[desitinationRow, destinationColumn].Piece == null)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].Piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
Unobstructed = false;
}
if (rowMovement != 0)
{
rowMovement = rowMovement + (rowMovement / Math.Abs(rowMovement));
}
if (columnMovement != 0)
{
columnMovement = columnMovement + (columnMovement / Math.Abs(columnMovement));
}
}
else
{
Unobstructed = false;
}
}while (Unobstructed);
}
public static string ConvertPieceToInitial(Pieces piece)
{
string pieceInitial = "";
switch (piece.Name)
{
case "Pawn":
pieceInitial = "P";
break;
case "Knight":
pieceInitial = "N";
break;
case "King":
pieceInitial = "K";
break;
case "Bishop":
pieceInitial = "B";
break;
case "Rook":
pieceInitial = "R";
break;
case "Queen":
pieceInitial = "Q";
break;
}
if (!piece.IsWhite)
{
pieceInitial = pieceInitial.ToLower();
}
return(pieceInitial);
}
private void CheckPawnLegals(Pieces piece)
{
foreach (Move move in piece.PossibleMoves)
{
int desitinationRow = piece.Position.Row + move.MoveRow;
int destinationColumn = piece.Position.Column + move.MoveColumn;
if (IsOnBoard(desitinationRow, destinationColumn))
{
// move diagonally only if it's occupied by opposite colour
if (desitinationRow != piece.Position.Row && destinationColumn != piece.Position.Column)
{
if (Board[desitinationRow, destinationColumn].IsOccupied &&
IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].Piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
}
// Moving forward
else
{
// if unobstructed is legal
if (!Board[desitinationRow, destinationColumn].IsOccupied)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
// if first move and unoccipied, can move two steps
if (piece.IsFirstMove && !Board[desitinationRow + move.MoveRow, destinationColumn + move.MoveColumn].IsOccupied)
{
Board[desitinationRow + move.MoveRow, destinationColumn + move.MoveColumn].IsLegal = true;
}
}
}
}
}
}
public void Promotion(Pieces piece, string newPiece)
{
switch (newPiece)
{
case "Rook":
piece.Position.Piece = new Rook(piece.IsWhite, piece.Position);
break;
case "Bishop":
piece.Position.Piece = new Bishop(piece.IsWhite, piece.Position);
break;
case "Knight":
piece.Position.Piece = new Knight(piece.IsWhite, piece.Position);
break;
case "Queen":
piece.Position.Piece = new Queen(piece.IsWhite, piece.Position);
break;
}
// Prevent ChangeStatus() from occuring
piece.Position.IsOccupied = true;
}
// Create reusable method?
private void CheckKnightLegals(Pieces piece)
{
foreach (Move move in piece.PossibleMoves)
{
int desitinationRow = piece.Position.Row + move.MoveRow;
int desitnationColumn = piece.Position.Column + move.MoveColumn;
// Can move anywhere as long as it is of opposite colour or unoccupied
if (IsOnBoard(desitinationRow, desitnationColumn))
{
if (Board[desitinationRow, desitnationColumn].Piece == null)
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, desitnationColumn].Piece.IsWhite))
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
}
}
}
}
// Can make this shorter? (DRY)
// Create method to check each of these and reuse?
// Pawn only move forward, unless piece of opposite colour on diagonal
// Check if path is obstructed? (if piece is blocked, do not move in that direction anymore) for Q, R, B
// Check if K is in check, if so next move must move piece out of check (i.e check if K is on same cell as legal move)
// Check if K is in mate, if so end the game (check all K legal and occupied positions are in opponents legal move)
// Castling, en passant?
// Promotion, when pawn reaches other side of the board, give choice on which piece to choose (B R Q N)
public void FindLegalMoves(Pieces piece)
{
if (piece.Name == "Pawn")
{
foreach (Move move in piece.PossibleMoves)
{
int desitinationRow = piece.Position.Row + move.MoveRow;
int desitnationColumn = piece.Position.Column + move.MoveColumn;
if (IsOnBoard(desitinationRow, desitnationColumn))
{
// move 2 only if first move and empty or occupied by opposite colour and it's the first move
if (Math.Abs(move.MoveRow) == 2)
{
if (piece.IsFirstMove &&
(Board[desitinationRow, desitnationColumn].piece == null ||
IsOppositeColour(piece.IsWhite, Board[desitinationRow, desitnationColumn].piece.IsWhite)))
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
piece.IsFirstMove = false;
}
}
// move diagonally only if it's occupied by opposite colour
else if (desitinationRow != piece.Position.Row && desitnationColumn != piece.Position.Column)
{
if (Board[desitinationRow, desitnationColumn].IsOccupied &&
IsOppositeColour(piece.IsWhite, Board[desitinationRow, desitnationColumn].piece.IsWhite))
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
}
// Moving forward by 1
else
{
if (!Board[desitinationRow, desitnationColumn].IsOccupied ||
IsOppositeColour(piece.IsWhite, Board[desitinationRow, desitnationColumn].piece.IsWhite))
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
}
}
}
}
else if (piece.Name == "King" || piece.Name == "Knight")
{
foreach (Move move in piece.PossibleMoves)
{
int desitinationRow = piece.Position.Row + move.MoveRow;
int desitnationColumn = piece.Position.Column + move.MoveColumn;
if (IsOnBoard(desitinationRow, desitnationColumn))
{
if (Board[desitinationRow, desitnationColumn].piece == null)
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, desitnationColumn].piece.IsWhite))
{
Board[desitinationRow, desitnationColumn].IsLegal = true;
}
}
}
}
}
else if (piece.Name == "Rook")
{
CheckRookObstruction(piece);
}
else if (piece.Name == "Bishop")
{
CheckBishopObstruction(piece);
}
else if (piece.Name == "Queen")
{
CheckRookObstruction(piece);
CheckBishopObstruction(piece);
}
}
private void CheckBishopObstruction(Pieces piece)
{
// backward movement
bool Unobstructed = true;
int movement = 1;
do
{
int desitinationRow = piece.Position.Row + movement;
int destinationColumn = piece.Position.Column + movement;
if (IsOnBoard(desitinationRow, destinationColumn))
{
if (Board[desitinationRow, destinationColumn].piece == null)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
Unobstructed = false;
}
++movement;
}
else
{
Unobstructed = false;
}
}while (Unobstructed);
// forward movement
Unobstructed = true;
movement = 1;
do
{
int desitinationRow = piece.Position.Row - movement;
int destinationColumn = piece.Position.Column + movement;
if (IsOnBoard(desitinationRow, destinationColumn))
{
if (Board[desitinationRow, destinationColumn].piece == null)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
Unobstructed = false;
}
++movement;
}
else
{
Unobstructed = false;
}
}while (Unobstructed);
// left movement
Unobstructed = true;
movement = 1;
do
{
int desitinationRow = piece.Position.Row + movement;
int destinationColumn = piece.Position.Column - movement;
if (IsOnBoard(desitinationRow, destinationColumn))
{
if (Board[desitinationRow, destinationColumn].piece == null)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
Unobstructed = false;
}
++movement;
}
else
{
Unobstructed = false;
}
}while (Unobstructed);
// right movement
Unobstructed = true;
movement = 1;
do
{
int desitinationRow = piece.Position.Row - movement;
int destinationColumn = piece.Position.Column - movement;
if (IsOnBoard(desitinationRow, destinationColumn))
{
if (Board[desitinationRow, destinationColumn].piece == null)
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
else
{
if (IsOppositeColour(piece.IsWhite, Board[desitinationRow, destinationColumn].piece.IsWhite))
{
Board[desitinationRow, destinationColumn].IsLegal = true;
}
Unobstructed = false;
}
++movement;
}
else
{
Unobstructed = false;
}
}while (Unobstructed);
}
/** This takes a string and returns the Player's piece that's name equals the string
* @param a_pieceString - The string we are matching to a piece
* @returns The piece that's name matches the string
* @author Thomas Hooper
* @date August 2019
*/
public Piece ReturnPieceFromString(string a_pieceString)
{
return(Pieces.Find(x => x.Name.Equals(a_pieceString)));
}
/** This method generates all the possible moves the player is able to make
* It goes through each piece and their valid squares and determines if it can
* make each move for each piece and square. It also evaluates if the piece can capture,
* castle or en passant
* @param a_player - The opposing player
* @param a_board - The board the game is played on
* @param a_previousMove - the previous move that was played
* @author Thomas Hooper
* @date July 2019
*/
public void GenerateMoves(Player a_player, Board a_board, Move a_previousMove)
{
List <Move> moves = new List <Move>();
foreach (Piece p in Pieces)
{
foreach (BoardSquare s in p.ValidSquares)
{
#region Just Moving
if (!s.Occupied)
{
moves.Add(new Move(s, p));
}
#endregion
#region Capturing
else
{
if (a_player.Pieces.Exists(x => x.Row == s.Row && x.Column == s.Column)) //BoardSquare Color
{
if (p.AttackingSquares.Exists(x => x.Row == s.Row && x.Column == s.Column) && s.PieceColor != p.Color)
{
Piece capturedPiece = a_player.Pieces.Find(x => x.Row == s.Row && x.Column == s.Column);
moves.Add(new Move(s, p, capturedPiece));
}
}
}
#endregion
}
}
#region En Passant
if (a_previousMove != null)
{
if (a_previousMove.MovingPiece is Pawn && (a_previousMove.MovingPiece.Row == 3 || a_previousMove.MovingPiece.Row == 4))
{
if (Pieces.Exists(x => x is Pawn && x.Row == a_previousMove.MovingPiece.Row))
{
if (a_previousMove.MovingPiece.Color == Color.White && a_previousMove.MovingPiece.Row == 4)
{
if (a_previousMove.OriginalSquare.Row == 6)
{
List <Piece> pawns = Pieces.FindAll(x => x.Row == 4);
foreach (Piece p in pawns)
{
if (Math.Abs(p.Column - a_previousMove.MovingPiece.Column) == 1)
{
BoardSquare square = a_board.ReturnSquare(a_previousMove.OriginalSquare.Row + 1, a_previousMove.OriginalSquare.Column);
moves.Add(new Move(square, p)
{
EnPassant = true
});
}
}
}
}
else if (a_previousMove.MovingPiece.Color == Color.Black && a_previousMove.MovingPiece.Row == 3)
{
if (a_previousMove.OriginalSquare.Row == 1)
{
List <Piece> pawns = Pieces.FindAll(x => x.Row == 3);
foreach (Piece p in pawns)
{
if (Math.Abs(p.Column - a_previousMove.MovingPiece.Column) == 1)
{
BoardSquare square = a_board.ReturnSquare(a_previousMove.OriginalSquare.Row - 1, a_previousMove.OriginalSquare.Column);
moves.Add(new Move(square, p)
{
EnPassant = true
});
}
}
}
}
}
}
}
#endregion
#region Castling
King k = (King)Pieces.Find(x => x is King);
if (!k.HasMoved && !Check)
{
BoardSquare s1 = new BoardSquare();
BoardSquare s2 = new BoardSquare();
BoardSquare s3 = new BoardSquare();
if (Pieces.Exists(x => x is Rook && !x.HasMoved && x.Column == 7))
{
Rook r = (Rook)Pieces.Find(x => x is Rook && !x.HasMoved && x.Column == 7);
s1 = a_board.ReturnSquare(k.Row, k.Column + 1);
s2 = a_board.ReturnSquare(k.Row, k.Column + 2);
if (!s1.Occupied && !s2.Occupied)
{
moves.Add(new Move(s2, k, r, true));
}
}
if (Pieces.Exists(x => x is Rook && !x.HasMoved && x.Column == 0))
{
Rook r = (Rook)Pieces.Find(x => x is Rook && !x.HasMoved && x.Column == 0);
s1 = a_board.ReturnSquare(k.Row, k.Column - 1);
s2 = a_board.ReturnSquare(k.Row, k.Column - 2);
s3 = a_board.ReturnSquare(k.Row, k.Column - 3);
if (!s1.Occupied && !s2.Occupied && !s3.Occupied)
{
moves.Add(new Move(s2, k, r, true));
}
}
}
#endregion
Moves = moves;
}
