// Code Review: Аргументи методу повинні починатися з малої літери.
public static bool CheckIfArePossibleMoves(ChessBoard board, bool IsWhite)
{
// Code Review: Назва локальної змінної повинна починатися з малої літери.
int comparerresult = IsWhite ? 1 : -1;
List <Square> pieces = new List <Square>();
for (char tfile = 'a'; tfile <= 'h'; tfile++)
{
for (sbyte trank = 1; trank <= 8; trank++)
{
if (board[tfile, trank].CompareTo(0) == comparerresult)
{
pieces.Add(new Square(tfile, trank));
}
}
}
foreach (Square temp in pieces)
{
char piecetype = GetLetter(board[temp]);
GetPiecePositionsType function = IsWhite ? GetWhitePiecePositionsType(piecetype) : GetBlackPiecePositionsType(piecetype);
if (function(board, temp.file, temp.rank).Count > 0)
{
return(true);
}
}
return(false);
}
// Code Review: Надто об'ємний метод.
// Code Review: Потрібно розділяти умови дужками () в операторах if.
public static ChessBoard PerformWhiteMove(ChessBoard board, string notation)
{
ChessBoard tempboard = board.ShallowCopy();
#region King-castling
if (notation == "O-O" && DefaultInfo.WhiteKingIsUnMoved && DefaultInfo.WhiteHsideRookIsUnMoved)
{
char kingfile = 'e';
for (char tfile = 'b'; tfile <= 'g'; tfile++)
{
if (board[tfile, 1] == (sbyte)DefaultPieces.WhiteKing)
{
kingfile = tfile;
break;
}
}
char Hrookfile = 'h';
for (char tfile = 'h'; tfile >= 'c'; tfile++)
{
if (board[tfile, 1] == (sbyte)DefaultPieces.WhiteRook)
{
Hrookfile = tfile;
break;
}
}
tempboard[kingfile, 1] = 0;
tempboard[Hrookfile, 1] = 0;
tempboard['g', 1] = (sbyte)DefaultPieces.WhiteKing;
tempboard['f', 1] = (sbyte)DefaultPieces.WhiteRook;
if (WhiteKing.GetPossiblePositions(board, kingfile, 1).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("Wrong move");
}
}
#endregion
#region Queen-castling
else if (notation == "O-O-O" && DefaultInfo.WhiteKingIsUnMoved && DefaultInfo.WhiteAsideRookIsUnMoved)
{
char kingfile = 'e';
for (char tfile = 'b'; tfile <= 'g'; tfile++)
{
if (board[tfile, 1] == (sbyte)DefaultPieces.WhiteKing)
{
kingfile = tfile;
break;
}
}
char Arookfile = 'h';
for (char tfile = 'a'; tfile <= 'f'; tfile++)
{
if (board[tfile, 1] == (sbyte)DefaultPieces.WhiteRook)
{
Arookfile = tfile;
break;
}
}
tempboard[kingfile, 1] = 0;
tempboard[Arookfile, 1] = 0;
tempboard['c', 1] = (sbyte)DefaultPieces.WhiteKing;
tempboard['d', 1] = (sbyte)DefaultPieces.WhiteRook;
if (WhiteKing.GetPossiblePositions(board, kingfile, 1).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("Wrong move");
}
}
#endregion
#region Pawn
else if (notation[0] <= 'h' && notation[0] >= 'a')
{
#region simple move
if (notation[1] <= '8' && notation[1] >= '3' && notation.Length == 2)
{
//simple move (not 4 rank)
if (notation[1] != 4)
{
sbyte pawnrank = (sbyte)(Char.GetNumericValue(notation[1]) - 1);
char pawnfile = notation[0];
tempboard[pawnfile, pawnrank] = 0;
tempboard[pawnfile, pawnrank + 1] = (sbyte)DefaultPieces.WhitePawn;
if (WhitePawn.GetPossiblePositions(board, pawnfile, pawnrank).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("Wrong move");
}
}
//simple move (4 rank)
else
{
char pawnfile = notation[0];
sbyte pawnrank;
if (board[pawnfile, (sbyte)(Char.GetNumericValue(notation[1]) - 1)] == (sbyte)DefaultPieces.WhitePawn)
{
pawnrank = (sbyte)(Char.GetNumericValue(notation[1]) - 1);
}
else if (board[pawnfile, (sbyte)(Char.GetNumericValue(notation[1]) - 2)] == (sbyte)DefaultPieces.WhitePawn)
{
pawnrank = (sbyte)(Char.GetNumericValue(notation[1]) - 2);
}
else
{
throw new ArgumentException("Wrong move");
}
tempboard[pawnfile, pawnrank] = 0;
tempboard[pawnfile, (sbyte)Char.GetNumericValue(notation[1])] = (sbyte)DefaultPieces.WhitePawn;
if (WhitePawn.GetPossiblePositions(board, pawnfile, pawnrank).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("Wrong move");
}
}
}
#endregion
#region capture move
else if (notation.Length == 4 && notation[1] == 'x' && notation[2] <= 'h' && notation[2] >= 'a' && notation[3] <= '8' && notation[3] >= '3')
{
char pawnfile = notation[0];
char enemyfile = notation[2];
sbyte enemyrank = (sbyte)Char.GetNumericValue(notation[3]);
sbyte pawnrank = (sbyte)(enemyrank - 1);
tempboard[pawnfile, pawnrank] = 0;
tempboard[enemyfile, enemyrank] = (sbyte)DefaultPieces.WhitePawn;
if (WhitePawn.GetPossiblePositions(board, pawnfile, pawnrank).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("Wrong move");
}
}
#endregion
//To Do en passant!!!
else
{
throw new ArgumentException("Wrong move");
}
}
#endregion
#region Pieces (not Pawn)
else if (notation[0] <= 'Z' && notation[0] >= 'A')
{
#region Non-ambiguous
if ((notation.Length == 3 && notation[1] <= 'h' && notation[1] >= 'a' && notation[2] >= '0' && notation[2] <= '8') || (notation.Length == 4 && notation[1] == 'x' && notation[2] <= 'h' && notation[2] >= 'a' && notation[2] >= '0' && notation[2] <= '8'))
{
char goalfile;
sbyte goalrank;
if (notation.Length == 3)
{
goalfile = notation[1];
goalrank = (sbyte)Char.GetNumericValue(notation[2]);
}
else
{
goalfile = notation[2];
goalrank = (sbyte)Char.GetNumericValue(notation[3]);
}
//Check if piece is not-ambigious and get piece square
List <Square> PossibleMovers = GetPossibleBlackMoversToSquare(board, goalfile, goalrank);
int NumberOfSamePieces = 0;
Square PieceSquare = new Square();
foreach (Square tempsquare in PossibleMovers)
{
if (board[tempsquare.file, tempsquare.rank] == GetSbyteFromWhitePieceLetter(notation[0]))
{
NumberOfSamePieces++;
PieceSquare = tempsquare;
}
}
if (NumberOfSamePieces != 1)
{
throw new ArgumentException("wrong notation");
}
tempboard[PieceSquare.file, PieceSquare.rank] = 0;
tempboard[goalfile, goalrank] = GetSbyteFromWhitePieceLetter(notation[0]);
GetPiecePositionsType piecefunction = GetWhitePiecePositionsType(notation[0]);
if (piecefunction(board, goalfile, goalrank).Contains(tempboard))
{
return(tempboard);
}
else
{
throw new ArgumentException("wrong move");
}
}
#endregion
#region Ambiguous
else if (notation.Length <= 6 && notation.Length >= 4 && notation[2] != 'x')
{
//&& ( (notation.Length==4 && notation[1]>='a' && notation[1]<='h' && notation[2]>='a' && notation[2]<='h' && notation[3]<='8' && notation[3]>='1' ) || ( (notation.Length==4 && notation[1]>='a' && notation[1]<='h' && notation[2]>='a' && notation[2]<='h' && notation[3]<='8' && notation[3]>='1' ) ) )
char piecefile;
sbyte piecerank;
char goalfile;
sbyte goalrank;
sbyte piecetype = GetSbyteFromWhitePieceLetter(notation[0]);
//Ngf3
if (notation.Length == 4 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] >= 'a' && notation[2] <= 'h' && notation[3] >= '1' && notation[3] <= '8')
{
goalfile = notation[2];
goalrank = (sbyte)Char.GetNumericValue(notation[3]);
piecefile = notation[1];
for (sbyte i = 1; i <= 8; i++)
{
if (board[piecefile, i] == piecetype)
{
piecerank = i;
break;
}
}
}
//Ngxf3
else if (notation.Length == 5 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] == 'x' && notation[3] >= 'a' && notation[3] <= 'h' && notation[4] >= '1' && notation[4] <= '8')
{
goalfile = notation[3];
goalrank = (sbyte)Char.GetNumericValue(notation[4]);
piecefile = notation[1];
for (sbyte i = 1; i <= 8; i++)
{
if (board[piecefile, i] == piecetype)
{
piecerank = i;
break;
}
}
}
//N5f3
else if (notation.Length == 4 && notation[1] >= '1' && notation[1] <= '8' && notation[2] >= 'a' && notation[2] <= 'h' && notation[3] >= '1' && notation[3] <= '8')
{
goalfile = notation[2];
goalrank = (sbyte)Char.GetNumericValue(notation[4]);
piecerank = (sbyte)Char.GetNumericValue(notation[1]);
for (char tfile = 'a'; tfile <= 'h'; tfile++)
{
if (board[tfile, piecerank] == piecetype)
{
piecefile = tfile;
break;
}
}
}
//N5xf4
else if (notation.Length == 5 && notation[1] >= '1' && notation[1] <= '8' && notation[2] == 'x' && notation[3] >= 'a' && notation[3] <= 'h' && notation[4] >= '1' && notation[4] <= '8')
{
goalfile = notation[3];
goalrank = (sbyte)Char.GetNumericValue(notation[5]);
piecerank = (sbyte)Char.GetNumericValue(notation[1]);
for (char tfile = 'a'; tfile <= 'h'; tfile++)
{
if (board[tfile, piecerank] == piecetype)
{
piecefile = tfile;
break;
}
}
}
//Ng5f3
else if (notation.Length == 5 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] >= '1' && notation[2] <= '8' && notation[3] >= 'a' && notation[3] <= 'h' && notation[4] >= '1' && notation[4] <= '8')
{
goalfile = notation[3];
goalrank = (sbyte)Char.GetNumericValue(notation[4]);
piecefile = notation[1];
piecerank = (sbyte)Char.GetNumericValue(notation[2]);
}
//Ng5xf3
else if (notation.Length == 6 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] >= '1' && notation[2] <= '8' && notation[3] == 'x' && notation[4] >= 'a' && notation[4] <= 'h' && notation[5] >= '1' && notation[5] <= 'h')
{
goalfile = notation[4];
goalrank = (sbyte)Char.GetNumericValue(notation[5]);
piecefile = notation[1];
piecerank = (sbyte)Char.GetNumericValue(notation[2]);
}
}
#endregion
}
#endregion
else
{
throw new ArgumentException("Wrong notation");
}
}
private static ChessBoard PerformBlackNonAmbiguousMove(ChessBoard board, string notation, ChessBoard tempboard)
{
char goalfile = notation[1];
sbyte goalrank = (sbyte)Char.GetNumericValue(notation[2]);
//Check if piece is not-ambigious and get piece square
List <Square> PossibleMovers = WhitePiece.GetPossibleBlackAttackersToSquare(board, new Square(goalfile, goalrank));
int NumberOfSamePieces = 0;
Square PieceSquare = new Square();
foreach (Square tempsquare in PossibleMovers)
{
if (board[tempsquare.file, tempsquare.rank] == GetSbyteFromBlackPieceLetter(notation[0]))
{
NumberOfSamePieces++;
PieceSquare = tempsquare;
}
}
if (NumberOfSamePieces != 1)
{
throw new ArgumentException("wrong notation");
}
tempboard[PieceSquare.file, PieceSquare.rank] = 0;
tempboard[goalfile, goalrank] = GetSbyteFromBlackPieceLetter(notation[0]);
GetPiecePositionsType piecefunction = GetBlackPiecePositionsType(notation[0]);
if (piecefunction(board, PieceSquare.file, PieceSquare.rank).Contains(tempboard))
{
if (board[PieceSquare.file, PieceSquare.rank] == (sbyte)DefaultPieces.BlackRook && (DefaultInfo.BlackAsideRookIsUnMoved || DefaultInfo.BlackHsideRookIsUnMoved))
{
if (DefaultInfo.BlackAsideRookIsUnMoved && !DefaultInfo.BlackHsideRookIsUnMoved)
{
DefaultInfo.BlackAsideRookIsUnMoved = false;
}
else if (!DefaultInfo.BlackAsideRookIsUnMoved && DefaultInfo.BlackHsideRookIsUnMoved)
{
DefaultInfo.BlackHsideRookIsUnMoved = false;
}
else
{
char rookfile;
for (rookfile = 'a'; rookfile <= 'h'; rookfile++)
{
if (board[rookfile, 8] == (sbyte)DefaultPieces.BlackRook)
{
break;
}
}
if (rookfile < PieceSquare.file)
{
DefaultInfo.BlackHsideRookIsUnMoved = false;
}
else
{
DefaultInfo.BlackAsideRookIsUnMoved = false;
}
}
}
return(tempboard);
}
else
{
throw new ArgumentException("wrong move");
}
}
// Code Review: Надто об'ємний метод.
private static ChessBoard PerformBlackAmbiguousMove(ChessBoard board, string notation, ChessBoard tempboard)
{
char piecefile = default(char);
sbyte piecerank = default(sbyte);
char goalfile;
sbyte goalrank;
sbyte piecetype = GetSbyteFromBlackPieceLetter(notation[0]);
//Ngf3
if (notation.Length == 4 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] >= 'a' && notation[2] <= 'h' && notation[3] >= '1' && notation[3] <= '8')
{
goalfile = notation[2];
goalrank = (sbyte)Char.GetNumericValue(notation[3]);
piecefile = notation[1];
for (sbyte i = 1; i <= 8; i++)
{
if (board[piecefile, i] == piecetype)
{
piecerank = i;
break;
}
}
}
//N5f3
else if (notation.Length == 4 && notation[1] >= '1' && notation[1] <= '8' && notation[2] >= 'a' && notation[2] <= 'h' && notation[3] >= '1' && notation[3] <= '8')
{
goalfile = notation[2];
goalrank = (sbyte)Char.GetNumericValue(notation[3]);
piecerank = (sbyte)Char.GetNumericValue(notation[1]);
for (char tfile = 'a'; tfile <= 'h'; tfile++)
{
if (board[tfile, piecerank] == piecetype)
{
piecefile = tfile;
break;
}
}
}
//Ng5f3
else if (notation.Length == 5 && notation[1] >= 'a' && notation[1] <= 'h' && notation[2] >= '1' && notation[2] <= '8' && notation[3] >= 'a' && notation[3] <= 'h' && notation[4] >= '1' && notation[4] <= '8')
{
goalfile = notation[3];
goalrank = (sbyte)Char.GetNumericValue(notation[4]);
piecefile = notation[1];
piecerank = (sbyte)Char.GetNumericValue(notation[2]);
}
else
{
throw new ArgumentException("wrong notation");
}
tempboard[goalfile, goalrank] = piecetype;
tempboard[piecefile, piecerank] = 0;
GetPiecePositionsType piecefunction = GetBlackPiecePositionsType(notation[0]);
if (piecefunction(board, piecefile, piecerank).Contains(tempboard))
{
if (board[piecefile, piecerank] == (sbyte)DefaultPieces.BlackRook && (DefaultInfo.BlackAsideRookIsUnMoved || DefaultInfo.BlackHsideRookIsUnMoved))
{
if (DefaultInfo.BlackAsideRookIsUnMoved && !DefaultInfo.BlackHsideRookIsUnMoved)
{
DefaultInfo.BlackAsideRookIsUnMoved = false;
}
else if (!DefaultInfo.BlackAsideRookIsUnMoved && DefaultInfo.BlackHsideRookIsUnMoved)
{
DefaultInfo.BlackHsideRookIsUnMoved = false;
}
else
{
char rookfile;
for (rookfile = 'a'; rookfile <= 'h'; rookfile++)
{
if (board[rookfile, 8] == (sbyte)DefaultPieces.BlackRook)
{
break;
}
}
if (rookfile < piecefile)
{
DefaultInfo.BlackHsideRookIsUnMoved = false;
}
else
{
DefaultInfo.BlackAsideRookIsUnMoved = false;
}
}
}
return(tempboard);
}
else
{
throw new ArgumentException("wrong move");
}
}