public void BeforeTests()
{
_board = new Board(8);
_rook = new Rook(PlayerColor.White);
_king = new King(PlayerColor.Black);
_referee = new Referee(new MoveAttemptHandler());
}
public static Piece GetType(string s, ChessColor color)
{
Piece p;
switch (s)
{
case "Bishop":
p = new Bishop(color);
break;
case "King":
p = new King(color);
break;
case "Knight":
p = new Knight(color);
break;
case "Pawn":
p = new Pawn(color);
break;
case "Queen":
p = new Queen(color);
break;
case "Rook":
p = new Rook(color);
break;
default:
throw new Exception("Piece unknown : " + s);
}
return p;
}
public void Whether_Rook_CantMoveToIncorrectSquare_On_CanMoveTo()
{
var board = new Board();
var rook = new Rook(new Square(4, 4), board, PieceColor.White);
Assert.That(rook.CanMoveTo(new Square(5, 5)), Is.False);
}
public void Whether_Rook_CantMoveOutsideTheBoard_On_CanMoveTo()
{
var board = new Board();
var rook = new Rook(new Square(1, 1), board, PieceColor.White);
Assert.That(rook.PossibleMoves().Count() == 14);
Assert.That(rook.CanMoveTo(new Square(-1, 1)), Is.False);
}
public void Whether_King_CantEscapeFromRookOnTheSameRank_On_CanMoveTo()
{
var board = new Board();
var king = new King(new Square(4, 4), board, PieceColor.White);
var bishop = new Rook(new Square(4, 7), board, PieceColor.Black);
Assert.That(king.CanMoveTo(new Square(4, 3)), Is.False);
}
public void Whether_Rook_CantJumpOverAnotherPiece_On_CanMoveTo(PieceColor pieceColor)
{
var board = new Board();
var rook = new Rook(new Square(4, 4), board, PieceColor.White);
var knight = new Knight(new Square(4, 5), board, pieceColor);
Assert.That(rook.CanMoveTo(new Square(4, 6)), Is.False);
}
public void Whether_Rook_CantMoveToOccupiedSquare_On_CanMoveTo()
{
var board = new Board();
var rook = new Rook(new Square(1, 1), board, PieceColor.White);
var anotherKnight = new Knight(new Square(1, 6), board, PieceColor.White);
Assert.That(rook.CanMoveTo(new Square(1, 6)), Is.False);
}
public override ChessPiece Clone(Board board)
{
var clone = new Rook(board, Color)
{
MovingStrategy = MovingStrategy.Clone(board)
};
return clone;
}
public void Whether_Rook_CanMoveToPossibleSquare_On_CanMoveTo(int offsetX, int offsetY)
{
var board = new Board();
var rook = new Rook(new Square(4, 4), board, PieceColor.White);
Assert.That(rook.CanMoveTo(
new Square(rook.Position.XPosition + offsetX,
rook.Position.YPosition + offsetY)));
}
public void Whether_Rook_ReturnsCorrectMoves_On_PossibleMoves()
{
var board = new Board();
var rook = new Rook(new Square(4, 4), board, PieceColor.White);
var possibleMoves = rook.PossibleMoves();
Assert.That(possibleMoves != null);
Assert.That(possibleMoves.Count() == 14);
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerChess"/> class.
/// </summary>
/// <param name="color">The piece color.</param>
/// <param name="gameboard">The gameboard.</param>
public PlayerChess(IPieceColor color, Gameboard gameboard)
: base(color)
{
IPiece newPiece;
int offset = 0;
this.gameboard = gameboard;
this.selectedPiece = null;
if (color == IPieceColor.White)
{
offset = 7;
}
else if (color == IPieceColor.Black)
{
offset = 0;
}
for (int i = 0; i < 8; i++)
{
newPiece = new Pawn(color, gameboard, new Position(i, Math.Abs(offset - 1)));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
}
newPiece = new Rook(color, gameboard, new Position(0, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Rook(color, gameboard, new Position(7, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Knight(color, gameboard, new Position(1, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Knight(color, gameboard, new Position(6, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Bishop(color, gameboard, new Position(2, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Bishop(color, gameboard, new Position(5, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Queen(color, gameboard, new Position(3, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new King(color, gameboard, new Position(4, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
this.King = newPiece;
}
public void TestFromFenValid()
{
const string FEN_STRING = "pQ4N1/3k3R/1r4n1/KbBbBppP/8/8/q7/7n";
FENSerializer ser = new FENSerializer();
Board expected = new Board(null);
Board actual;
// Setup
expected['8', 'A'] = new Pawn('b');
expected['8', 'B'] = new Queen('w');
expected['8', 'G'] = new Knight('w');
expected['7', 'D'] = new King('b');
expected['7', 'H'] = new Rook('w');
expected['6', 'B'] = new Rook('b');
expected['6', 'G'] = new Knight('b');
expected['5', 'A'] = new King('w');
expected['5', 'B'] = new Bishop('b');
expected['5', 'C'] = new Bishop('w');
expected['5', 'D'] = new Bishop('b');
expected['5', 'E'] = new Bishop('w');
expected['5', 'F'] = new Pawn('b');
expected['5', 'G'] = new Pawn('b');
expected['5', 'H'] = new Pawn('w');
expected['2', 'A'] = new Queen('b');
expected['1', 'H'] = new Knight('b');
// Act
actual = ser.Deserialize(FEN_STRING);
// Test
for (int file = 0; file < Board.NUM_FILES; file++)
{
for (int row = 0; row < Board.NUM_ROWS; row++)
{
Piece expectedPiece = expected[row, file];
Piece actualPiece = actual[row, file];
bool areEqual = Piece.AreEqual(expectedPiece, actualPiece);
Assert.IsTrue(areEqual);
}
}
}
public void placeBlackFigures()
{
Figure[] pawns = new Figure[8];
Figure[] otherFigures = new Figure[8];
char currentChar = 'A';
char charPositionPawn = 'A';
for (int i = 0; i < 8; i++)
{
pawns[i] = new Pawn(charPositionPawn, 2, false);
charPositionPawn++;
if ((currentChar == 'A') || (currentChar == 'H'))
{
otherFigures[i] = new Rook(currentChar, 1, false);
}
else if ((currentChar == 'B') || (currentChar == 'G'))
{
otherFigures[i] = new Knight(currentChar, 1, false);
}
else if ((currentChar == 'C') || (currentChar == 'F'))
{
otherFigures[i] = new Bishop(currentChar, 1, false);
}
else if (currentChar == 'E')
{
otherFigures[i] = new King(currentChar, 1, false);
}
else
{
otherFigures[i] = new Queen(currentChar, 1, false);
}
currentChar++;
}
for (int i = 0; i < 8; i++)
{
placeFigure(pawns[i]);
placeFigure(otherFigures[i]);
}
}
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
}
public static void TestInEquality_OneIsNull()
{
Piece piece1 = new Rook(Player.White);
Piece piece2 = null;
Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
Assert.False(piece1.Equals(piece2), "piece1.Equals(piece2) should be false");
Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
piece1 = null;
piece2 = new Bishop(Player.Black);
Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
Assert.False(piece2.Equals(piece1), "piece1.Equals(piece2) should be false");
Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
}
public void Kings_WithARookWhichHasAlreadyMoved_CannotCastle()
{
var board = new Board();
var king = new King(Player.White);
board.AddPiece(Square.At(7, 4), king);
var rook = new Rook(Player.White);
board.AddPiece(Square.At(7, 7), rook);
var pawn = new Rook(Player.Black);
board.AddPiece(Square.At(0, 3), pawn);
rook.MoveTo(board, Square.At(6, 7));
pawn.MoveTo(board, Square.At(1, 3));
rook.MoveTo(board, Square.At(7, 7));
var moves = king.GetAvailableMoves(board);
moves.Should().NotContain(Square.At(7, 6));
}
public void BlackPawn_CannotTakeEnPassant_IfWhitePawnHasNotJustMovedToPosition()
{
var board = new Board();
var whitePawn = new Pawn(Player.White);
var whiteRook = new Rook(Player.White);
var blackPawn = new Pawn(Player.Black);
var blackRook = new Rook(Player.Black);
board.AddPiece(Square.At(6, 3), whitePawn);
board.AddPiece(Square.At(2, 3), whiteRook);
board.AddPiece(Square.At(4, 4), blackPawn);
board.AddPiece(Square.At(4, 0), blackRook);
whitePawn.MoveTo(board, Square.At(4, 3));
blackRook.MoveTo(board, Square.At(0, 0));
whiteRook.MoveTo(board, Square.At(0, 3));
var moves = blackPawn.GetAvailableMoves(board).ToList();
moves.Should().NotContain(Square.At(5, 3));
}
public void AnotherTestScoreCalculator()
{
var rook = new Rook(Player.Black);
var queen = new Queen(Player.Black);
var pawn2 = new Pawn(Player.Black);
var knight = new Knight(Player.White);
var pawn = new Pawn(Player.White);
var pawn3 = new Pawn(Player.White);
var board = A.Fake <IBoard>();
A.CallTo(() => board.CapturedPieces).Returns(new List <Piece> {
rook, queen, knight, pawn, pawn2, pawn3
});
var scoreCalculator = new ScoreCalculator(board);
scoreCalculator.GetWhiteScore().Should().Be(5);
scoreCalculator.GetBlackScore().Should().Be(15);
}
public void IsSomethingInTheWay(int sourceRow, int sourceColumn, bool isBlack, int destinationRow, int destinationColumn, bool result)
{
var pawn = new Pawn
{
Row = 2,
Column = 0,
IsBlack = isBlack
};
Formation.Pieces.Add(pawn);
var rook = new Rook
{
Row = sourceRow,
Column = sourceColumn,
IsBlack = isBlack
};
var targetField = new Field(destinationRow, destinationColumn);
Assert.That(rook.CanMove(targetField), Is.EqualTo(result));
}
private void InitializeRooks(string color)
{
if (color is "White")
{
Rook rook1 = new Rook(color);
Rook rook2 = new Rook(color);
rook1.Position = new Position(1, 1);
rook2.Position = new Position(8, 1);
Pieces.Add(rook1);
Pieces.Add(rook2);
}
else
{
Rook rook1 = new Rook(color);
Rook rook2 = new Rook(color);
rook1.Position = new Position(1, 8);
rook2.Position = new Position(8, 8);
Pieces.Add(rook1);
Pieces.Add(rook2);
}
}
public static void TestInEquality_OneIsNull()
{
Piece piece1 = new Rook(Player.White);
Piece piece2 = null;
Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
Assert.False(piece1.Equals(piece2), "piece1.Equals(piece2) should be false");
Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
piece1 = null;
piece2 = new Bishop(Player.Black);
Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
Assert.False(piece2.Equals(piece1), "piece1.Equals(piece2) should be false");
Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
}
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 Board()
{
for (var x = 0; x < 8; x++)
{
_board[x, 1] = new Pawn(new Point2D(x, 1), Color.Black);
_board[x, 6] = new Pawn(new Point2D(x, 6), Color.White);
}
for (var i = 0; i < 2; i++)
{
//Rooks
_board[0, i == 1 ? 0 : 7] =
new Rook(new Point2D(0, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
_board[7, i == 1 ? 0 : 7] =
new Rook(new Point2D(7, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
_board[1, i == 1 ? 0 : 7] =
new Knight(new Point2D(1, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
_board[6, i == 1 ? 0 : 7] =
new Knight(new Point2D(6, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
_board[2, i == 1 ? 0 : 7] =
new Bishop(new Point2D(2, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
_board[5, i == 1 ? 0 : 7] =
new Bishop(new Point2D(5, i == 1 ? 0 : 7), i == 1 ? Color.Black : Color.White);
}
_board[3, 0] = new King(new Point2D(3, 0), Color.Black);
_board[4, 7] = new King(new Point2D(4, 7), Color.White);
_board[3, 7] = new Queen(new Point2D(3, 7), Color.White);
_board[4, 0] = new Queen(new Point2D(4, 0), Color.Black);
foreach (var piece in _board)
{
if (piece != null)
{
AllPieces1.Add(piece);
}
}
}
public void RochadeIsEnemyInTheWay()
{
var others = new List <ChessPieceViewModel>();
var rook = new Rook
{
Row = 0,
Column = 7,
IsBlack = true
};
var knight = new Knight
{
Row = 0,
Column = 6,
IsBlack = !true
};
others.Add(rook);
others.Add(knight);
//DoRochade(others, false);
}
// Castling uses different logic so it doesn't utilise _CheckCoords
public static void CastlingLong(List <Coords> coords, ChessPiece piece, bool move = true, bool eat = true)
{
try
{
// Only permitted if the piece is a King piece
if (piece is King && piece.GetBoard().kingInDanger == null)
{
ChessTile[,] tilesInfo = piece.GetBoard().GetBoardArray();
int x = piece.X;
int y = piece.Y;
ChessPiece p = tilesInfo[x - 4, y].Piece;
if (p is Rook)
{
Rook rook = p as Rook;
if (rook.hasMoved == true)
{
return;
}
}
if (tilesInfo[x - 1, y].Piece == null)
{
if (tilesInfo[x - 2, y].Piece == null)
{
if (tilesInfo[x - 3, y].Piece == null)
{
coords.Add(new Coords {
x = x - 2, y = y
});
}
}
}
}
}
catch (System.IndexOutOfRangeException) { return; }
}
static void Main(string[] args)
{
string figure = Console.ReadLine();
int x1 = int.Parse(Console.ReadLine());
int y1 = int.Parse(Console.ReadLine());
int x2 = int.Parse(Console.ReadLine());
int y2 = int.Parse(Console.ReadLine());
Figure myFigure;
switch (figure)
{
case "K":
myFigure = new King(x1, y1);
break;
case "N":
myFigure = new Knight(x1, y1);
break;
case "Q":
myFigure = new Queen(x1, y1);
break;
case "R":
myFigure = new Rook(x1, y1);
break;
case "B":
myFigure = new Bishop(x1, y1);
break;
default:
return;
}
Console.WriteLine(myFigure.Move(x2, y2) ? "Yes" : "No");
}
/// <summary>
/// Asez toate piesele de fiecare culoare in pozitiile lor initiale specifice
/// </summary>
private void Aranjare_Ture()
{
//setez tipul de piesa pentru celula
Global.chessBoard[1, 1].pieceType = Global.PIECE_TYPE.ROOK;
Global.chessBoard[1, 8].pieceType = Global.PIECE_TYPE.ROOK;
Global.chessBoard[8, 1].pieceType = Global.PIECE_TYPE.ROOK;
Global.chessBoard[8, 8].pieceType = Global.PIECE_TYPE.ROOK;
Global.chessBoard[1, 1].pieceColor = Global.PIECE_COLOR.BLACK;
Global.chessBoard[1, 8].pieceColor = Global.PIECE_COLOR.BLACK;
Global.chessBoard[8, 1].pieceColor = Global.PIECE_COLOR.WHITE;
Global.chessBoard[8, 8].pieceColor = Global.PIECE_COLOR.WHITE;
//desenez turele in celulele corespunzatoare
Rook blackRook1 = new Rook(Global.chessBoard[1, 1], Image.FromFile("Black Rook.png"));
AddControlToPanel(blackRook1.img_piece);
Global.AllPieces[1, 1] = blackRook1;
Console.WriteLine(Convert.ToInt32(Global.PIECE_COLOR.BLACK));
Global.ListPieces[Convert.ToInt32(Global.PIECE_COLOR.BLACK)].Add(blackRook1);
Rook blackRook2 = new Rook(Global.chessBoard[1, 8], Image.FromFile("Black Rook.png"));
AddControlToPanel(blackRook2.img_piece);
Global.AllPieces[1, 8] = blackRook2;
Global.ListPieces[Convert.ToInt32(Global.PIECE_COLOR.BLACK)].Add(blackRook2);
Rook whiteRook1 = new Rook(Global.chessBoard[8, 1], Image.FromFile("White Rook.png"));
AddControlToPanel(whiteRook1.img_piece);
Global.AllPieces[8, 1] = whiteRook1;
Global.ListPieces[Convert.ToInt32(Global.PIECE_COLOR.WHITE)].Add(whiteRook1);
Rook whiteRook2 = new Rook(Global.chessBoard[8, 8], Image.FromFile("White Rook.png"));
AddControlToPanel(whiteRook2.img_piece);
Global.AllPieces[8, 8] = whiteRook2;
Global.ListPieces[Convert.ToInt32(Global.PIECE_COLOR.WHITE)].Add(whiteRook2);
}
private Rook GetRook(int direction, int count)
{
if (!mIsFirstMove)
{
return(null);
}
int currentX = mCurrentCell.mBoardPosition.x;
int currentY = mCurrentCell.mBoardPosition.y;
for (int i = 1; i < count; i++)
{
int offsetX = currentX + (i * direction);
CellState cellState = mCurrentCell.mBoard.ValidateCell(offsetX, currentY, this);
if (cellState != CellState.Free)
{
return(null);
}
}
Cell rookCell = mCurrentCell.mBoard.mAllCells[currentX + (count * direction), currentY];
Rook rook = null;
if (rookCell.mCurrentPiece != null)
{
if (rookCell.mCurrentPiece is Rook)
{
rook = (Rook)rookCell.mCurrentPiece;
}
}
if (rook == null)
{
return(null);
}
if (rook.mColor != mColor || !rook.mIsFirstMove)
{
return(null);
}
mHighlightedCells.Add(rook.mCastleTriggerCell);
return(rook);
}
private List <Field> FindSmallerRestrictedFields()
{
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);
int fieldSize = CalculateRestrictedField(rook.Field.Horizontal, rook.Field.Vertical);
List <Field> possibleRookMoves = new List <Field>();
foreach (var field in rook.PossibleMoves)
{
if (IsRookProtected(field, king.Field))
{
var calculatedFieldSize = CalculateRestrictedField(field.Horizontal, field.Vertical);
if (calculatedFieldSize < fieldSize)
{
possibleRookMoves.Add(field);
}
}
}
return(possibleRookMoves);
}
public static void TestInEquality_OneIsNull()
{
var piece1 = new Rook(Player.White);
Piece piece2 = null;
Assert.AreNotEqual(piece1, piece2);
Assert.False(piece1.Equals(piece2));
Assert.False(piece1 == piece2);
Assert.False(piece2 == piece1);
Assert.True(piece1 != piece2);
Assert.True(piece2 != piece1);
piece1 = null;
piece2 = new Bishop(Player.Black);
Assert.AreNotEqual(piece1, piece2);
Assert.False(piece2.Equals(piece1));
Assert.False(piece1 == piece2);
Assert.False(piece2 == piece1);
Assert.True(piece1 != piece2);
Assert.True(piece2 != piece1);
}
private bool CanCastle(Rook rook)
{
// For rook
if (rook == null)
{
return(false);
}
// Do the cells match?
if (rook.mCastleTriggerCell != mCurrentCell)
{
return(false);
}
// Check if same team, and hasn't moved
if (rook.mColor != mColor || !rook.mIsFirstMove)
{
return(false);
}
return(true);
}
//Rochade Test
public void DoRochade(List <ChessPieceViewModel> otherPieces, bool result)
{
otherPieces.ForEach(Formation.Pieces.Add);
var rook = new Rook
{
Row = 0,
Column = 7,
IsBlack = false,
FirstMove = true
};
var king = new King
{
Row = 0,
Column = 4,
IsBlack = false,
FirstMove = true
};
Formation.Pieces.Add(rook);
Formation.Pieces.Add(king);
var targetField = new Field(0, 6);
Assert.That(king.CanMove(targetField), Is.EqualTo(result));
Assert.That(king.NoChess(targetField), Is.EqualTo(result));
if (result)
{
king.TryMove(targetField, Formation.Pieces);
Assert.That(king.Column, Is.EqualTo(6));
Assert.That(rook.Column, Is.EqualTo(5));
}
else
{
Assert.That(king.Column, Is.EqualTo(4));
Assert.That(rook.Column, Is.EqualTo(7));
}
}
public void getMovesTestRook()
{
/*By putting the rook on a specific panel, I have looked at
* what moves the rook should have on this panel, and made sure
* this is the same as what the function getMoves() returns*/
BoardGen board = new BoardGen();
Panel[,] gen = board.GenerateBoard();
Piece TestPiece = new Rook("WRook", gen[3, 4], false);
TestPiece.setMoves(board, false, false);
List <Panel> DesiredPossibleMoves = new List <Panel> {
gen[3, 1], gen[3, 2],
gen[3, 3], gen[3, 4], gen[3, 5], gen[0, 4], gen[1, 4], gen[2, 4],
gen[4, 4], gen[5, 4], gen[6, 4], gen[7, 4]
};
if (TestPiece.getMoves().Except(DesiredPossibleMoves).ToList().Count() != 0)
{
Assert.Fail();
}
}
public void PossibleMoves5()
{
Game game = new Game();
King whiteKing = new King(game, Color.White, new Field(Horizontal.G, Vertical._7));
Rook whiteRook = new Rook(game, Color.White, new Field(Horizontal.E, Vertical._8));
Rook blackRook = new Rook(game, Color.Black, new Field(Horizontal.G, Vertical._8));
game.AddFigures(new List <IFigure>()
{
whiteKing, whiteRook, blackRook
});
List <Field> desiredFields = new List <Field>();
desiredFields.Add(new Field(Horizontal.E, Vertical._8));
desiredFields.Add(new Field(Horizontal.F, Vertical._8));
desiredFields.Add(new Field(Horizontal.H, Vertical._8));
desiredFields.Add(new Field(Horizontal.G, Vertical._7));
AssertFields(desiredFields, blackRook.PossibleMoves);
}
public void reset()
{
if (Piece != null)
{
Board.Controls.Remove(Piece);
Piece = null;
}
if (Position.Y == 0)
{
if (Position.X == 0 || Position.X == 7)
{
Piece = new Rook(this, Color.WHITE);
}
}
if (Position.Y == 1)
{
Piece = new Pawn(this, Color.WHITE);
}
if (Position.Y == 6)
{
Piece = new Pawn(this, Color.BLACK);
}
if (Position.Y == 7)
{
if (Position.X == 0 || Position.X == 7)
{
Piece = new Rook(this, Color.BLACK);
}
}
if (Piece != null)
{
Board.Controls.Add(Piece);
}
}
public void DetectStalemate()
{
var king = new King(board, Color.White);
board.AddPieceToTheGame(king, board[0, 0]);
var enemyRook = new Rook(board, Color.Black);
board.AddPieceToTheGame(enemyRook, board[6, 1]);
var otherEnemy = new Rook(board, Color.Black);
board.AddPieceToTheGame(otherEnemy, board[1, 6]);
Assert.IsTrue(board.Stalemate(Color.White, board.GetPossibleMovesFor(Color.White)));
Assert.IsFalse(board.Checkmate(Color.White, board.GetPossibleMovesFor(Color.White)));
var friend = new Bishop(board, Color.White);
board.AddPieceToTheGame(friend, board[4, 4]);
Assert.IsFalse(board.Stalemate(Color.White, board.GetPossibleMovesFor(Color.White)));
}
public void TestMoveFurtherThanEnemyPiece_AssertFalse()
{
Piece[,] board = new Piece[8, 8];
board[3, 4] = new Pawn(false);
GameBoard myBoard = new GameBoard(board);
//Arrange
int[] currentPosition = new int[2];
currentPosition[0] = 3;
currentPosition[1] = 1;
int[] newPosition = new int[2];
newPosition[0] = 3;
newPosition[1] = 5;
//Act
Rook myKing = new Rook(true);
bool result = myKing.TestValidMove(currentPosition, newPosition);
//Assert
Assert.IsFalse(result);
}
public override void PostMoveActions()
{
if (this.canCastle)
{
// Move the Rook
// If this move was deemed valid in the first place, the Rook should be there in said position
if (this.GetCurrentPosition().GetColumn() == 2)
{
// King side castling
Rook kingSideRook = (Rook)this.chessBoard.GetPieceAtPosition(new Position(1, this.GetCurrentPosition().GetRow()));
this.chessBoard.MoveTo(kingSideRook, new Position(3, kingSideRook.GetCurrentPosition().GetRow()));
}
else if (this.GetCurrentPosition().GetColumn() == 6)
{
// Queen side castling
Rook queenSideRook = (Rook)this.chessBoard.GetPieceAtPosition(new Position(8, this.GetCurrentPosition().GetRow()));
this.chessBoard.MoveTo(queenSideRook, new Position(5, queenSideRook.GetCurrentPosition().GetRow()));
}
this.canCastle = false;
}
}
private BoardData()
{
for (var i = 0; i < 8; i++)
{
for (var j = 0; j < 8; j++)
{
arrPiece[i, j] = null;
}
}
for (int x = 0; x < 8; x++)
{
arrPiece[x, 1] = new Pawn(PieceSide.White, new Point(x, 1));
arrPiece[x, 6] = new Pawn(PieceSide.Black, new Point(x, 6));
}
arrPiece[0, 0] = new Rook(PieceSide.White, new Point(0, 0));
arrPiece[7, 0] = new Rook(PieceSide.White, new Point(7, 0));
arrPiece[0, 7] = new Rook(PieceSide.Black, new Point(0, 7));
arrPiece[7, 7] = new Rook(PieceSide.Black, new Point(7, 7));
arrPiece[1, 0] = new Knight(PieceSide.White, new Point(1, 0));
arrPiece[6, 0] = new Knight(PieceSide.White, new Point(6, 0));
arrPiece[1, 7] = new Knight(PieceSide.Black, new Point(1, 7));
arrPiece[6, 7] = new Knight(PieceSide.Black, new Point(6, 7));
arrPiece[2, 0] = new Bishop(PieceSide.White, new Point(2, 0));
arrPiece[5, 0] = new Bishop(PieceSide.White, new Point(5, 0));
arrPiece[2, 7] = new Bishop(PieceSide.Black, new Point(2, 7));
arrPiece[5, 7] = new Bishop(PieceSide.Black, new Point(5, 7));
arrPiece[3, 0] = new Queen(PieceSide.White, new Point(3, 0));
arrPiece[3, 7] = new Queen(PieceSide.Black, new Point(3, 7));
arrPiece[4, 0] = new King(PieceSide.White, new Point(4, 0));
kingPiece.Add(PieceSide.White, arrPiece[4, 0]);
arrPiece[4, 7] = new King(PieceSide.Black, new Point(4, 7));
kingPiece.Add(PieceSide.Black, arrPiece[4, 7]);
}
/*
* A Helper method for placing the starting pieces in the correct location
*/
private IPiece AddStartingPiece(int row, int col, ChessColor color)
{
IPiece piece;
// Adds piece to a List, 0/7 for non pawns, else it has to be a pawn
if (row == 0 || row == XDim - 1)
{
if (col == 0 || col == YDim - 1)
{
piece = new Rook(color);
}
else if (col == 1 || col == YDim - 2)
{
piece = new Knight(color);
}
else if (col == 2 || col == YDim - 3)
{
piece = new Bishop(color);
}
else if (col == 3)
{
piece = new Queen(color);
}
else
{
piece = new King(color);
}
}
else
{
piece = new Pawn(color);
}
piece.ColID = col;
piece.RowID = row;
pieces.Add(piece);
return(piece);
}
public void InCheckWhiteIllegalMoveBot()
{
var bot = new ChessBot(new OnlyPieceCountMatterEvaluator(), 3, Color.White, true);
var c = new ChessBoard();
var board = new Piece[8, 8];
board[0, 2] = new King(Color.Black)
{
AmountOfMoves = 2
};
board[0, 4] = new Rook(Color.Black)
{
AmountOfMoves = 1
};
board[1, 6] = new Knight(Color.Black);
board[2, 6] = new Pawn(Color.Black);
board[2, 7] = new Pawn(Color.Black);
board[3, 0] = new Pawn(Color.Black);
board[5, 1] = new Bishop(Color.Black);
board[2, 2] = new Bishop(Color.White);
board[3, 1] = new Knight(Color.White);
board[4, 0] = new Pawn(Color.White);
board[4, 1] = new Pawn(Color.White);
board[4, 3] = new Pawn(Color.White);
board[5, 4] = new King(Color.White);
board[5, 6] = new Pawn(Color.White);
board[6, 3] = new Bishop(Color.White);
c.Board = board;
var allMoves = c.GetAllAvailableMoves(Color.White);
bot.FindMove(c);
Assert.AreEqual(6, allMoves.Count());
}
public void PlayerWhiteRookShouldEatPawnNotDefended()
{
// Requires to calculate more than next move to spot
// 8 P
// 7 P P
// 6 P P
// 5P R P
// 4
// 3
// 2
// 1
// ABCDEFGH
var logic = new Logic(true);
logic.Board = new Board();
// Pawns
var pawnPositions = new List <string> {
"a5", "b6", "c7", "d8", "e7", "f6", "g5"
};
var asTuples = pawnPositions.Select(p => p.ToTuple()).ToList();
CreatePawns(asTuples, logic.Board, false);
//
var whiteRook = new Rook(true);
whiteRook.CurrentPosition = "d5".ToTuple();
logic.Board.AddNew(whiteRook);
var playerMove = logic.CreateMove();
// Let's see if the best move selected
// Seems like d7 and d8 would be equally good
playerMove.Move.EndPosition.ShouldBe("d7");
Logger.LogMessage($"Test: {nameof(PlayerWhiteRookShouldEatPawnNotDefended)}, diagnostics: {playerMove.Diagnostics}");
}
public void Execute()
{
_moveCommand.Execute();
var square = _board.SquareAt(Move.TargetCoordinate);
Piece piece;
switch (Move.PromotePieceType)
{
case Type.Bishop:
piece = new Bishop(Move.PieceColor, square);
break;
case Type.King:
piece = new King(Move.PieceColor, square);
break;
case Type.Queen:
piece = new Queen(Move.PieceColor, square);
break;
case Type.Pawn:
piece = new Pawn(Move.PieceColor, square);
break;
case Type.Knight:
piece = new Knight(Move.PieceColor, square);
break;
case Type.Rook:
piece = new Rook(Move.PieceColor, square);
break;
default:
throw new ArgumentOutOfRangeException();
}
square.Piece = piece;
}
public bool Castling(Vector2 clickLocalPos)
{
Vector2 diff = clickLocalPos - FigCoords;
Vector2 absDiff = new Vector2(Math.Abs(diff.x), Math.Abs(diff.y));
if (absDiff.x == 2 && diff.y == 0 && canCastling)
{
Rook castledRook = diff.x > 0 ? r2 : r1;
if (castledRook is Rook && castledRook.canCastling && !isCheck)
{
int diffKingAndRook = (int)castledRook.FigCoords.x - (int)FigCoords.x;
int absDiffKingAndRook = Math.Abs(diffKingAndRook);
if (diffKingAndRook < 0)
{
for (int i = 1; i < absDiffKingAndRook; i++)
{
if (Gameplay.keyValuePairs[(int)castledRook.FigCoords.x + i, (int)FigCoords.y] is Figure)
{
return(false);
}
}
}
else
{
for (int i = 1; i < absDiffKingAndRook; i++)
{
if (Gameplay.keyValuePairs[(int)castledRook.FigCoords.x - i, (int)FigCoords.y] is Figure)
{
return(false);
}
}
}
return(true);
}
}
return(false);
}
public void RookNumberOfMoves_RookCannotCaptureFriendlyPieces_FivePossibleMoves()
{
var board = new BasePiece[8, 8];
var Rook = new Rook()
{
Color = Color.White, Location = new Vector(0, 0)
};
var Pawn = new Pawn()
{
Color = Color.White, Location = new Vector(2, 0)
};
var Bishop = new Bishop()
{
Color = Color.White, Location = new Vector(0, 5)
};
board[0, 0] = Rook;
board[2, 0] = Pawn;
board[0, 5] = Bishop;
var possibleMoves = Rook.GetMoves(board).Length;
Assert.AreEqual(5, possibleMoves);
}
public void BeforeEachTest()
{
Target = new Rook();
}
public void Whether_Piece_PositionUpdatedRaised_On_PieceMoved()
{
var board = new Board();
var newPos = new Square(1, 6);
var moved = false;
var rook = new Rook(new Square(1, 1), board, PieceColor.White);
rook.PositionUpdated += (s, p) => moved = true;
rook.MoveTo(newPos);
Assert.That(moved, Is.True);
}
// images[blksq/whtsq][side][idx] - idx = {KING, QUEEN, ROOK, KNIGHT, BISHOP}
public ChessPiece createPiece(PieceType type,
ColorType color,
int rank, int file)
{
ChessPiece piece = null;
ChessSide myside, oppside;
if (color == ColorType.WHITE)
{
myside = whites;
oppside = blacks;
}
else
{
myside = blacks;
oppside = blacks;
}
switch (type)
{
case PieceType.KING:
piece = new King (color, rank, file,
myside, oppside);
break;
case PieceType.QUEEN:
piece = new Queen (color, rank,
file, myside,
oppside);
break;
case PieceType.ROOK:
piece = new Rook (color, rank, file,
myside, oppside);
break;
case PieceType.KNIGHT:
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case PieceType.BISHOP:
piece = new Bishop (color, rank,
file, myside,
oppside);
break;
default:
return null;
}
return piece;
}
private static void GetPieceForFENChar(char fench,
ChessSide
whites,
ChessSide
blacks,
int rank,
int file,
out ChessPiece
piece)
{
ColorType color;
ChessSide myside, oppside;
if (Char.IsUpper (fench))
{
color = ColorType.WHITE;
myside = whites;
oppside = blacks;
}
else
{
color = ColorType.BLACK;
myside = blacks;
oppside = whites;
}
char ch = Char.ToLower (fench);
switch (ch)
{
case 'p':
piece = new Pawn (color, rank, file,
myside, oppside);
break;
case 'k':
piece = new King (color, rank, file,
myside, oppside);
break;
case 'q':
piece = new Queen (color, rank,
file, myside,
oppside);
break;
case 'b':
piece = new Bishop (color, rank,
file, myside,
oppside);
break;
case 's':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'n':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'r':
piece = new Rook (color, rank, file,
myside, oppside);
break;
default:
throw new
ChessException
(Catalog.GetString("Invalid piece type ") +
ch);
}
}
public void Whether_Piece_CantMoveWhenIsWhiteMove_On_MoveTo()
{
var board = new Board();
var newPos = new Square(1, 6);
var oldPos = new Square(1, 1);
var rook = new Rook(oldPos, board, PieceColor.Black);
var hasMoved = rook.MoveTo(newPos);
Assert.That(board.IsWhiteMove);
Assert.That(rook.Position.Equals(oldPos));
Assert.That(!hasMoved);
}
private bool Equals(Rook other)
{
return !ReferenceEquals(null, other)
&& Color == other.Color;
}
public void Whether_Piece_UpdatesPosition_On_MoveTo()
{
var board = new Board();
var newPos = new Square(1, 6);
var rook = new Rook(new Square(1, 1), board, PieceColor.White);
rook.MoveTo(newPos);
Assert.That(rook.Position.Equals(newPos));
}
public void Whether_Board_UpdatesIsWhiteMove_On_MoveTo()
{
var board = new Board();
var newPos = new Square(1, 6);
var oldPos = new Square(1, 1);
var rook = new Rook(oldPos, board, PieceColor.White);
var hasMoved = rook.MoveTo(newPos);
Assert.That(rook.Position.Equals(newPos));
Assert.IsFalse(board.IsWhiteMove);
Assert.That(hasMoved);
}
public void BeforeEachTest()
{
this.Target =new Rook();
this.MovesFrom11 = Target.GetMovesFrom(new BoardCoordinate(1, 1));
}
private static IPiece InitialPieceAtLocation(Rank rank, File file)
{
var emptyRanks = new[] { Rank.Three, Rank.Four, Rank.Five, Rank.Six};
if (emptyRanks.Contains(rank))
{
return null;
}
var colour = PlayerColour.Black;
if (rank == Rank.One || rank == Rank.Two)
{
colour = PlayerColour.White;
}
IPiece piece = new Rook(colour);
if (rank == Rank.Seven || rank == Rank.Two)
{
piece = new Pawn(colour);
}
else if (file == File.B || file == File.G)
{
piece = new Knight(colour);
}
else if (file == File.C || file == File.F)
{
piece = new Bishop(colour);
}
else if (file == File.D)
{
piece = new Queen(colour);
}
else if (file == File.E)
{
piece = new King(colour);
}
return piece;
}
public static void initGame()
{
Console.Clear();
//initalize game
Random rnd = new Random ();
if (rnd.Next(2)==1)
{
State.playerOneColor = "White";
}
else
{
State.playerOneColor = "Black";
}
State.moveNumber = 0;
State.turn = "White";
State.strength = 18;
//Initiate White pieces
Piece k2 = new King (4, 0, "White");
Piece q1 = new Queen(3, 0, "White");
Piece r1 = new Rook(0, 0, "White");
Piece r2 = new Rook(7, 0, "White");
Piece b1 = new Bishop (5, 0, "White");
Piece b2 = new Bishop (2, 0, "White");
Piece n1 = new Knight (1, 0, "White");
Piece n2 = new Knight (6, 0, "White");
//pawns
Piece p0 = new Pawn (0, 1, "White");
Piece p1 = new Pawn (1, 1, "White");
Piece p2 = new Pawn (2, 1, "White");
Piece p3 = new Pawn (3, 1, "White");
Piece p4 = new Pawn (4, 1, "White");
Piece p5 = new Pawn (5, 1, "White");
Piece p6 = new Pawn (6, 1, "White");
Piece p7 = new Pawn (7, 1, "White");
//Initiate Black pieces
Piece k1 = new King (4, 7, "Black");
Piece q2 = new Queen (3, 7, "Black");
Piece r3 = new Rook (0, 7, "Black");
Piece r4 = new Rook (7, 7, "Black");
Piece b3 = new Bishop(5, 7, "Black");
Piece b4 = new Bishop(2, 7, "Black");
Piece n3 = new Knight (1,7, "Black");
Piece n4 = new Knight (6,7, "Black");
//pawns
Piece p8 = new Pawn (0, 6, "Black");
Piece p9 = new Pawn (1, 6, "Black");
Piece p10 = new Pawn (2, 6, "Black");
Piece p11 = new Pawn (3, 6, "Black");
Piece p12 = new Pawn (4, 6, "Black");
Piece p13 = new Pawn (5, 6, "Black");
Piece p14 = new Pawn (6, 6, "Black");
Piece p15 = new Pawn (7, 6, "Black");
//Add pieces to piece array
Piece[] pieces = new Piece[] {k1, k2, q1, q2,
r1, r2, r3, r4, n1, n2, n3, n4, b1, b2, b3, b4,
p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15};
//Send setup back to the state
State.addPiece(pieces);
}
public void Setup()
{
Target = new Rook();
}
