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); } }
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(); }