public void TestInvalidMoves()
{
var rook = new Rook(board, Color.White);
board.AddPieceToTheGame(rook, board[4, 4]);
for (int i = 0; i < ChessBoard.ChessboardSize; i++)
{
for (int j = 0; j < ChessBoard.ChessboardSize; j++)
{
if (i != 4 && j != 4)
{
Assert.IsFalse(rook.Move(board[i, j]));
Assert.IsTrue(board[i, j].Empty);
}
}
}
Assert.IsFalse(board[4, 4].Empty);
var otherRook = new Rook(board, Color.Black);
board.AddPieceToTheGame(otherRook, board[4, 6]);
Assert.IsFalse(rook.Move(board[4, 7]));
Assert.IsTrue(rook.Move(board[4, 6]));
}
public void _02_making_a_legal_move_by_placing_the_black_rook_on_X_equals_7_and_Y_eqauls_7_and_moving_to_X_equals_7_and_Y_eqauls_4_should_move_the_rook()
{
_chessBoard.Add(_blackRook, 7, 7);
_blackRook.Move(7, 4);
Assert.That(_blackRook.XCoordinate, Is.EqualTo(7));
Assert.That(_blackRook.YCoordinate, Is.EqualTo(4));
Assert.That(_chessBoard.IsPieceAt(7, 4, _blackRook), Is.True);
}
public void _12_black_king_at_X_equals_4_and_Y_equals_7_long_castles_but_the_rook_has_moved()
{
_chessBoard.Add(_blackKing, 4, 7);
_chessBoard.Add(_blackRook, 0, 6);
_blackRook.Move(0, 7);
_blackKing.LongCastle();
Assert.That(!_chessBoard.IsPieceAt(2, 7, _blackKing));
Assert.That(!_chessBoard.IsPieceAt(3, 7, _blackRook));
}
public void _12_is_at_X_equals_4_and_Y_equals_0_long_castles_but_the_rook_has_moved()
{
_chessBoard.Add(_whiteKing, 4, 0);
_chessBoard.Add(_whiteRook, 0, 1);
_whiteRook.Move(0, 0);
_whiteKing.LongCastle();
Assert.That(!_chessBoard.IsPieceAt(2, 0, _whiteKing));
Assert.That(!_chessBoard.IsPieceAt(3, 0, _whiteRook));
}
public void TestValidMoves()
{
var rook = new Rook(board, Color.White);
board.AddPieceToTheGame(rook, board[4, 4]);
Assert.IsTrue(rook.Move(board[7, 4]));
Assert.IsTrue(board[4, 4].Empty);
Assert.IsFalse(board[7, 4].Empty);
Assert.IsTrue(rook.Move(board[7, 7]));
Assert.IsTrue(rook.Move(board[0, 7]));
Assert.IsTrue(rook.Move(board[0, 0]));
Assert.IsTrue(rook.Move(board[0, 1]));
}
public void DetectCheckmate()
{
var king = new King(board, Color.White);
board.AddPieceToTheGame(king, board[0, 0]);
var enemyRook = new Rook(board, Color.Black);
board.AddPieceToTheGame(enemyRook, board[7, 0]);
Assert.IsFalse(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
var otherRook = new Rook(board, Color.Black);
board.AddPieceToTheGame(otherRook, board[7, 1]);
Assert.IsTrue(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
var whiteRook = new Rook(board, Color.White);
board.AddPieceToTheGame(whiteRook, board[4, 4]);
Assert.IsFalse(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
whiteRook.Move(board[0, 4]);
enemyRook.Move(board[0, 4]);
Assert.IsTrue(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
board.AddPieceToTheGame(whiteRook, board[4, 4]);
Assert.IsFalse(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
}
private bool IsValidMove(pieceName sourcePieceType, int destinationY, int destinationX) // determine if the piece is able to move to its target square
{
int sourceY = PieceDetails.FindCoordinate(selectedpiece.Location.Y);
int sourceX = PieceDetails.FindCoordinate(selectedpiece.Location.X);
switch (sourcePieceType)
{
case pieceName.Pawn:
Pawn pawn = new Pawn(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(pawn.Move(board));
case pieceName.Rook:
Rook rook = new Rook(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(rook.Move(board));
case pieceName.Knight:
Knight knight = new Knight(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(knight.Move(board));
case pieceName.Bishop:
Bishop bishop = new Bishop(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(bishop.Move(board));
case pieceName.Queen:
Queen queen = new Queen(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(queen.Move(board));
default:
King king = new King(board, sourceY, sourceX, destinationY, destinationX, History, turn);
return(king.Move(board));
}
}
protected override void Move()
{
if (PossibleMoves.Count > 0)
{
Color currentPlayerColor = this.Game.CurrentPlayer.Color;
Rook rook = (Rook)Game.Figures.First(f => f.Color == currentPlayerColor && f is Rook);
King king = (King)Game.Figures.First(f => f.Color == currentPlayerColor && f is King);
var pole = CalculateRestrictedField(rook.Field.Horizontal, rook.Field.Vertical);
var restrictionMoves = FindSmallerRestrictedFields();
if (restrictionMoves.Count > 0)
{
rook.Move(restrictionMoves.Last());
return;
}
var oppositions = FindOppositions();
if (oppositions.Count > 0)
{
king.Move(oppositions.First());
return;
}
else
{
MoveKingCloser();
}
}
}
public void Move_InvalidPosition_ReturnsStartingPosition(int finalDestinationColumn, int finalDestinationRow)
{
IChessPiece rook = new Rook(0, 5, 5);
rook.Move(finalDestinationColumn, finalDestinationRow);
Assert.Equal(5, rook.Position.ColumnPosition);
Assert.Equal(5, rook.Position.RowPosition);
}
public void _26_it_is_at_X_equals_4_and_Y_equals_0_and_a_piece_tries_to_capture_it_should_not_move_either_piece()
{
_chessBoard.Add(_whiteKing, 4, 0);
_chessBoard.Add(_blackRook, 4, 4);
_blackRook.Move(4, 0);
Assert.That(_chessBoard.IsPieceAt(4, 0, _whiteKing));
Assert.That(_chessBoard.IsPieceAt(4, 4, _blackRook));
}
public void _06_and_is_captured_by_a_white_rook()
{
_chessBoard.Add(_blackKnight, 3, 7);
_chessBoard.Add(_whiteRook, 3, 4);
_whiteRook.Move(3, 7);
Assert.That(_chessBoard.CapturedBlackPieces.Contains(_blackKnight));
Assert.That(_chessBoard.IsPieceAt(3, 7, _whiteRook));
Assert.That(_whiteRook.XCoordinate, Is.EqualTo(3));
Assert.That(_whiteRook.YCoordinate, Is.EqualTo(7));
}
public void RookIsMoved()
{
var rook = new Rook(2, 2, PieceColor.White);
var board = new Board();
Board.Occupy(board[2, 2], rook);
Assert.IsTrue(rook.Move(7, 2, board, out _, false));
Assert.IsTrue(rook.Move(7, 5, board, out _, false));
Assert.IsTrue(rook.Move(7, 3, board, out _, false));
Assert.IsTrue(rook.Move(3, 3, board, out _, false));
Assert.IsFalse(rook.Move(4, 4, board, out _, false));
Assert.IsFalse(rook.Move(2, 5, board, out _, false));
Assert.IsFalse(rook.Move(8, 3, board, out _, false));
Assert.IsFalse(rook.Move(3, 1, board, out _, false));
Assert.IsFalse(rook.Move(3, 7, board, out _, false));
Assert.IsTrue(rook.Move(3, 6, board, out _, false));
Assert.IsTrue(board[3, 6].OccupiedBy.Color == PieceColor.White);
Assert.IsNull(board[2, 2].OccupiedBy);
}
static void Main(string[] args)
{
Rook r = new Rook('a', 1);
Console.WriteLine("Rook on a1");
Console.WriteLine("Move {0}{1} - {2}", 'b', 4, r.Move('b', 4));
Console.WriteLine("Move {0}{1} - {2}", 'f', 2, r.Move('f', 2));
Console.WriteLine("Move {0}{1} - {2}", 'b', 4, r.Move('c', 3));
Console.WriteLine("Move {0}{1} - {2}", 'a', 8, r.Move('a', 8));
Console.WriteLine("Move {0}{1} - {2}", 'b', 8, r.Move('b', 8));
Console.WriteLine("Move {0}{1} - {2}", 'b', 0, r.Move('b', 0));
Knight k = new Knight('d', 4);
Console.WriteLine("Knight on d4");
Console.WriteLine("Move {0}{1} - {2}", 'e', 6, k.Move('e', 6));
Console.WriteLine("Move {0}{1} - {2}", 'f', 5, k.Move('f', 5));
Console.WriteLine("Move {0}{1} - {2}", 'b', 3, k.Move('b', 3));
Console.WriteLine("Move {0}{1} - {2}", 'b', 5, k.Move('b', 5));
Console.WriteLine("Move {0}{1} - {2}", 'c', 2, k.Move('c', 2));
Console.WriteLine("Move {0}{1} - {2}", 'b', 0, k.Move('b', 0));
Bishop b = new Bishop('d', 4);
Console.WriteLine("Bishop on d4");
Console.WriteLine("Move {0}{1} - {2}", 'c', 3, b.Move('c', 3));
Console.WriteLine("Move {0}{1} - {2}", 'a', 1, b.Move('a', 1));
Console.WriteLine("Move {0}{1} - {2}", 'b', 3, b.Move('b', 3));
Console.WriteLine("Move {0}{1} - {2}", 'b', 5, b.Move('b', 5));
Console.WriteLine("Move {0}{1} - {2}", 'c', 2, b.Move('c', 2));
Console.WriteLine("Move {0}{1} - {2}", 'a', 8, b.Move('a', 8));
Queen q = new Queen('d', 4);
Console.WriteLine("Queen on d4");
Console.WriteLine("Move {0}{1} - {2}", 'c', 3, q.Move('c', 3));
Console.WriteLine("Move {0}{1} - {2}", 'a', 1, q.Move('a', 1));
Console.WriteLine("Move {0}{1} - {2}", 'b', 3, q.Move('b', 3));
Console.WriteLine("Move {0}{1} - {2}", 'b', 5, q.Move('b', 5));
Console.WriteLine("Move {0}{1} - {2}", 'c', 2, q.Move('c', 2));
Console.WriteLine("Move {0}{1} - {2}", 'd', 8, q.Move('d', 8));
King kg = new King('h', 1);
Console.WriteLine("King on h1");
Console.WriteLine("Move {0}{1} - {2}", 'g', 2, kg.Move('g', 2));
Console.WriteLine("Move {0}{1} - {2}", 'g', 1, kg.Move('g', 1));
Console.WriteLine("Move {0}{1} - {2}", 'c', 4, kg.Move('c', 4));
Console.WriteLine("Move {0}{1} - {2}", 'd', 5, kg.Move('d', 5));
Console.WriteLine("Move {0}{1} - {2}", 'd', 3, kg.Move('d', 3));
Console.WriteLine("Move {0}{1} - {2}", 'e', 5, kg.Move('e', 5));
Console.WriteLine("Move {0}{1} - {2}", 'e', 4, kg.Move('e', 4));
Console.WriteLine("Move {0}{1} - {2}", 'e', 3, kg.Move('e', 3));
}
public static void Main(String[] args)
{
//while (true)
//{
//int X = ShowMenu();
//switch (X)
// {
// case 1:
// PlayGame(new CheckersFactory());
// break;
// case 2:
// PlayGame(new ChessFactory());
// break;
//}
//Position p = new Position(2, 3);
//Pawn pp = new Pawn(FigureColor.White, FigureType.Pawn, p);
//-------------------------Test figures
//King is ok
//Queen is ok
//Rook is ok
//Knight is ok
//Bishop is ok
//Pawn is ok
Console.WriteLine("Create new rook at (5, 7)");
Console.WriteLine("Valid moves are:");
Rook myRook = new Rook(FigureColor.White, FigureType.Rook, new Position(5, 7));
foreach (Position pos in myRook.ValidMoves)
{
Console.WriteLine("{0}, {1}", pos.X, pos.Y);
}
Console.WriteLine("Move to new position (5,5)");
Console.WriteLine("New Valid moves are:");
myRook.Move(new Position(5,5));
foreach (Position pos in myRook.ValidMoves)
{
Console.WriteLine("{0}, {1}", pos.X, pos.Y);
}
//-------------------------Test figures
}
static void Main()
{
string figure = Console.ReadLine();
int x = Convert.ToInt32(Console.ReadLine());
int y = Convert.ToInt32(Console.ReadLine());
int x1 = Convert.ToInt32(Console.ReadLine());
int y1 = Convert.ToInt32(Console.ReadLine());
switch (figure)
{
case "K":
King king = new King(x, y);
Console.WriteLine($"King: {king.Move(x1, y1)}");
break;
case "Q":
Queen queen = new Queen(x, y);
Console.WriteLine($"Queen: {queen.Move(x1, y1)}");
break;
case "B":
Bishop bishop = new Bishop(x, y);
Console.WriteLine($"Bishop: {bishop.Move(x1, y1)}");
break;
case "N":
Knight knight = new Knight(x, y);
Console.WriteLine($"Knight: {knight.Move(x1, y1)}");
break;
case "R":
Rook rook = new Rook(x, y);
Console.WriteLine($"Rook: {rook.Move(x1, y1)}");
break;
default:
Console.WriteLine("Unknown piece code. Try again.");
break;
}
}
public bool CanMove(string move)
{
//pt ce piesa se aplica mutarea
var startX = Int32.Parse(move[1].ToString()) - 1;
//Console.WriteLine("startx board: " + startX);
var startY = move[0] - 'a';
//Console.WriteLine("starty board: " + startY);
var endY = move[3] - 'a';
//Console.WriteLine("Endy board: " + endY);
var endX = Int32.Parse(move[4].ToString()) - 1;
//Console.WriteLine("Endx board: " + endX);
if (TablaSah[startX, startY] == null)
{
//Console.WriteLine("Nu exista piesa pe aceasta pozitie");
return(false);
}
else
{
if (TablaSah[startX, startY].Name == "K")
{
Piece king = new King();
return(king.Move(TablaSah, move));
}
if (TablaSah[startX, startY].Name == "Q")
{
Piece queen = new Queen();
if (queen.Move(TablaSah, move) == true && queen.CheckIfMove(TablaSah, move) == false)
{
return(true);
}
else
{
return(false);
}
}
if (TablaSah[startX, startY].Name == "B")
{
Piece bishop = new Bishop();
if (bishop.Move(TablaSah, move) == true && bishop.CheckIfMove(TablaSah, move) == false)
{
return(true);
}
else
{
return(false);
}
}
if (TablaSah[startX, startY].Name == "N")
{
Piece knight = new Knight();
if (knight.Move(TablaSah, move) == true && knight.CheckIfMove(TablaSah, move) == false)
{
return(true);
}
else
{
return(false);
}
}
if (TablaSah[startX, startY].Name == "P")
{
Piece pawn = new Pawn();
if (pawn.Move(TablaSah, move) == true && pawn.CheckIfMove(TablaSah, move) == false)
{
return(true);
}
else
{
return(false);
}
}
if (TablaSah[startX, startY].Name == "R")
{
Piece rook = new Rook();
if (rook.Move(TablaSah, move) == true && rook.CheckIfMove(TablaSah, move) == false)
{
return(true);
}
else
{
return(false);
}
}
}
return(false);
}
public void CastlingRound(Square[,] b, Player otherPlayer)
{
bool canDoCastling = true;
Square[,] board = null;
if (b == null)
{
board = Board.Instance.SquareMatrix;
}
else
{
board = b;
}
if (!isMoved && otherPlayer != null && !otherPlayer.CheckIfSquareIsInMoves(this.actualSquare)) //Si no es jaque ahora
{
for (int i = actualSquare.X + 1; i < 7; i++)
{
if (board[actualSquare.Y, i].PieceContainer != null || otherPlayer.CheckIfSquareIsInMoves(board[actualSquare.Y, i]))
{
canDoCastling = false;
break;
}
}
if (!isMoved && canDoCastling && board[actualSquare.Y, 7].PieceContainer != null && board[actualSquare.Y, 7].PieceContainer is Rook)
{
Rook rook = board[actualSquare.Y, 7].PieceContainer as Rook;
if (!rook.IsMoved)
{
Move move = new Move(board[actualSquare.Y, actualSquare.X + 2]);
int y = ActualSquare.Y;
int x = ActualSquare.X + 1;
int previousX = rook.ActualSquare.X;
int previousY = rook.ActualSquare.Y;
move.RegisterCallback(() =>
{
if (b != null)
{
rook.Move(board[y, x]);
}
else
{
rook.Move(board[y, x].RelatedBehaviour);
}
});
move.RegisterCallbackToReset(() =>
{
rook.Move(board[previousY, previousX]);
});
possibleMoves.Add(move);
}
}
canDoCastling = true;
for (int i = actualSquare.X - 1; i > 0; i--)
{
if (board[actualSquare.Y, i].PieceContainer != null || otherPlayer.CheckIfSquareIsInMoves(board[actualSquare.Y, i]))
{
canDoCastling = false;
break;
}
}
if (!isMoved && canDoCastling && board[actualSquare.Y, 0].PieceContainer != null && board[actualSquare.Y, 0].PieceContainer is Rook)
{
Rook rook = board[actualSquare.Y, 0].PieceContainer as Rook;
if (!rook.IsMoved)
{
Move move = new Move(board[actualSquare.Y, actualSquare.X - 2]);
int y = ActualSquare.Y;
int x = ActualSquare.X - 1;
int previousX = rook.ActualSquare.X;
int previousY = rook.ActualSquare.Y;
move.RegisterCallback(() =>
{
if (b != null)
{
rook.Move(board[y, x]);
}
else
{
rook.Move(board[y, x].RelatedBehaviour);
}
});
move.RegisterCallbackToReset(() =>
{
rook.Move(board[previousY, previousX]);
});
possibleMoves.Add(move);
}
}
}
}
public void Rook_WhenMoveBothRankAndFile_ThrowsInvalidMoveException(char file, char rank)
{
mockNewSquare.Setup(s => s.Position).Returns((file, rank));
Assert.Throws <InvalidMoveException>(() => rook.Move(mockNewSquare.Object));
}
public bool TestMoveRook(string fromPostiton, string toPosition, bool isWhite)
{
var rook = new Rook(isWhite);
return(rook.Move(fromPostiton, toPosition, isWhite));
}
