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