private void GetAllBeatMoves(Piece piece, List <BeatedPiece> beatedPieces, int sourceRow, int sourceColumn, int targetRow, int targetColumn, ref List <Move> allMoves, ref int maxBeated)
{
if (beatedPieces.Count > maxBeated)
{
maxBeated = beatedPieces.Count;
}
Piece newPiece = new Piece(targetRow, targetColumn, piece.Color, piece.Size, piece.IsKing);
if (beatedPieces.Count == maxBeated)
{
allMoves.Add(new Move(piece, newPiece, beatedPieces));
}
if (CanBeatPiece(newPiece, targetRow - 1, targetColumn - 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow - 1, targetColumn - 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Row == beatedPiece.Row && p.Column == beatedPiece.Column && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow - 2, targetColumn - 2, ref allMoves, ref maxBeated);
}
}
if (CanBeatPiece(newPiece, targetRow + 1, targetColumn - 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow + 1, targetColumn - 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Row == beatedPiece.Row && p.Column == beatedPiece.Column && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow + 2, targetColumn - 2, ref allMoves, ref maxBeated);
}
}
if (CanBeatPiece(newPiece, targetRow - 1, targetColumn + 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow - 1, targetColumn + 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Row == beatedPiece.Row && p.Column == beatedPiece.Column && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow - 2, targetColumn + 2, ref allMoves, ref maxBeated);
}
}
if (CanBeatPiece(newPiece, targetRow + 1, targetColumn + 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow + 1, targetColumn + 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Row == beatedPiece.Row && p.Column == beatedPiece.Column && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow + 2, targetColumn + 2, ref allMoves, ref maxBeated);
}
}
}
private void GetAllKingBeatMoves(Piece piece, List <BeatedPiece> beatedPieces, int sourceRow, int sourceColumn, int targetRow, int targetColumn, ref List <Move> allMoves, ref int maxBeated)
{
if (beatedPieces.Count > maxBeated)
{
maxBeated = beatedPieces.Count;
}
Piece newPiece = new Piece(targetRow, targetColumn, piece.Color, piece.Size, piece.IsKing);
if (beatedPieces.Count == maxBeated)
{
allMoves.Add(new Move(piece, newPiece, beatedPieces));
}
for (int ind = 1; ind < Size; ind++)
{
if (targetRow - sourceRow > 0 && targetColumn - sourceColumn > 0)
{
if (CanMoveToPosition(targetRow + ind, targetColumn + ind, piece.Position))
{
GetAllKingBeatMoves(piece, new List <BeatedPiece>(beatedPieces), targetRow, targetColumn, targetRow + ind, targetColumn + ind, ref allMoves, ref maxBeated);
}
else
{
break;
}
}
if (targetRow - sourceRow > 0 && targetColumn - sourceColumn < 0)
{
if (CanMoveToPosition(targetRow + ind, targetColumn - ind, piece.Position))
{
GetAllKingBeatMoves(piece, new List <BeatedPiece>(beatedPieces), targetRow, targetColumn, targetRow + ind, targetColumn - ind, ref allMoves, ref maxBeated);
}
else
{
break;
}
}
if (targetRow - sourceRow < 0 && targetColumn - sourceColumn > 0)
{
if (CanMoveToPosition(targetRow - ind, targetColumn + ind, piece.Position))
{
GetAllKingBeatMoves(piece, new List <BeatedPiece>(beatedPieces), targetRow, targetColumn, targetRow - ind, targetColumn + ind, ref allMoves, ref maxBeated);
}
else
{
break;
}
}
if (targetRow - sourceRow < 0 && targetColumn - sourceColumn < 0)
{
if (CanMoveToPosition(targetRow - ind, targetColumn - ind, piece.Position))
{
GetAllKingBeatMoves(piece, new List <BeatedPiece>(beatedPieces), targetRow, targetColumn, targetRow - ind, targetColumn - ind, ref allMoves, ref maxBeated);
}
else
{
break;
}
}
}
if (!(targetRow - sourceRow > 0 && targetColumn - sourceColumn > 0))
{
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(newPiece, targetRow - ind, targetColumn - ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow - ind, targetColumn - ind, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Position == beatedPiece.Position && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllKingBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow - ind - 1, targetColumn - ind - 1, ref allMoves, ref maxBeated);
break;
}
else
{
break;
}
}
else
{
if (!CanMoveToPosition(targetRow - ind, targetColumn - ind, piece.Position))
{
break;
}
}
}
}
if (!(targetRow - sourceRow < 0 && targetColumn - sourceColumn > 0))
{
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(newPiece, targetRow + ind, targetColumn - ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow + ind, targetColumn - ind, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Position == beatedPiece.Position && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllKingBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow + ind + 1, targetColumn - ind - 1, ref allMoves, ref maxBeated);
break;
}
else
{
break;
}
}
else
{
if (!CanMoveToPosition(targetRow + ind, targetColumn - ind, piece.Position))
{
break;
}
}
}
}
if (!(targetRow - sourceRow > 0 && targetColumn - sourceColumn < 0))
{
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(newPiece, targetRow - ind, targetColumn + ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow - ind, targetColumn + ind, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Position == beatedPiece.Position && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllKingBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow - ind - 1, targetColumn + ind + 1, ref allMoves, ref maxBeated);
break;
}
else
{
break;
}
}
else
{
if (!CanMoveToPosition(targetRow - ind, targetColumn + ind, piece.Position))
{
break;
}
}
}
}
if (!(targetRow - sourceRow < 0 && targetColumn - sourceColumn < 0))
{
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(newPiece, targetRow + ind, targetColumn + ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(targetRow + ind, targetColumn + ind, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, targetRow, targetColumn);
if (beatedPieces.Where(p => p.Position == beatedPiece.Position && p.Color == beatedPiece.Color).Count() == 0)
{
List <BeatedPiece> newBeatedPieces = new List <BeatedPiece>(beatedPieces);
newBeatedPieces.Add(beatedPiece);
GetAllKingBeatMoves(piece, newBeatedPieces, targetRow, targetColumn, targetRow + ind + 1, targetColumn + ind + 1, ref allMoves, ref maxBeated);
break;
}
else
{
break;
}
}
else
{
if (!CanMoveToPosition(targetRow + ind, targetColumn + ind, piece.Position))
{
break;
}
}
}
}
}
private List <Move> GetPawnPossibleMoves(int piecePosition, PieceColor color, ref int maxBeated)
{
List <Move> possibleMoves = new List <Move>();
var piece = new Piece(piecePosition, color, Size, false);
//normalne ruchy do przodu
if (maxBeated == 0)
{
switch (piece.Color)
{
case PieceColor.White:
if (CanMoveToPosition(piece.Row + 1, piece.Column + 1, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row + 1, piece.Column + 1, PieceColor.White, piece.Size, piece.Row + 1 == Size - 1), null));
}
if (CanMoveToPosition(piece.Row + 1, piece.Column - 1, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row + 1, piece.Column - 1, PieceColor.White, piece.Size, piece.Row + 1 == Size - 1), null));
}
break;
case PieceColor.Black:
if (CanMoveToPosition(piece.Row - 1, piece.Column + 1, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row - 1, piece.Column + 1, PieceColor.Black, piece.Size, piece.Row - 1 == 0), null));
}
if (CanMoveToPosition(piece.Row - 1, piece.Column - 1, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row - 1, piece.Column - 1, PieceColor.Black, piece.Size, piece.Row - 1 == 0), null));
}
break;
}
}
//próba bicia w czterech różnych kierunkach
if (CanBeatPiece(piece, piece.Row - 1, piece.Column - 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row - 1, piece.Column - 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row - 2, piece.Column - 2, ref possibleMoves, ref maxBeated);
}
if (CanBeatPiece(piece, piece.Row + 1, piece.Column - 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row + 1, piece.Column - 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row + 2, piece.Column - 2, ref possibleMoves, ref maxBeated);
}
if (CanBeatPiece(piece, piece.Row - 1, piece.Column + 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row - 1, piece.Column + 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row - 2, piece.Column + 2, ref possibleMoves, ref maxBeated);
}
if (CanBeatPiece(piece, piece.Row + 1, piece.Column + 1, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row + 1, piece.Column + 1, piece.Color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row + 2, piece.Column + 2, ref possibleMoves, ref maxBeated);
}
return(possibleMoves);
}
private List <Move> GetKingPossibleMoves(int piecePosition, PieceColor color, ref int maxBeated)
{
var piece = new Piece(piecePosition, color, Size, true);
List <Move> possibleMoves = new List <Move>();
//normalne ruchy w czterech kierunkach aż do napotkania pionka lub końca planszy
if (maxBeated == 0)
{
int pieceRow = Piece.ToRow(piecePosition, Size);
int pieceColumn = Piece.ToColumn(piecePosition, Size);
for (int ind = 1; ind < Size; ind++)
{
if (CanMoveToPosition(pieceRow + ind, pieceColumn + ind, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row + ind, piece.Column + ind, piece.Color, piece.Size, piece.IsKing), null));
}
else
{
break;
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanMoveToPosition(piece.Row + ind, piece.Column - ind, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row + ind, piece.Column - ind, piece.Color, piece.Size, piece.IsKing), null));
}
else
{
break;
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanMoveToPosition(piece.Row - ind, piece.Column + ind, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row - ind, piece.Column + ind, piece.Color, piece.Size, piece.IsKing), null));
}
else
{
break;
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanMoveToPosition(piece.Row - ind, piece.Column - ind, piecePosition))
{
possibleMoves.Add(new Move(piece, new Piece(piece.Row - ind, piece.Column - ind, piece.Color, piece.Size, piece.IsKing), null));
}
else
{
break;
}
}
}
//próba bicia w czterech różnych kierunkach damką
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(piece, piece.Row - ind, piece.Column - ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row - ind, piece.Column - ind, color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllKingBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row - ind - 1, piece.Column - ind - 1, ref possibleMoves, ref maxBeated);
}
else
{
if (!CanMoveToPosition(piece.Row - ind, piece.Column - ind, piecePosition))
{
break;
}
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(piece, piece.Row + ind, piece.Column - ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row + ind, piece.Column - ind, color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllKingBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row + ind + 1, piece.Column - ind - 1, ref possibleMoves, ref maxBeated);
}
else
{
if (!CanMoveToPosition(piece.Row + ind, piece.Column - ind, piecePosition))
{
break;
}
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(piece, piece.Row - ind, piece.Column + ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row - ind, piece.Column + ind, color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllKingBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row - ind - 1, piece.Column + ind + 1, ref possibleMoves, ref maxBeated);
}
else
{
if (!CanMoveToPosition(piece.Row - ind, piece.Column + ind, piecePosition))
{
break;
}
}
}
for (int ind = 1; ind < Size; ind++)
{
if (CanBeatPiece(piece, piece.Row + ind, piece.Column + ind, piece))
{
BeatedPiece beatedPiece = new BeatedPiece(piece.Row + ind, piece.Column + ind, color == PieceColor.White ? PieceColor.Black : PieceColor.White, false, piece.Row, piece.Column);
GetAllKingBeatMoves(piece, new List <BeatedPiece>()
{
beatedPiece
}, piece.Row, piece.Column, piece.Row + ind + 1, piece.Column + ind + 1, ref possibleMoves, ref maxBeated);
}
else
{
if (!CanMoveToPosition(piece.Row + ind, piece.Column + ind, piecePosition))
{
break;
}
}
}
return(possibleMoves);
}
