public override bool IsAvailable(ChessSquare[,] board, int row, int column, int index)
{
bool canMove = true;
if (board[row, column].Piece.Color == Color)
{
canMove = false;
}
else if (board[row, column].Piece.Color != ChessColor.NONE)
{
if (collision[index] >= 1)
{
canMove = false;
}
collision[index]++;
}
else
{
for (int x = 0; x < 8; ++x)
{
if(collision[x] > 0)
{
canMove = false;
break;
}
}
}
if (this.canMove[index])
{
this.canMove[index] = canMove;
}
return canMove;
}
public bool IsEmpty(ChessSquare[,] board, int row, int column, int index)
{
bool canMove = true;
if (board[row, column].Piece.Color != ChessColor.NONE)
{
canMove = false;
}
if (this.canMove[index] == true)
{
this.canMove[index] = canMove;
}
return canMove;
}
public override bool CheckMovement(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
bool isValid = false;
List<int[]> available = RestrictMovement(board, startX, startY);
for (int x = 0; x < available.Count; ++x)
{
if (available[x][0] == endX && available[x][1] == endY)
{
isValid = true;
}
}
return isValid;
}
public override bool IsAvailable(ChessSquare[,] board, int row, int column, int index)
{
bool canMove = true;
if (board[row, column].Piece.Color == Color && board[row, column].Piece.Color != ChessColor.NONE)
{
canMove = false;
}
if (this.canMove[index] == true)
{
this.canMove[index] = canMove;
}
return canMove;
}
/// <summary>
/// Creates a board of empty board squares.
/// </summary>
public void CreateSquares()
{
//Board
Squares = new ChessSquare[8, 8];
ChessColor color = ChessColor.LIGHT;
//Empty squares
for (int x = 0; x < 8; ++x)
{
for (int y = 0; y < 8; y++)
{
Squares[x, y] = new ChessSquare(x, y, color);
//Spaces
if (Squares[x, y].Piece == null)
{
Squares[x, y].Piece = new Space();
}
color = ChangeColor(color);
}
color = ChangeColor(color);
}
}
public bool CastleingRightPosition(ChessSquare[,] board, int x)
{
bool inPosition = false;
int position = 0;
if (board[x, 4].Piece.GetType() == typeof(King))
{
if (((King)board[x, 4].Piece).moveAmount == 0)
{
position++;
}
}
if (board[x, 7].Piece.GetType() == typeof(Rook))
{
if (((Rook)board[x, 7].Piece).moveAmount == 0)
{
position++;
}
}
if (position == 2)
{
inPosition = true;
}
return inPosition;
}
public override List<int[]> Search(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
bool isMoveSet = false;
List<int[]> available = new List<int[]>();
if (startX + 1 < 8)//down
{
available.Add(new int[] { startX + 1, startY });
if (startX + 1 == endX && startY == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
if (isMoveSet == false)
{
if (startX + 1 < 8 && startY - 1 >= 0)//down Left
{
available.Add(new int[] { startX + 1, startY - 1 });
if (startX + 1 == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 1 < 8 && startY - 1 >= 0)//down Left
{
available.Add(new int[] { startX + 1, startY - 1 });
if (startX + 1 == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 1 < 8 && startY + 1 < 8)//down right
{
available.Add(new int[] { startX + 1, startY + 1 });
if (startX + 1 == endX && startY + 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startY + 1 < 8)//right
{
available.Add(new int[] { startX, startY + 1 });
if (startX == endX && startY + 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX - 1 >= 0)//up
{
available.Add(new int[] { startX - 1, startY });
if (startX - 1 == endX && startY == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX - 1 >= 0 && startY - 1 >= 0)//up left
{
available.Add(new int[] { startX - 1, startY - 1 });
if (startX - 1 == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX - 1 >= 0 && startY + 1 < 8)//up right
{
available.Add(new int[] { startX - 1, startY + 1 });
if (startX - 1 == endX && startY + 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startY - 1 >= 0)//left
{
available.Add(new int[] { startX, startY - 1 });
if (startX == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
ResetSearch(available, isMoveSet);
}
return available;
}
public bool IsPossibleToCastle(ChessSquare[,] board, int x, bool isLeft)
{
bool isPossible = false;
bool leftCastle = false;
bool rightCastle = false;
int caslteLeft = 0;
int caslteRight = 0;
for (int y = 0; y < 4; ++y)
{
if(4 - y >= 0)
{
if (board[x, 4 - y].Piece.Color == ChessColor.NONE)
{
caslteLeft++;
}
}
if (4 + y < 8)
{
if (y != 3)
{
if (board[x, 4 + y].Piece.Color == ChessColor.NONE)
{
caslteRight++;
}
}
}
}
if(isLeft == true)
{
if (caslteLeft == 3)
{
leftCastle = CastleingLeftPosition(board, x);
if (leftCastle == true)
{
isPossible = true;
}
}
}
else
{
if (caslteRight == 2)
{
rightCastle = CastleingRightPosition(board, x);
if (rightCastle == true)
{
isPossible = true;
}
}
}
return isPossible;
}
public override List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY)
{
ResetMovement();
List<int[]> available = new List<int[]>();
bool isAvailable = false;
bool isCastleing = false;
bool isLeft = false;
if (startX + 1 < 8)//down 1
{
isAvailable = IsAvailable(board, startX + 1, startY, 0);
if (isAvailable == true)
{
if(canMove[0] == true)
{
available.Add(new int[] { startX + 1, startY });
}
}
}
if (startX + 1 < 8 && startY - 1 >= 0)//down Left 1
{
isAvailable = IsAvailable(board, startX + 1, startY - 1, 1);
if (isAvailable == true)
{
if (canMove[1] == true)
{
available.Add(new int[] { startX + 1, startY - 1 });
}
}
}
if (startX + 1 < 8 && startY + 1 < 8)//down right 1
{
isAvailable = IsAvailable(board, startX + 1, startY + 1, 2);
if (isAvailable == true)
{
if (canMove[2] == true)
{
available.Add(new int[] { startX + 1, startY + 1 });
}
}
}
if (startY + 1 < 8)//right 1
{
isAvailable = IsAvailable(board, startX, startY + 1, 3);
if (isAvailable == true)
{
if (canMove[3] == true)
{
available.Add(new int[] { startX, startY + 1 });
}
}
isCastleing = IsPossibleToCastle(board, startX, isLeft);
if (isCastleing == true)
{
available.Add(new int[] { startX, startY + 2 });
}
}
if (startX - 1 >= 0)//up 1
{
isAvailable = IsAvailable(board, startX - 1, startY, 4);
if (isAvailable == true)
{
if (canMove[4] == true)
{
available.Add(new int[] { startX - 1, startY });
}
}
}
if (startX - 1 >= 0 && startY - 1 >= 0)//up left 1
{
isAvailable = IsAvailable(board, startX - 1, startY - 1, 5);
if (isAvailable == true)
{
if (canMove[5] == true)
{
available.Add(new int[] { startX - 1, startY - 1 });
}
}
}
if (startX - 1 >= 0 && startY + 1 < 8)//up right 1
{
isAvailable = IsAvailable(board, startX - 1, startY + 1, 6);
if (isAvailable == true)
{
if (canMove[6] == true)
{
available.Add(new int[] { startX - 1, startY + 1 });
}
}
}
if (startY - 1 >= 0)//left 1
{
isAvailable = IsAvailable(board, startX, startY - 1, 7);
if (isAvailable == true)
{
if (canMove[7] == true)
{
available.Add(new int[] { startX, startY - 1 });
}
}
isLeft = true;
isCastleing = IsPossibleToCastle(board, startX, isLeft);
if (isCastleing == true)
{
available.Add(new int[] { startX, startY - 2 });
}
}
return available;
}
public override List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY)
{
return new List<int[]>();
}
private bool CheckEnPassant(ChessSquare[,] board, int row, int column, int index)
{
bool canMove = false;
if (board[row, column].Piece is Pawn)
{
if (board[row, column].Piece.Color != Color && board[row, column].Piece.Color != ChessColor.NONE)
{
if (((Pawn)board[row, column].Piece)._moveAmount == 1)
{
if (((Pawn)board[row, column].Piece)._moves == 2)
{
if (((Pawn)board[row, column].Piece).chance == true)
{
canMove = true;
}
}
}
}
}
if (this.canMove[index] == false)
{
this.canMove[index] = canMove;
}
return canMove;
}
/// <summary> /// Checks if movement does not go off the board. /// </summary> /// <param name="start">A int array containing the starting postion for the piece.</param> /// <returns>Returns a list of valid movements for the piece.</returns> public abstract List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY);
/// <summary> /// Checks if the desired location is an empty square and a piece of a different color. /// </summary> /// <param name="board">A 2-Dimesional array of ints representing the board.</param> /// <param name="end">A int array containg the end position for the piece.</param> /// <returns> /// True: If the desired square is empty or has an enemy piece. /// False: If the desired square already contains a friendly piece. /// </returns> public abstract bool CheckMovement(ChessSquare[,] board, int startX, int startY, int endX, int endY);
/// <summary>
/// Removes the pawn that got
/// </summary>
/// <param name="grid"></param>
/// <param name="board"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void EnPassant(UniformGrid grid, ChessSquare[,] board, int x, int y)
{
if ((int)board[x, y].Piece.Color != Turn)
{
if (((Pawn)board[x, y].Piece)._moveAmount == 1)
{
board[x, y].Piece = new Space();
((Square)grid.Children[(x * 8) + y]).Panel.Children.Clear();
((Square)grid.Children[(x * 8) + y]).Pic = null;
}
}
}
public override bool CheckMovement(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
ResetMovement();
bool isValid = false;
List<int[]> available = RestrictMovement(board, startX, startY);
for (int x = 0; x < available.Count; ++x)
{
if (available[x][0] == endX && available[x][1] == endY)
{
isValid = true;
_moveAmount++;
_moves = startX - endX;
if (Color == ChessColor.DARK)
{
_moves = endX - startX;
}
if (_moves == 2)
{
chance = true;
}
}
}
return isValid;
}
/// <summary>
/// Checks if the current piece is a pawn.
/// Checks if the sides of the piece is not the end of the board.
/// Checks the color of the selected piece.
/// Checks if the sides of the selected piece is a pawn.
/// </summary>
/// <param name="board"></param>
/// <param name="x1">The selected piece's x coordinate</param>
/// <param name="y1">The selected piece's y coordinate</param>
public void CheckEnPassant(ChessSquare[,] board, int x1, int y1)
{
if (board[x1, y1].Piece.GetType() == typeof(Pawn))
{
if ((x1 + 1) < 8)
{
if (board[x1, y1].Piece.Color == ChessColor.LIGHT)
{
if (board[x1 + 1, y1].Piece.GetType() == typeof(Pawn))
{
EnPassant(g, Board.Squares, x1 + 1, y1);
}
}
}
if ((x1 - 1) >= 0)
{
if (board[x1, y1].Piece.Color == ChessColor.DARK)
{
if (board[x1 - 1, y1].Piece.GetType() == typeof(Pawn))
{
EnPassant(g, Board.Squares, x1 - 1, y1);
}
}
}
}
}
/// <summary> /// Moves a piece from a starting location to a desired location. /// </summary> /// <param name="board">A 2-Dimesional array of ints representing the board.</param> /// <param name="start">A int array containing the starting postion for the piece.</param> /// <param name="end">A int array containg the end position for the piece.</param> public abstract void MovePiece(ChessSquare[,] board, int startX, int startY, int endX, int endY);
/// <summary> /// Checks if a movement option for a piece is empty or has an enemy piece. /// If it has a ally piece, then it can not move pass the piece unless it is /// a knight. /// </summary> /// <param name="board">A 2-Dimesional array of ints representing the board.</param> /// <param name="row">A int representing a row from the board.</param> /// <param name="column">A int representing a column number fromthe board.</param> /// <param name="index">A int representing a index number for the bool array.</param> /// <returns></returns> public abstract bool IsAvailable(ChessSquare[,] board, int row, int column, int index);
public override List<int[]> Test(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
bool isMoveSet = false;
List<int[]> available = new List<int[]>();
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8)//down
{
available.Add(new int[] { startX + x, startY });
if (startX + x == endX && startY == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
if(isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8 && startY - x >= 0)//down Left
{
available.Add(new int[] { startX + x, startY - x });
if (startX + x == endX && startY - x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8 && startY + x < 8)//down right
{
available.Add(new int[] { startX + x, startY + x });
if (startX + x == endX && startY + x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startY + x < 8)//right
{
available.Add(new int[] { startX, startY + x });
if (startX == endX && startY + x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0)//up
{
available.Add(new int[] { startX - x, startY });
if (startX - x == endX && startY == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0 && startY - x >= 0)//up left
{
available.Add(new int[] { startX - x, startY - x });
if (startX - x == endX && startY - x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0 && startY + x < 8)//up right
{
available.Add(new int[] { startX - x, startY + x });
if (startX - x == endX && startY + x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
for (int x = 1; x < 8; ++x)
{
if (startY - x >= 0)//left
{
available.Add(new int[] { startX, startY - x });
if (startX == endX && startY - x == endY)
{
isMoveSet = true;
break;
}
}
}
Test2(available, isMoveSet);
}
return available;
}
public override bool IsAvailable(ChessSquare[,] board, int row, int column, int index)
{
return false;
}
public override List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY)
{
ResetMovement();
List<int[]> available = new List<int[]>();
bool isAvailable = false;
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8)//down
{
isAvailable = IsAvailable(board, startX + x, startY, 0);
if (isAvailable == true)
{
if (canMove[0] == true)
{
available.Add(new int[] { startX + x, startY });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8 && startY - x >= 0)//down Left
{
isAvailable = IsAvailable(board, startX + x, startY - x, 1);
if (isAvailable == true)
{
if (canMove[1] == true)
{
available.Add(new int[] { startX + x, startY - x });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startX + x < 8 && startY + x < 8)//down right
{
isAvailable = IsAvailable(board, startX + x, startY + x, 2);
if (isAvailable == true)
{
if (canMove[2] == true)
{
available.Add(new int[] { startX + x, startY + x });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startY + x < 8)//right
{
isAvailable = IsAvailable(board, startX, startY + x, 3);
if (isAvailable == true)
{
if (canMove[3] == true)
{
available.Add(new int[] { startX, startY + x });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0)//up
{
isAvailable = IsAvailable(board, startX - x, startY, 4);
if (isAvailable == true)
{
if (canMove[4] == true)
{
available.Add(new int[] { startX - x, startY });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0 && startY - x >= 0)//up left
{
isAvailable = IsAvailable(board, startX - x, startY - x, 5);
if (isAvailable == true)
{
if (canMove[5] == true)
{
available.Add(new int[] { startX - x, startY - x });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startX - x >= 0 && startY + x < 8)//up right
{
isAvailable = IsAvailable(board, startX - x, startY + x, 6);
if (isAvailable == true)
{
if (canMove[6] == true)
{
available.Add(new int[] { startX - x, startY + x });
}
}
}
}
collision = new int[8];
for (int x = 1; x < 8; ++x)
{
if (startY - x >= 0)//left
{
isAvailable = IsAvailable(board, startX, startY - x, 7);
if (isAvailable == true)
{
if (canMove[7] == true)
{
available.Add(new int[] { startX, startY - x });
}
}
}
}
return available;
}
public abstract List<int[]> Test(ChessSquare[,] board, int startX, int startY, int endX, int endY);
public override void MovePiece(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
board[endX, endY].Piece = board[startX, startY].Piece;
board[startX, startY].Piece = new Space();
}
public override List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY)
{
List<int[]> available = new List<int[]>();
bool isAvailable = false;
if (Color == ChessColor.DARK)
{
if (startX + 1 < 8)//down 1
{
isAvailable = IsEmpty(board, startX + 1, startY, 0);
if (isAvailable == true)
{
if (canMove[0] == true)
{
available.Add(new int[] { startX + 1, startY });
}
}
}
if (_moves == 0)//down 2
{
isAvailable = IsEmpty(board, startX + 2, startY, 6);
if (isAvailable == true)
{
if (canMove[0] == true)
{
available.Add(new int[] { startX + 2, startY });
}
}
}
if (startX + 1 < 8 && startY - 1 >= 0)//down Left 1
{
if (board[startX + 1, startY - 1].Piece.Color != Color && board[startX + 1, startY - 1].Piece.Color != ChessColor.NONE)
{
isAvailable = IsAvailable(board, startX + 1, startY - 1, 1);
if (isAvailable == true)
{
if (canMove[1] == true)
{
available.Add(new int[] { startX + 1, startY - 1 });
}
}
}
}
if (startX + 1 < 8 && startY + 1 < 8)//down right 1
{
if (board[startX + 1, startY + 1].Piece.Color != Color && board[startX + 1, startY + 1].Piece.Color != ChessColor.NONE)
{
isAvailable = IsAvailable(board, startX + 1, startY + 1, 2);
if (isAvailable == true)
{
if (canMove[2] == true)
{
available.Add(new int[] { startX + 1, startY + 1 });
}
}
}
}
}
else
{
if (startX - 1 >= 0)//up 1
{
isAvailable = IsEmpty(board, startX - 1, startY, 3);
if (isAvailable == true)
{
if (canMove[3] == true)
{
available.Add(new int[] { startX - 1, startY });
}
}
}
if (_moves == 0)//up 2
{
isAvailable = IsEmpty(board, startX - 2, startY, 7);
if (isAvailable == true)
{
if (canMove[3] == true)
{
available.Add(new int[] { startX - 2, startY });
}
}
}
if (startX - 1 >= 0 && startY - 1 >= 0)//up left 1
{
if (board[startX - 1, startY - 1].Piece.Color != Color && board[startX - 1, startY - 1].Piece.Color != ChessColor.NONE)
{
isAvailable = IsAvailable(board, startX - 1, startY - 1, 4);
if (isAvailable == true)
{
if (canMove[4] == true)
{
available.Add(new int[] { startX - 1, startY - 1 });
}
}
}
}
if (startX - 1 >= 0 && startY + 1 < 8)//up right 1
{
if (board[startX - 1, startY + 1].Piece.Color != Color && board[startX - 1, startY + 1].Piece.Color != ChessColor.NONE)
{
isAvailable = IsAvailable(board, startX - 1, startY + 1, 5);
if (isAvailable == true)
{
if (canMove[5] == true)
{
available.Add(new int[] { startX - 1, startY + 1 });
}
}
}
}
}
return available;
}
public override bool CheckMovement(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
return false;
}
public override List<int[]> Test(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
bool isMoveSet = false;
List<int[]> available = new List<int[]>();
if (startX - 2 >= 0 && startY - 1 >= 0)//up 2 left 1
{
available.Add(new int[] { startX - 2, startY - 1 });
if (startX - 2 == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
if (isMoveSet == false)
{
if (startX - 2 >= 0 && startY + 1 < 8)//up 2 right 1
{
available.Add(new int[] { startX - 2, startY + 1 });
if (startX - 2 == endX && startY + 1 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX - 1 >= 0 && startY - 2 >= 0)//up 1 left 2
{
available.Add(new int[] { startX - 1, startY - 2 });
if (startX - 1 == endX && startY - 2 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX - 1 >= 0 && startY + 2 < 8)//up 1 right 2
{
available.Add(new int[] { startX - 1, startY + 2 });
if (startX - 1 == endX && startY + 2 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 2 < 8 && startY - 1 >= 0)//down 2 left 1
{
available.Add(new int[] { startX + 2, startY - 1 });
if (startX + 2 == endX && startY - 1 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 2 < 8 && startY + 1 < 8)//down 2 right 1
{
available.Add(new int[] { startX + 2, startY + 1 });
if (startX + 2 == endX && startY + 1 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 1 < 8 && startY - 2 >= 0)//down 1 left 2
{
available.Add(new int[] { startX + 1, startY - 2 });
if (startX + 1 == endX && startY - 2 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
if (isMoveSet == false)
{
if (startX + 1 < 8 && startY + 2 < 8)//down 1 right 2
{
available.Add(new int[] { startX + 1, startY + 2 });
if (startX + 1 == endX && startY + 2 == endY)
{
isMoveSet = true;
}
}
Test2(available, isMoveSet);
}
return available;
}
public override void MovePiece(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
}
public override List<int[]> RestrictMovement(ChessSquare[,] board, int startX, int startY)
{
ResetMovement();
List<int[]> available = new List<int[]>();
bool isAvailable = false;
if (startX - 2 >= 0 && startY - 1 >= 0)//up 2 left 1
{
isAvailable = IsAvailable(board, startX - 2, startY - 1, 0);
if (isAvailable == true)
{
available.Add(new int[] { startX - 2, startY - 1 });
}
}
if (startX - 2 >= 0 && startY + 1 < 8)//up 2 right 1
{
isAvailable = IsAvailable(board, startX - 2, startY + 1, 1);
if (isAvailable == true)
{
available.Add(new int[] { startX - 2, startY + 1 });
}
}
if (startX - 1 >= 0 && startY - 2 >= 0)//up 1 left 2
{
isAvailable = IsAvailable(board, startX - 1, startY - 2, 2);
if (isAvailable == true)
{
available.Add(new int[] { startX - 1, startY - 2 });
}
}
if (startX - 1 >= 0 && startY + 2 < 8)//up 1 right 2
{
isAvailable = IsAvailable(board, startX - 1, startY + 2, 3);
if (isAvailable == true)
{
available.Add(new int[] { startX - 1, startY + 2 });
}
}
if (startX + 2 < 8 && startY - 1 >= 0 )//down 2 Left 1
{
isAvailable = IsAvailable(board, startX + 2, startY - 1, 4);
if (isAvailable == true)
{
available.Add(new int[] { startX + 2, startY - 1 });
}
}
if (startX + 2 < 8 && startY + 1 < 8)//down 2 right 1
{
isAvailable = IsAvailable(board, startX + 2, startY + 1, 5);
if (isAvailable == true)
{
available.Add(new int[] { startX + 2, startY + 1 });
}
}
if (startX + 1 < 8 && startY - 2 >= 0)//down 1 Left 2
{
isAvailable = IsAvailable(board, startX + 1, startY - 2, 6);
if (isAvailable == true)
{
available.Add(new int[] { startX + 1, startY - 2 });
}
}
if (startX + 1 < 8 && startY + 2 < 8)//down 1 right 2
{
isAvailable = IsAvailable(board, startX + 1, startY + 2, 7);
if (isAvailable == true)
{
available.Add(new int[] { startX + 1, startY + 2 });
}
}
return available;
}
public override List<int[]> Search(ChessSquare[,] board, int startX, int startY, int endX, int endY)
{
return new List<int[]>();
}
public List<int[]> Attacks(ChessSquare[,] board, int startX, int startY)
{
ResetMovement();
List<int[]> available = new List<int[]>();
bool isAvailable = false;
if (Color == ChessColor.DARK)
{
if (startX + 1 < 8 && startY - 1 >= 0)//down Left 1
{
if (board[startX + 1, startY - 1].Piece.Color != Color)
{
isAvailable = IsAvailable(board, startX + 1, startY - 1, 1);
if (isAvailable == true)
{
if (canMove[1] == true)
{
available.Add(new int[] { startX + 1, startY - 1 });
}
}
}
}
if (startX + 1 < 8 && startY + 1 < 8)//down right 1
{
if (board[startX + 1, startY + 1].Piece.Color != Color)
{
isAvailable = IsAvailable(board, startX + 1, startY + 1, 2);
if (isAvailable == true)
{
if (canMove[2] == true)
{
available.Add(new int[] { startX + 1, startY + 1 });
}
}
}
}
}
else
{
if (startX - 1 >= 0 && startY - 1 >= 0)//up left 1
{
if (board[startX - 1, startY - 1].Piece.Color != Color)
{
isAvailable = IsAvailable(board, startX - 1, startY - 1, 4);
if (isAvailable == true)
{
if (canMove[4] == true)
{
available.Add(new int[] { startX - 1, startY - 1 });
}
}
}
}
if (startX - 1 >= 0 && startY + 1 < 8)//up right 1
{
if (board[startX - 1, startY + 1].Piece.Color != Color)
{
isAvailable = IsAvailable(board, startX - 1, startY + 1, 5);
if (isAvailable == true)
{
if (canMove[5] == true)
{
available.Add(new int[] { startX - 1, startY + 1 });
}
}
}
}
}
return available;
}