public void MarkShot(BoardCoordinates coordinates, OneOf <Miss, Hit, Sink> shotOutcome) { shotOutcome.Switch( miss => _boardViewUpdater.Missed(coordinates), hit => _boardViewUpdater.GotHit(coordinates), sink => _boardViewUpdater.Sunken(sink.SunkenShipCoords)); }
public TicTacToeBoardFieldControl(BoardCoordinates coordinates) { Coordinates = coordinates; BorderStyle = BorderStyle.FixedSingle; Width = 10; Height = 10; }
public Space GetSpace(BoardCoordinates coordinates) { BoardLayer layer = layers[coordinates.layer]; Space space = layer.GetSpace(coordinates.column, coordinates.row); return(space); }
private ShotStatus TorpedoHit(BoardCoordinates torpedo) { ShotStatus shotStatus = ShotStatus.Miss; for (int i = 0; i < GameBoard.Ships.Count; i++) { var ship = GameBoard.Ships[i]; var boardCellStatus = (ShotTypes)Enum.Parse(typeof(ShotTypes), GameBoard.DisplayBoard[torpedo.Row, torpedo.Column]); if (CheckShipHit(ship, torpedo) && (boardCellStatus != ShotTypes.Hit && boardCellStatus != ShotTypes.Sink)) { if (ship.HitCount < ship.Size) { ship.HitCount++; } if (ship.HitCount == ship.Size) { ship.Sunk = true; shotStatus = ShotStatus.Sink; } else { shotStatus = ShotStatus.Hit; } } } return(shotStatus); }
public void LayerSelected(BoardLayer layer, int row, int column) { int i = Array.IndexOf(layers, layer); BoardCoordinates fullCoord = new BoardCoordinates(i, row, column); Messenger <BoardCoordinates> .Broadcast(GameEvent.SPACE_SELECTED, fullCoord); }
private BoardCoordinates ExtractPosition(Torpedo torpedo) { if (String.IsNullOrEmpty(torpedo.TorpedoPosition)) { throw new ArgumentOutOfRangeException("Invalid coordinates"); } var column = torpedo.TorpedoPosition.Substring(0, 1); var rowString = torpedo.TorpedoPosition.Substring(1, torpedo.TorpedoPosition.Length - 1); int row; if (!int.TryParse(rowString, out row)) { throw new ArgumentOutOfRangeException("Invalid coordinates"); } if (String.IsNullOrEmpty(column) || !Char.IsLetter(column.ToCharArray()[0])) { throw new ArgumentOutOfRangeException("Invalid coordinates"); } int columnInt = ((int)char.ToUpper(column.ToCharArray()[0]) - 64); var boardCoordinates = new BoardCoordinates { Row = row - 1, Column = columnInt - 1 }; if (!ShotInBounds(boardCoordinates)) { throw new ArgumentOutOfRangeException("Invalid coordinates"); } ; return(boardCoordinates); }
private static Color GenerateBoardFieldColor(BoardCoordinates coords) { var columnIsOdd = coords.Column % 2 == 0; var rowIsOdd = coords.Row % 2 == 0; return(columnIsOdd == rowIsOdd ? SimplifiedColors.Cyan : SimplifiedColors.DarkCyan); }
private Tile GetTileByLocation(BoardCoordinates location) { Tile tile = null; this._boardTilesMap.TryGetValue(location, out tile); return(tile); }
public TicTacToeBoardFieldControl(BoardCoordinates coordinates) { this.Coordinates = coordinates; this.BorderStyle = BorderStyle.FixedSingle; this.Width = 10; this.Height = 10; }
public void Parse_With_A_Should_Return_Null() { var input = "A"; var res = BoardCoordinates.Parse(input); Assert.Null(res); }
public void Parse_With_A_And_1_Should_Return_A1_Coordinates() { var input = "A1"; var res = BoardCoordinates.Parse(input); Assert.True(res.Coordinates == "A1"); }
public void Parse_With_A_And_1_Should_Return_BoardCoordinates() { var input = "A1"; var res = BoardCoordinates.Parse(input); Assert.IsType <BoardCoordinates>(res); }
public void Coordinates_With_A1_Should_Return_A1() { BoardCoordinates boardCoordinates = new BoardCoordinates(1, 1); var res = boardCoordinates.Coordinates; Assert.Equal("A1", res); }
public void IsLegalShot_AtLeastOneCoordinateEqualToBoardBounds_ReturnsFalse(uint column, uint row) { var coords = new BoardCoordinates(column, row); var sut = CreateSut(4, 4); var result = sut.IsLegalShot(coords); result.Should().BeFalse(); }
public void MarkShot_MissGiven_UpdatesViewWithGivenCoords() { var coords = new BoardCoordinates(5, 7); var sut = CreateSut(); sut.MarkShot(coords, new Miss()); _boardViewUpdaterMock.Verify(u => u.Missed(coords)); }
public void ReactToShot_At_Unoccuped_A1_Coordinates_Should_Return_MISSED() { Player player = new Player(); BoardCoordinates A1Coordinates = new BoardCoordinates(1, 1); var res = player.ReactToShot(A1Coordinates); Assert.True(res == ShipType.MISSED); }
public void CheckFireCoordinates_At_UnShooted_A1_Coordinates_Should_Return_A1_Coordinates() { Player player = new Player(); BoardCoordinates testCoordinates = new BoardCoordinates(1, 1); var res = player.CheckFireCoordinates(testCoordinates); Assert.True(res.Equals(testCoordinates)); }
public void IsLegalShot_CoordsWithinBoardBounds_ReturnsTrue(uint column, uint row) { var coords = new BoardCoordinates(column, row); var sut = CreateSut(4, 4); var result = sut.IsLegalShot(coords); result.Should().BeTrue(); }
public void MarkShot_HitGiven_UpdatesViewWithGivenCoords() { var coords = new BoardCoordinates(4, 3); var sut = CreateSut(); sut.MarkShot(coords, new Hit()); _boardViewUpdaterMock.Verify(u => u.GotHit(coords)); }
public IShip CreateShip <T>(BoardSquareStatus[,] gameBoard) where T : IShip { ShipDirection direction = ShipDirection.Horizontal; BoardCoordinates initialPosition = new BoardCoordinates { Row = 1, Column = 1 }; var ship = (T)Activator.CreateInstance(typeof(T), direction, initialPosition); return(ship); }
public void UpdateBoardWithShotResult_MISSED_At_A1_Coordinates_Should_Set_EnnemyBoard_At_A1_Coordinate_MISSED() { Player player = new Player(); BoardCoordinates A1Coordinates = new BoardCoordinates(1, 1); var shotResult = ShipType.MISSED; player.UpdateBoardWithShotResult(shotResult, A1Coordinates); Assert.True(player.EnnemyBoardGame.Cells.At(A1Coordinates).CellOccupant == shotResult); }
private void OnSpaceSelected(BoardCoordinates coordinates) { if (gameController.gameOver || !playerController.GetPlayer(playerController.currentPlayer).isLocal) { return; } Space selectedSpace = board.GetSpace(coordinates); if (playerController.PieceBankEmpty(playerController.currentPlayer)) { if (selectedSpace.piece == null) { if (selectedDestSpace != null) { board.GetSpace(selectedDestSpace).SetActive(false); board.GetSpace(selectedDestSpace).ClearPieceTemp(); } selectedDestSpace = coordinates; selectedSpace.SetActive(true); } else { if (selectedSpace.piece.playerNum != playerController.currentPlayer) { return; } if (selectedOriginSpace != null) { board.GetSpace(selectedOriginSpace).SetActive(false); } selectedOriginSpace = coordinates; selectedSpace.SetActive(true); } if (selectedDestSpace != null && selectedOriginSpace != null) { PieceType tempType = board.GetSpace(selectedOriginSpace).piece.type; board.GetSpace(selectedDestSpace).ApplyPieceTemp(tempType); Messenger <bool> .Broadcast(GameEvent.TOGGLE_CONFIRM_DRAWER, true); } } else { if (selectedSpace.piece != null) { return; } if (selectedDestSpace != null) { board.GetSpace(selectedDestSpace).SetActive(false); } selectedDestSpace = coordinates; selectedSpace.SetActive(true); Messenger <bool, int> .Broadcast(GameEvent.TOGGLE_PIECE_DRAWER, true, playerController.currentPlayer); } }
private static void playGame(Game i_GameToPlay) { GameBoard gameBoard = i_GameToPlay.GameBoard; mofo.ShowGameBoard(gameBoard); Player winningPlayer, losingPlayer; while (!i_GameToPlay.IsGameOver(out winningPlayer, out losingPlayer)) { Player currentPlayer = i_GameToPlay.WhosTurnIsIt(); // player that is now playing BoardCoordinates[] nextMovesCoordinates = new BoardCoordinates[2]; // The coordinates of the cards chosen by the player during the current turn if (!currentPlayer.IsComputer) { nextMovesCoordinates[0] = mofo.GetAndCheckCoordinatesInput(i_GameToPlay, currentPlayer); gameBoard.ExposeCard(nextMovesCoordinates[0]); mofo.ShowGameBoard(gameBoard); nextMovesCoordinates[1] = mofo.GetAndCheckCoordinatesInput(i_GameToPlay, currentPlayer); mofo.ShowGameBoard(gameBoard); } else { nextMovesCoordinates = i_GameToPlay.AiForComputerPlay.GetCoordinatesForNextMove(gameBoard); mofo.ShowComputerIsPlaying(); gameBoard.ExposeCard(nextMovesCoordinates[0]); mofo.ShowGameBoard(gameBoard, 1000); } if (i_GameToPlay.GuessCardAndUpdateScores(nextMovesCoordinates[1])) { mofo.ShowGameBoard(gameBoard); } else { mofo.ShowGameBoard(gameBoard, 2000); gameBoard.EraseLastMoveFromBoard(nextMovesCoordinates[1]); mofo.ShowGameBoard(gameBoard); if (i_GameToPlay.AiMode != eAiModes.Off) { i_GameToPlay.AiForComputerPlay.SaveToMemory(nextMovesCoordinates[0]); i_GameToPlay.AiForComputerPlay.SaveToMemory(nextMovesCoordinates[1]); } } } if (mofo.EndGameAndCheckForRematch(losingPlayer, winningPlayer, winningPlayer == null)) { Game newGame = new Game(gameBoard.GetHeightOfBoard(), gameBoard.GetLengthOfBoard(), i_GameToPlay.AiMode, i_GameToPlay.Player1.Name, i_GameToPlay.Player2.Name); playGame(newGame); } else { mofo.ExitGame(); } }
public void Generate_DifferentBoardSizesAndStandardFleetSize_WillGenerateWithinBounds( uint columns, uint rows) { var boardBounds = new BoardCoordinates(columns, rows); var sut = new FleetGenerator(_randomGenerator, boardBounds); var shipsToGenerate = GetShipsToGenerate(); var result = sut.Generate(shipsToGenerate); VerifyGeneratedWithinBounds(result, columns, rows); }
public void PlaceShip_CounterTorpedo_From_Unoccuped_A1_Coordinates_To_Unoccuped_A3_Coordinates_Should_Return_True() { Player player = new Player(); BoardCoordinates A1Coordinates = new BoardCoordinates(1, 1); BoardCoordinates A3Coordinates = new BoardCoordinates(1, 3); var ship = new CounterTorpedo(); var res = player.PlaceShip(ship, A1Coordinates, A3Coordinates); Assert.True(res); }
public static BoardCoordinates GetAndCheckCoordinatesInput(Game i_CurrGame, Player i_CurrentPlayer) { Console.WriteLine($"{i_CurrentPlayer.Name}, you currently have {i_CurrentPlayer.Score} pairs. please choose next coordinates"); BoardCoordinates coordinatesFromUser = new BoardCoordinates(); bool isInputValid = false; while (!isInputValid) { string inputFromUser = Console.ReadLine(); if (inputFromUser == "Q") { Console.WriteLine("\nSee you next time!"); System.Threading.Thread.Sleep(2000); Environment.Exit(0); } if (inputFromUser == null || inputFromUser.Length != 2) { Console.WriteLine("you need to put in 2 coordinates, for example 'A1'"); continue; } coordinatesFromUser = BoardCoordinates.TryParsePlacement(inputFromUser, out bool wasSuccess); if (!wasSuccess) { Console.WriteLine("you need to put in a capital letter and a number bigger than 0, for example 'A1'"); continue; } GameBoard gameBoard = i_CurrGame.GameBoard; int row = coordinatesFromUser.Row; int column = coordinatesFromUser.Column; int lengthOfBoard = gameBoard.GetLengthOfBoard(); int heightOfBoard = gameBoard.GetHeightOfBoard(); if (column >= lengthOfBoard) { Console.WriteLine($"{(char)('A' + column)} does not fit in board parameters"); } else if (row >= heightOfBoard) { Console.WriteLine($"{row + 1} does not fit in board parameters"); } else if (gameBoard.IsCardExposed(coordinatesFromUser)) { Console.WriteLine("The card you picked is already exposed"); } else { isInputValid = true; } } return(coordinatesFromUser); }
public void CheckShot_ThreeSquareUntouchedShipHit_ReturnsHitAndFleetSizeNotReduced() { var fleet = new[] { CreateOneSquareShip(), CreateTwoSquareShip(), CreateThreeSquareShip() }; var sut = CreateSupervisor(fleet); var coords = new BoardCoordinates(6, 2); var result = sut.CheckShot(coords); result.Value.Should().BeOfType <Hit>(); sut.FloatingShipsLeft.Should().Be(3); }
public void CheckFireCoordinates_At_MISSED_A1_Coordinates_Should_Return_Null() { Player player = new Player(); BoardCoordinates testCoordinates = new BoardCoordinates(1, 1); var occupedCell = player.EnnemyBoardGame.Cells.First(cell => cell.BoardCoordinates.Coordinates == testCoordinates.Coordinates); occupedCell.CellOccupant = ShipType.MISSED; var res = player.CheckFireCoordinates(testCoordinates); Assert.Null(res); }
public void CheckShot_SingleOneSquareShipHit_ReturnsSinkAndFleetSizeReducedToZero() { var fleet = new[] { CreateOneSquareShip() }; var sut = CreateSupervisor(fleet); var coords = new BoardCoordinates(2, 2); var result = sut.CheckShot(coords); result.Value.Should().BeOfType <Sink>(); result.AsT2.SunkenShipCoords.Should().Contain(CreateOneSquareShip()); sut.FloatingShipsLeft.Should().Be(0); }
public void GetCellsBetween_A1_Cell_And_D5_Cell_Should_Return_null() { BoardGame boardGame = new BoardGame(); boardGame.InitBoardGame(); var A1Coordinate = new BoardCoordinates(1, 1); var D5Coordinate = new BoardCoordinates(4, 5); var res = boardGame.GetCellsBetween(boardGame.Cells.At(A1Coordinate), boardGame.Cells.At(D5Coordinate)); Assert.Null(res); }