public static void WasDoubleJump(DataStructure.Point prev, DataStructure.Point current)
{
if (Math.Abs(prev.i - current.i) > 1)
{
EnPassant = current;
}
}
public static bool IsOpponent(DataStructure.Point possition, int[,] boardMatrix)
{
try
{
//if (int)color % 2 != 0 it means its 1 therefore an odd number = white.
//if (color == (int)DataStructure.Color.white)
if (EnvironmentVariables.Player == DataStructure.Color.white)
{
//than if value on the possition is equal to 0 (even number) than its black and can be kicked out
//value needs to be bigger than 0 as it is empty value.
if (boardMatrix[possition.i, possition.j] > 0 && boardMatrix[possition.i, possition.j] % 2 == 0)
{
return(true);
}
}
else
{
//than if value on the possition is equal to 1 (odd number) than its white and can be kicked out
if (boardMatrix[possition.i, possition.j] % 2 == 1)
{
return(true);
}
}
}
catch (Exception e)
{
Console.WriteLine("IsOpponent methid failure: Values of x and y axis needs to be between 0 to 7.");
Console.WriteLine(e.ToString());
}
return(false);
}
public static void KickingOutEnPassant(DataStructure.Point prev, DataStructure.Point current, int[,] boardMatrix)
{
if (current.j == EnPassant.j && prev.j != current.j)
{
if (current.i != EnPassant.i)
{
boardMatrix[EnPassant.i, EnPassant.j] = (int)DataStructure.Figures.empty;
}
}
}
public List <DataStructure.Point> FindPossibleMoves(DataStructure.Point possition, int[,] boardMatrix)
{
if (EnvironmentVariables.Player == DataStructure.Color.white)
{
return(FindMovesWhite(possition, boardMatrix));
}
else
{
return(FindMovesBlack(possition, boardMatrix));
}
}
/// <summary>
/// Method that moves figures on the board
/// </summary>
/// <param name="currentPosition">Current position of the figure</param>
/// <param name="newPosition">Next position of the figure</param>
protected void MoveFigure(DataStructure.Point currentPosition, DataStructure.Point newPosition)
{
try
{
boardMatrix[newPosition.i, newPosition.j] = boardMatrix[currentPosition.i, currentPosition.j];
boardMatrix[currentPosition.i, currentPosition.j] = 0;
}
catch (Exception e)
{
Console.WriteLine("MoveFigure method failure: Values of x and y axis needs to be between 0 to 7.");
Console.WriteLine(e.ToString());
}
}
/// <summary>
/// Check if pawn landed on the last row of the column. If yes the promote to queen (for now)
/// </summary>
/// <param name="possition"></param>
/// <param name="boardMatrix"></param>
public static void EndofTheColumn(DataStructure.Point possition, int[,] boardMatrix)
{
//TODO UX,UI etc
if (possition.i == 0)
{
boardMatrix[possition.i, possition.j] = (int)DataStructure.Figures.black_queen;
}
else if (possition.i == 7)
{
boardMatrix[possition.i, possition.j] = (int)DataStructure.Figures.white_queen;
}
EnPassant.i = -2;
EnPassant.j = -2;
}
static bool KnightCanMove(DataStructure.Point possition, int[,] boardMatrix, DataStructure.Color color)
{
if (Validation.IsEmpty(possition, boardMatrix))
{
return(true);
}
else
{
if (Validation.IsOpponent(possition, boardMatrix))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Find out what color is a selected piece.
/// </summary>
/// <param name="selectedField">x,y coordinates for selected field</param>
/// <param name="boardMatrix">matrix itself</param>
/// <returns>Color of the selected figure, or that no figure was selected (empty)</returns>
public static DataStructure.Color FigureColor(DataStructure.Point selectedField, int[,] boardMatrix)
{
if (boardMatrix[selectedField.i, selectedField.j] == 0)
{
return(DataStructure.Color.empty);
}
if (boardMatrix[selectedField.i, selectedField.j] % 2 == (int)DataStructure.Color.white)
{
return(DataStructure.Color.white);
}
else
{
return(DataStructure.Color.black);
}
}
/// <summary>
/// Method to determinade if a field is empty.
/// </summary>
/// <param name="possition">Position to move.</param>
/// <returns></returns>
public static bool IsEmpty(DataStructure.Point possition, int[,] boardMatrix)
{
try
{
if (boardMatrix[possition.i, possition.j] == 0)
{
return(true);
}
}
catch (Exception e)
{
Console.WriteLine("IsEmpty methid failure: Values of x and y axis needs to be between 0 to 7.");
Console.WriteLine(e.ToString());
}
return(false);
}
/// <summary>
/// Method for validating a position. It has to be matrix 0 to 7 in x and y axis.
/// </summary>
/// <param name="possition">position to be validated</param>
/// <returns></returns>
public static bool IsValidPosition(DataStructure.Point possition)
{
try
{
if (possition.i < 0 || possition.i > 7)
{
return(false);
}
else if (possition.j < 0 || possition.j > 7)
{
return(false);
}
}
catch (Exception e)
{
Console.WriteLine("IsValidPosition method failure: Values of x and y axis needs to be between 0 to 7.");
Console.WriteLine(e.ToString());
}
return(true);
}
public static bool IsOpponent(DataStructure.Point enemyPossition, DataStructure.Point allyPossition, int[,] boardMatrix)
{
try
{
if (boardMatrix[enemyPossition.i, enemyPossition.j] != (int)DataStructure.Figures.empty)
{
if (boardMatrix[enemyPossition.i, enemyPossition.j] % 2 != boardMatrix[allyPossition.i, allyPossition.j] % 2)
{
return(true);
}
}
////if (int)color % 2 != 0 it means its 1 therefore an odd number = white.
//if ((int)color % 2 != 0)
//{
// //than if value on the possition is equal to 0 (even number) than its black and can be kicked out
// //value needs to be bigger than 0 as it is empty value.
// if (boardMatrix[possition.i, possition.j] > 0 && boardMatrix[possition.i, possition.j] % 2 == 0)
// {
// return true;
// }
//}
//else
//{
// //than if value on the possition is equal to 1 (odd number) than its white and can be kicked out
// if (boardMatrix[possition.i, possition.j] % 2 == 1)
// {
// return true;
// }
//}
}
catch (Exception e)
{
Console.WriteLine("IsOpponent methid failure: Values of x and y axis needs to be between 0 to 7.");
Console.WriteLine(e.ToString());
}
return(false);
}
static List <DataStructure.Point> FindMovesBlack(DataStructure.Point possition, int[,] boardMatrix)
{
List <DataStructure.Point> possiblePossitions = new List <DataStructure.Point>();
DataStructure.Point p;
p = new DataStructure.Point(possition.i + 2, possition.j - 1);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i + 1, possition.j - 2);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i - 1, possition.j - 2);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i - 2, possition.j - 1);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i - 2, possition.j + 1);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i - 1, possition.j + 2);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i + 1, possition.j + 2);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i + 2, possition.j + 1);
if (Validation.IsValidPosition(p))
{
if (KnightCanMove(p, boardMatrix, DataStructure.Color.black))
{
possiblePossitions.Add(p);
}
}
return(possiblePossitions);
}
/// <summary>
/// color of the fields are set.
/// This method set correct color of the figures and background as of actual matrix which is saved in myCollection;
/// </summary>
private void DrawBackground()
{
myCollection = new Dictionary <string, DataStructure.Point>();
DataStructure.Point p = new DataStructure.Point();
int k = 0;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if ((i + j) % 2 == 0)
{
switch (boardMatrix[i, j])
{
case (int)DataStructure.Figures.empty:
listOfControllers[k].BackColor = Color.White;
listOfControllers[k].Image = null;
break;
case (int)DataStructure.Figures.white_pawn:
listOfControllers[k].Image = Properties.Resources.white_pawn_white;
break;
case (int)DataStructure.Figures.black_pawn:
listOfControllers[k].Image = Properties.Resources.black_pawn_white;
break;
case (int)DataStructure.Figures.white_rock:
listOfControllers[k].Image = Properties.Resources.white_rock_white;
break;
case (int)DataStructure.Figures.black_rock:
listOfControllers[k].Image = Properties.Resources.black_rock_white;
break;
case (int)DataStructure.Figures.white_knight:
listOfControllers[k].Image = Properties.Resources.white_knight_white;
break;
case (int)DataStructure.Figures.black_knight:
listOfControllers[k].Image = Properties.Resources.black_knight_white;
break;
case (int)DataStructure.Figures.white_bishop:
listOfControllers[k].Image = Properties.Resources.white_bishop_white;
break;
case (int)DataStructure.Figures.black_bishop:
listOfControllers[k].Image = Properties.Resources.black_bishop_white;
break;
case (int)DataStructure.Figures.white_queen:
listOfControllers[k].Image = Properties.Resources.white_queen_white;
break;
case (int)DataStructure.Figures.black_queen:
listOfControllers[k].Image = Properties.Resources.black_queen_white;
break;
case (int)DataStructure.Figures.white_king:
listOfControllers[k].Image = Properties.Resources.white_king_white;
break;
case (int)DataStructure.Figures.black_king:
listOfControllers[k].Image = Properties.Resources.black_King_white;
break;
default:
break;
}
}
else
{
switch (boardMatrix[i, j])
{
case (int)DataStructure.Figures.empty:
listOfControllers[k].BackColor = Color.RosyBrown;
listOfControllers[k].Image = null;
break;
case (int)DataStructure.Figures.white_pawn:
listOfControllers[k].Image = Properties.Resources.white_pawn_brown;
break;
case (int)DataStructure.Figures.black_pawn:
listOfControllers[k].Image = Properties.Resources.black_pawn_brown;
break;
case (int)DataStructure.Figures.white_rock:
listOfControllers[k].Image = Properties.Resources.white_rock_brown;
break;
case (int)DataStructure.Figures.black_rock:
listOfControllers[k].Image = Properties.Resources.black_rock_brown;
break;
case (int)DataStructure.Figures.white_knight:
listOfControllers[k].Image = Properties.Resources.white_knight_brown;
break;
case (int)DataStructure.Figures.black_knight:
listOfControllers[k].Image = Properties.Resources.black_knight_brown;
break;
case (int)DataStructure.Figures.white_bishop:
listOfControllers[k].Image = Properties.Resources.white_bishop_brown;
break;
case (int)DataStructure.Figures.black_bishop:
listOfControllers[k].Image = Properties.Resources.black_bishop_brown;
break;
case (int)DataStructure.Figures.white_queen:
listOfControllers[k].Image = Properties.Resources.white_queen_brown;
break;
case (int)DataStructure.Figures.black_queen:
listOfControllers[k].Image = Properties.Resources.black_queen_brown;
break;
case (int)DataStructure.Figures.white_king:
listOfControllers[k].Image = Properties.Resources.white_king_brown;
break;
case (int)DataStructure.Figures.black_king:
listOfControllers[k].Image = Properties.Resources.black_King_brown;
break;
default:
break;
}
}
p.i = i;
p.j = j;
myCollection.Add(listOfControllers[k].Name.ToString(), p);
k++;
}
}
}
static List <DataStructure.Point> FindMovesWhite(DataStructure.Point possition, int[,] boardMatrix)
{
List <DataStructure.Point> possiblePossitions = new List <DataStructure.Point>();
DataStructure.Point p;
for (int i = possition.i - 1; i > -1; i--)
{
p = new DataStructure.Point(i, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int i = possition.i + 1; i < 8; i++)
{
p = new DataStructure.Point(i, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int j = possition.j - 1; j > -1; j--)
{
p = new DataStructure.Point(possition.i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int j = possition.j + 1; j < 8; j++)
{
p = new DataStructure.Point(possition.i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
try
{
int i = possition.i - 1;
int j = possition.j - 1;
while (i > -1 && j > -1)
{
p = new DataStructure.Point(i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
i--;
j--;
}
i = possition.i - 1;
j = possition.j + 1;
while (i > -1 && j < 8)
{
p = new DataStructure.Point(i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
i--;
j++;
}
i = possition.i + 1;
j = possition.j - 1;
while (i < 8 && j > -1)
{
p = new DataStructure.Point(i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
i++;
j--;
}
i = possition.i + 1;
j = possition.j + 1;
while (i < 8 && j < 8)
{
p = new DataStructure.Point(i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
i++;
j++;
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
return(possiblePossitions);
}
/// <summary>
/// Checks if selectedField is in possiblePossitions
/// </summary>
/// <param name="possiblePossitions">list of x,y coordinates</param>
/// <param name="selectedField">one x,y coordinate. </param>
/// <returns>true/false based if selectedfield x,y coordinate is in the list of possiblePossitions coordinates</returns>
public static bool IsItHighlightedField(List <DataStructure.Point> possiblePossitions, DataStructure.Point selectedField)
{
foreach (DataStructure.Point p in possiblePossitions)
{
if (p.i == selectedField.i && p.j == selectedField.j)
{
return(true);
}
}
return(false);
}
void SelectUnselectPiece(PictureBox oBox)
{
//if figure is picked conteniu.
if (!pickedFlag)
{
//if player is white conteniu
if (EnvironmentVariables.Player == DataStructure.Color.white)
{
//save coordination data to variable and check what piece was picked up.
pickedPiece.i = myCollection[oBox.Name].i;
pickedPiece.j = myCollection[oBox.Name].j;
if (Validation.FigureColor(pickedPiece, boardMatrix) == DataStructure.Color.white)
{
pickedFlag = true;
switch (boardMatrix[myCollection[oBox.Name].i, myCollection[oBox.Name].j])
{
case (int)DataStructure.Figures.white_pawn:
possiblePossitions = pawn.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.white_rock:
possiblePossitions = rock.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.white_knight:
possiblePossitions = knight.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.white_bishop:
possiblePossitions = bishopcs.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.white_queen:
possiblePossitions = queen.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.white_king:
possiblePossitions = king.FindPossibleMoves(pickedPiece, boardMatrix);
break;
default:
break;
}
DrawBackground();
HighligtSelectedPiece(oBox);
}
}
else
{
pickedPiece.i = myCollection[oBox.Name].i;
pickedPiece.j = myCollection[oBox.Name].j;
if (Validation.FigureColor(pickedPiece, boardMatrix) == DataStructure.Color.black)
{
pickedFlag = true;
switch (boardMatrix[myCollection[oBox.Name].i, myCollection[oBox.Name].j])
{
case (int)DataStructure.Figures.black_pawn:
possiblePossitions = pawn.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.black_rock:
possiblePossitions = rock.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.black_knight:
possiblePossitions = knight.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.black_bishop:
possiblePossitions = bishopcs.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.black_queen:
possiblePossitions = queen.FindPossibleMoves(pickedPiece, boardMatrix);
break;
case (int)DataStructure.Figures.black_king:
possiblePossitions = king.FindPossibleMoves(pickedPiece, boardMatrix);
break;
default:
break;
}
DrawBackground();
HighligtSelectedPiece(oBox);
}
}
}
else
{
//if clicked at the same square as before, "drop figure" and clear highlights
if (pickedPiece.i == myCollection[oBox.Name].i && pickedPiece.j == myCollection[oBox.Name].j)
{
pickedPiece.i = -1;
pickedPiece.j = -1;
pickedFlag = false;
DrawBackground();
}
else
{
DataStructure.Point temp = new DataStructure.Point(myCollection[oBox.Name].i, myCollection[oBox.Name].j);
//if it is one of highlighted fields go on. if not than
//if it is a empty field or not highlighted enemy piece do nothing if it is a friendly piece select it
if (Validation.IsItHighlightedField(possiblePossitions, temp))
{
MoveFigure(pickedPiece, temp);
if (boardMatrix[temp.i, temp.j] == (int)DataStructure.Figures.white_pawn ||
boardMatrix[temp.i, temp.j] == (int)DataStructure.Figures.black_pawn)
{
Pawn.KickingOutEnPassant(pickedPiece, temp, boardMatrix);
Pawn.EndofTheColumn(temp, boardMatrix);
Pawn.WasDoubleJump(pickedPiece, temp);
}
if (EnvironmentVariables.Player == DataStructure.Color.white)
{
}
pickedFlag = false;
DrawBackground();
ChangePlayer();
}
else if (Validation.IsEmpty(temp, boardMatrix))
{
//do nothing
}
else
{
if (boardMatrix[pickedPiece.i, pickedPiece.j] % 2 == (int)DataStructure.Color.white)
{
if (!Validation.IsOpponent(temp, boardMatrix))
{
pickedPiece.i = -1;
pickedPiece.j = -1;
pickedFlag = false;
SelectUnselectPiece(oBox);
}
//else do nothing
}
else if (boardMatrix[pickedPiece.i, pickedPiece.j] % 2 == (int)DataStructure.Color.black)
{
if (!Validation.IsOpponent(temp, boardMatrix))
{
pickedPiece.i = -1;
pickedPiece.j = -1;
pickedFlag = false;
SelectUnselectPiece(oBox);
}
//else do nothing
}
}
}
}
}
List <DataStructure.Point> FindMovesBlack(DataStructure.Point possition, int[,] boardMatrix)
{
List <DataStructure.Point> possiblePossitions = new List <DataStructure.Point>();
DataStructure.Point p;
//if it is first move of the pawn than check 2 columns
if (possition.i == 6)
{//if first is empty than add it and check second
p = new DataStructure.Point(possition.i - 1, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{//if second is empty add it
possiblePossitions.Add(p);
p = new DataStructure.Point(possition.i - 2, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
}
}
else
{
p = new DataStructure.Point(possition.i - 1, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
}
//check for corner pawns. if it is first or last the moves won`t be add together
//with occupied possitions with friendly characters.
p = new DataStructure.Point(possition.i - 1, possition.j - 1);
if (Validation.IsValidPosition(p))
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
if (EnPassant.i == possition.i && EnPassant.j == possition.j - 1)
{
possiblePossitions.Add(p);
}
if (EnPassant.i == possition.i + 1 && EnPassant.j == possition.j - 1)
{
possiblePossitions.Add(p);
}
}
p = new DataStructure.Point(possition.i - 1, possition.j + 1);
if (Validation.IsValidPosition(p))
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
if (EnPassant.i == possition.i && EnPassant.j == possition.j + 1)
{
possiblePossitions.Add(p);
}
if (EnPassant.i == possition.i + 1 && EnPassant.j == possition.j + 1)
{
possiblePossitions.Add(p);
}
}
return(possiblePossitions);
}
static List <DataStructure.Point> FindMovesBlack(DataStructure.Point possition, int[,] boardMatrix)
{
List <DataStructure.Point> possiblePossitions = new List <DataStructure.Point>();
DataStructure.Point p;
for (int i = possition.i - 1; i > -1; i--)
{
p = new DataStructure.Point(i, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int i = possition.i + 1; i < 8; i++)
{
p = new DataStructure.Point(i, possition.j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int j = possition.j - 1; j > -1; j--)
{
p = new DataStructure.Point(possition.i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
for (int j = possition.j + 1; j < 8; j++)
{
p = new DataStructure.Point(possition.i, j);
if (Validation.IsEmpty(p, boardMatrix))
{
possiblePossitions.Add(p);
}
else
{
if (Validation.IsOpponent(p, boardMatrix))
{
possiblePossitions.Add(p);
}
break;
}
}
return(possiblePossitions);
}
