public void IsChecking_NoPiecesTest() { var bs = TestUtils.CreateBoardState(Array.Empty <(Index, Team, Piece)>()); Assert.False(MoveValidator.IsChecking(Team.White, bs, null)); Assert.False(MoveValidator.IsChecking(Team.Black, bs, null)); }
/* * The King can move in any direction by 1 space, unless it is Castling. * The King asks the Move Validator if it is allowed to Castle. * It is only a valid move if it can Castle, or if the square it's moving from has a piece and it is not * moving to itself. Also need to check if the space it's moving to is not occupied by it's own colored pieces. */ public bool IsValidMove(GameBoard gb, Square fromSquare, Square toSquare) { int fromRow = fromSquare.RowID; int fromCol = fromSquare.ColID; int toRow = toSquare.RowID; int toCol = toSquare.ColID; bool isOccupied = MoveValidator.IsOccupied(toSquare); bool isEnemy = MoveValidator.IsEnemy(fromSquare, toSquare); if (fromSquare.Piece == null || fromSquare.Piece == toSquare.Piece) { return(false); } bool isCastle = MoveValidator.IsCastle(gb, fromSquare, toSquare); if (isCastle) { return(true); } if (((toRow == fromRow + 1 && toCol == fromCol) || (toCol == fromCol + 1 && toRow == fromRow) || (toRow == fromRow - 1 && toCol == fromCol) || (toCol == fromCol - 1 && toRow == fromRow) || (toRow == fromRow + 1 && toCol == fromCol + 1) || (toRow == fromRow - 1 && toCol == fromCol - 1) || (toRow == fromRow + 1 && toCol == fromCol - 1) || (toRow == fromRow - 1 && toCol == fromCol + 1)) && (!isOccupied || isEnemy)) { return(true); } return(false); }
private static void TestMove() { var board = MakeBoard("rnbqkbnr/pppppppp/8/8/8/3P4/PPP1PPPP/RNBQKBNR b KQkq -"); //board.DoMove2(new Move(ChessPosition.D2, ChessPosition.D3, ChessPiece.WhitePawn)); //board.UndoMove(); Console.WriteLine(board.Print()); var slidingMoveGenerator = new MagicBitboardsService(); //var evaluationService = new EvaluationService(); //Console.WriteLine(evaluationService.Evaluate(board)); var attacksService = new AttacksService(slidingMoveGenerator); var pinDetector = new PinDetector(slidingMoveGenerator); var validator = new MoveValidator(attacksService, slidingMoveGenerator, pinDetector); var movesService = new MoveGenerator(attacksService, slidingMoveGenerator, pinDetector, validator); var forWhite = true; var moves = new Move[218]; var moveCount = 0; movesService.GetAllLegalMoves(board, moves, ref moveCount); //var dests = moves.Select(x => x.To); //var toMoveBoard = fact.PositionsToBitBoard(dests); //var attacked = attacksService.GetAllAttacked(board); //var newMove = new Move(4,2,ChessPiece.WhiteKing); //board.DoMove2(newMove); //Debugging.ShowBitBoard(board.BitBoard[ChessPiece.WhiteKing], board.BitBoard[ChessPiece.WhiteRook]); }
public void MoveIsValidWhenCheckingToPlaceSymbolOnVacantSpot() { var board = new Board(3); var move = new Move(1, 1); Assert.True(MoveValidator.IsValidMove(move, board)); }
private void ValidateButton_Click(object sender, RoutedEventArgs e) { //UpdateBoard(); if (MoveValidator.Validate(game.gs, BoardCharView, game.movementRecorder) != -1 && !game.GameEnd()) { ListingWords(game.gs.CorrectWords); game.UpdateState(BoardCharView); GetNewTiles(); LogBoardWriter(game.gs.ListOfPlayers[PlayerNow].ToString()); PlayerNow = game.NextPlayer(); UpdatePlayerInfoLbl(PlayerNow); Console.WriteLine("PlayerNow:" + PlayerNow); //gs.Update(bc, PlayerNow, sum); LoadBoardView(); LoadRackView(); } else { LogBoardWriter("Game Judge: \"You didn't score. Please try again!\""); LoadBoardView(); Retry(); } if (game.GameEnd()) { foreach (Player p in game.gs.ListOfPlayers) { LogBoardWriter(game.gs.ListOfPlayers[PlayerNow].ToString()); } game.gs.ListOfPlayers.Sort(); LogBoardWriter("Game Winner is Player " + (game.gs.ListOfPlayers[0].Id + 1) + " with scores" + (game.gs.ListOfPlayers[0].Score) + "!!!"); } }
/// <summary> /// Picks up a piece on the board /// </summary> void TryPickup() { RaycastHit hit; Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out hit) && hit.transform.tag == "chessPiece") { heldPiece = hit.transform.GetComponent <PieceScript>(); if (heldPiece.team == GameManager.Instance.playerTeam) { ClearValidMoves(); List <int> moves = MoveValidator.FindValidMoves(BoardManager.PositionToBoardIndex(hit.transform.position), BoardManager.BoardToCharArray(board)); for (int i = 0; i < moves.Count; i++) { validMoves.Add(board[moves[i]]); } ApplyHighlight(); } else { heldPiece = null; } } }
public void MoveIsInvalidWhenCheckingToPlaceSymbolOnSpotOutsideOfBoundaries() { var board = new Board(3); var move = new Move(4, 4); Assert.False(MoveValidator.IsValidMove(move, board)); }
public async Task ValidateMoveAsync_FirstMove_CorrectMoveNumber() { // arrange var moveRepositoryMock = new Mock <IMoveRepository>(); moveRepositoryMock .Setup(m => m.GetMovesForGame(It.IsAny <string>(), CancellationToken.None)) .Returns(() => Task.FromResult(new List <Move>())) .Verifiable(); var gameManager = new MoveValidator(moveRepositoryMock.Object); // act MoveResult result = await gameManager.ValidateMoveAsync( new Move { GameId = "abc", BoardPosition = new Position { X = 0, Y = 0 }, TilePosition = new Position { X = 0, Y = 0 }, Player = Player.Cross }, CancellationToken.None); // assert result.Move.MoveNumber.Should().Be(1); }
public void Coordinate_Is_Invalid_When_Placing_Move_On_Spot_Outside_Of_Boundaries() { var board = new Board(4); var coordinate = new Coordinate(4, 4); Assert.False(MoveValidator.IsValidMove(coordinate, board)); }
public void WhenPromotionIsRequiredAndPromotionMoveWasGivenPromoteAndReturnTrue() { var boardMock = new Mock <IChessBoard>(MockBehavior.Strict); var promotionDetectorMock = new Mock <IPromotionDetector>(MockBehavior.Strict); var movementMock = new Mock <ILegalMovement>(MockBehavior.Strict); var currentPlayer = ChessColor.White; var piecePosition = new Position(0, 1); var pieceDestination = new Position(0, 3); var chessMove = new ChessMove(piecePosition, pieceDestination, pawnPromotion: ChessPieceType.Queen); boardMock .Setup(b => b.Move(chessMove)); promotionDetectorMock .Setup(c => c.IsPromotionRequired()) .Returns(true); var moveValidator = new MoveValidator(boardMock.Object, movementMock.Object, promotionDetectorMock.Object); var result = moveValidator.ValidateAndMove(chessMove, currentPlayer); Assert.AreEqual(true, result); boardMock .Verify(b => b.Move(chessMove)); }
public void Coordinate_Is_Invalid_When_It_Is_Negative() { var board = new Board(4); var coordinate = new Coordinate(-2, 0); Assert.False(MoveValidator.IsValidMove(coordinate, board)); }
public void WhenTryingToMoveEmptySpaceReturnFalse() { var boardMock = new Mock <IChessBoard>(MockBehavior.Strict); var promotionDetectorMock = new Mock <IPromotionDetector>(MockBehavior.Strict); var movementMock = new Mock <ILegalMovement>(MockBehavior.Strict); var examplePieceMock = new Mock <IReadOnlyChessPiece>(MockBehavior.Strict); var currentPlayer = ChessColor.Black; var piecePosition = new Position(0, 1); var pieceDestination = new Position(0, 3); var chessMove = new ChessMove(new Position(1, 6), pieceDestination); examplePieceMock .SetupGet(p => p.Position) .Returns(piecePosition); boardMock .SetupGet(b => b.Pieces) .Returns(new List <IReadOnlyChessPiece>() { examplePieceMock.Object }); promotionDetectorMock .Setup(c => c.IsPromotionRequired()) .Returns(false); var moveValidator = new MoveValidator(boardMock.Object, movementMock.Object, promotionDetectorMock.Object); var result = moveValidator.ValidateAndMove(chessMove, currentPlayer); Assert.AreEqual(false, result); }
private void SetMoveIndicator(SelectionDetails s, Tile tile) { if (tile == null) { moveIndicator.enabled = false; return; } moveIndicator.enabled = true; var color = MoveValidator.IsValidMove(s.selectedPawn, tile) ? Color.white : Color.red; moveIndicator.SetPositions(new Vector3[] { s.selectedPawn.transform.position + Vector3.up * 0.5f, tile.transform.position + Vector3.up * 0.5f }); var gradient = moveIndicator.colorGradient; gradient.SetKeys( new GradientColorKey[1] { new GradientColorKey(color, 0f) }, new GradientAlphaKey[1] { new GradientAlphaKey(1f, 0f) } ); moveIndicator.colorGradient = gradient; }
public void Coordinate_Is_Valid_When_Placing_Move_On_Vacant_Spot() { var board = new Board(4); var coordinate = new Coordinate(1, 1); Assert.True(MoveValidator.IsValidMove(coordinate, board)); }
private bool IsThroughCheck(Move move, BoardState boardState) { var color = boardState.PiecePositions[move.StartPosition.X, move.StartPosition.Y].Color; if (MoveValidator.IsSquareAttacked(move.StartPosition, color, boardState)) { return(true); } for (int x = move.StartPosition.X; x != move.EndPosition.X; x += Math.Sign(move.EndPosition.X - move.StartPosition.X)) { var position = new Coordinate { X = x, Y = move.StartPosition.Y }; if (MoveValidator.IsSquareAttacked(position, color, boardState)) { return(true); } } return(false); }
/// <summary> /// Generates the next possible moves on the current board. There is no depth or ply to these moves /// </summary> /// <param name="currentBoard">board to analize</param> /// <param name="AiTurn">Whether it is the AI's turn or the players</param> /// <returns>A list of moves which are possible this turn</returns> public static List <Move> GenerateNextMoves(char[] currentBoard, bool AiTurn) { List <Move> movesQueue = new List <Move>(); List <int> myPieces; if (AiTurn) { myPieces = BoardManager.GetTeamPieceIndexes(currentBoard, GameManager.Instance.aiTeam); } else { myPieces = BoardManager.GetTeamPieceIndexes(currentBoard, GameManager.Instance.playerTeam); } foreach (int pieceIndex in myPieces) { List <int> possibleMoves = MoveValidator.FindValidMoves(pieceIndex, currentBoard); foreach (int move in possibleMoves) { movesQueue.Add(new Move(currentBoard, pieceIndex, move)); } } return(movesQueue = Prioritize(movesQueue, AiTurn)); }
public void MoveIsInvalidWhenCheckingToPlaceSymbolOnSpotWithNegativeCoordinates() { var board = new Board(3); var move = new Move(-1, -2); Assert.False(MoveValidator.IsValidMove(move, board)); }
public Games(Board b, BoardPresenter bp, MoveValidator mv, MoveExecutor me) { Board = b; BoardPresenter = bp; MoveValidator = mv; MoveExecutor = me; ActivePlayer = EPlayer.White; }
public IChessGame Create() { var piecesFactory = new PiecesFactory(); var movementHistory = new MovementHistory(); var piecePromoter = new PiecePromoter(movementHistory); var castlingMover = new CastlingMover(movementHistory); var enPassantMover = new EnPassantMover(movementHistory); var pieceMover = new PieceMover(movementHistory, piecePromoter, castlingMover, enPassantMover); var chessBoard = new ChessBoard(piecesFactory, pieceMover); List <IMovement> movements = new(); var pawnMovement = new PawnMovement(chessBoard); var enPassantMovement = new EnPassantMovement(chessBoard); var kingMovement = new KingMovement(chessBoard); var horizontalMovement = new HorizontalMovement(chessBoard); var verticalMovement = new VerticalMovement(chessBoard); var pdiagonalMovement = new PositiveDiagonalMovement(chessBoard); var ndiagonalMovement = new NegativeDiagonalMovement(chessBoard); var knightMovement = new KnightMovement(chessBoard); movements.Add(pawnMovement); movements.Add(enPassantMovement); movements.Add(kingMovement); movements.Add(horizontalMovement); movements.Add(verticalMovement); movements.Add(pdiagonalMovement); movements.Add(ndiagonalMovement); movements.Add(knightMovement); var movementComposite = new MovementComposite(movements); List <IMovement> movementsWithCastling = new(); var queensideCastlingMovement = new QueensideCastlingMovement(chessBoard, movementComposite); var kingsideCastlingMovement = new KingsideCastlingMovement(chessBoard, movementComposite); movementsWithCastling.Add(movementComposite); movementsWithCastling.Add(queensideCastlingMovement); movementsWithCastling.Add(kingsideCastlingMovement); var movementCompositeWithCastling = new MovementComposite(movementsWithCastling); var promotionDetector = new PromotionDetector(chessBoard); var checkDetector = new CheckDetector(chessBoard, movementCompositeWithCastling); var legalMovement = new LegalMovement(chessBoard, movementCompositeWithCastling, checkDetector); var moveValidator = new MoveValidator(chessBoard, legalMovement, promotionDetector); var gameFinishedDetector = new GameFinishedDetector(checkDetector, legalMovement); return(new ChessGame(chessBoard, moveValidator, promotionDetector, gameFinishedDetector, legalMovement)); }
public static MoveValidator Create(Board board) { MoveValidator validator = new MoveValidator() { _board = board }; return(validator); }
[Fact] public void MoveIsInvalidWhenCheckingToPlaceSymbolOnFilledSpot() { var board = new Board(3); var validMove = new Move(1, 1); var invalidMove = new Move(1, 1); board.PlaceSymbolToCoordinates(Symbol.Cross, validMove); Assert.False(MoveValidator.IsValidMove(invalidMove, board)); }
private void CreateValidator() { board = new Board(5, 5); troopMap = new TroopMap(board); player0 = PlayerSide.Red; wb = new WavesBuilder(); validator = new MoveValidator(troopMap, board, player0); validator.ToggleActivePlayer(); }
public MoveTest() { _move = new Move() { BeerId = "1", NewLocation = "T", UserName = "******" }; _validator = new MoveValidator(); }
public bool Validate(char[,] bc) { if (MoveValidator.Validate(gs, bc, moveRecorder) != -1 && !GameEnd()) { return(true); } else { return(false); } }
public void Coordinate_Is_Invalid_When_Placing_Move_On_Revealed_Spot() { var board = new Board(4); var validCoordinate = new Coordinate(1, 1); var invalidCoordinate = new Coordinate(1, 1); var square = board.GetSquare(validCoordinate); square.IsRevealed = true; Assert.False(MoveValidator.IsValidMove(invalidCoordinate, board)); }
public void IsOccupiedTest() { GameBoard gb = new GameBoard(8, 8); bool actual = MoveValidator.IsOccupied(gb.squares[1, 0]); Assert.AreEqual(true, actual); actual = MoveValidator.IsOccupied(gb.squares[2, 0]); Assert.AreEqual(false, actual); }
public void IsEnemyTest() { GameBoard gb = new GameBoard(8, 8); bool actual = MoveValidator.IsEnemy(gb.squares[6, 0], gb.squares[1, 0]); Assert.AreEqual(true, actual); actual = MoveValidator.IsEnemy(gb.squares[1, 1], gb.squares[1, 0]); Assert.AreEqual(false, actual); }
/* * Since a Queen can move like either a Rook or a Bishop, reuses their ValidMove * code in the MoveValidator */ public bool IsValidMove(GameBoard gb, Square fromSquare, Square toSquare) { bool rookValid = MoveValidator.RookMove(gb, fromSquare, toSquare); bool bishopValid = MoveValidator.BishopMove(gb, fromSquare, toSquare); if (rookValid || bishopValid) { return(true); } return(false); }
void Awake() { if (moveGenerator == null) { moveGenerator = GetComponent <MoveGenerator>(); } if (moveValidator == null) { moveValidator = GetComponent <MoveValidator>(); } move = GetComponent <Move>(); SetReturning(false); }
/* * The knight moves in horizontally or vertically 2 spaces, then the other direction * 1 space. It is only a valid move if the square it's moving from has a piece and it is not moving to * itself. Also need to check if the space it's moving to is not occupied by it's own colored pieces. */ public bool IsValidMove(GameBoard gb, Square fromSquare, Square toSquare) { int fromRow = fromSquare.RowID; int fromCol = fromSquare.ColID; int toRow = toSquare.RowID; int toCol = toSquare.ColID; bool isOccupied = MoveValidator.IsOccupied(toSquare); bool isEnemy = MoveValidator.IsEnemy(fromSquare, toSquare); if (fromSquare.Piece == null || fromSquare.Piece == toSquare.Piece) { return(false); } if (toRow == fromRow + 1 && fromCol == toCol + 2 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow + 1 && fromCol == toCol - 2 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow - 1 && fromCol == toCol + 2 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow - 1 && fromCol == toCol - 2 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow + 2 && fromCol == toCol + 1 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow - 2 && fromCol == toCol + 1 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow + 2 && fromCol == toCol - 1 && (!isOccupied || isEnemy)) { return(true); } else if (toRow == fromRow - 2 && fromCol == toCol - 1 && (!isOccupied || isEnemy)) { return(true); } else { return(false); } }