public void EmptyPoint()
{
var builder = new GameBoardBuilder ();
var board = builder.GetBoard ();
Assert.That (board.IsEmpty(Point.Make(1, 1)));
}
public Game(BoardView boardView)
{
m_boardView = boardView;
GameBoardBuilder builder = new GameBoardBuilder ();
AddGameUnity (builder,Point.Make(0,4));
m_logicBoard = builder.GetBoard ();
m_currentSelection = m_logicBoard.Select (Point.Make(-1,-1));
m_boardView.OnCellClicked.Register((x,y) =>{
//TODO: Usar state pattern
var point = Point.Make(x,y);
Debug.Log(point);
if(m_currentSelection.IsEmpty)
{
m_currentSelection = m_logicBoard.Select(point);
}
else
{
var visitor = new WalkVisitor(point);
m_currentSelection.Commands.Visit(visitor);
m_boardView.AddResult(visitor.Result);
m_currentSelection = m_logicBoard.Select (Point.Make(-1,-1));
}
});
}
public void EmptySelection()
{
var builder = new GameBoardBuilder ();
var board = builder.GetBoard ();
var selection = board.Select (Point.Make(1, 1));
Assert.That (selection.IsEmpty);
}
public void NonEmptyPoint()
{
var builder = new GameBoardBuilder ();
var board = builder.GetBoard ();
var moq = new Mock<ISelectable> ();
builder.AddSelectable (Point.Make(1, 1), moq.Object);
Assert.That (!board.IsEmpty(Point.Make(1, 1)));
}
void AddGameUnity(GameBoardBuilder builder, Point p)
{
var unit = GameUnit.Basic ().CanWalk (10,10);
var selectable = new GameUnitSelectableAdapter (unit);
m_boardView.AddUnitView (p);
builder.AddSelectable (p,selectable);
}
public static GameBoard BuildLevel(int levelNum, bool restart = false)
{
if (levelNum < 0 || levelNum >= LevelCount)
{
return(null);
}
var level = restart ? OriginalLevels.Levels[levelNum] : CurrentLevels.Levels[levelNum];
return(GameBoardBuilder.BuildBoard(level));
}
public void SetupGame()
{
var gameBoardBuilder = new GameBoardBuilder(GridSize)
.WithShips(1, ShipType.Battleship)
.WithShips(2, ShipType.Destroyer);
PlayerBoard = gameBoardBuilder.Build();
AIBoard = gameBoardBuilder.Build();
_aiPlayer = new AIPlayer(AIBoard);
}
public void GivenSizeCreatesGameBoard()
{
var builder = new GameBoardBuilder();
var board = builder.Build(new Size(2, 2));
board.Squares.Should().ContainKeys(
new Point(1, 1),
new Point(1, 2),
new Point(2, 1),
new Point(2, 2)
);
}
public void SameSelectionObject()
{
var builder = new GameBoardBuilder ();
var moq = new Mock<ISelectable> ();
var moqSelection = new Mock<ISelection> ();
moqSelection.SetupGet ((x) => x.IsEmpty).Returns (false);
var ret = moqSelection.Object;
moq.Setup ((x) => x.Select (It.IsAny<Point>(), It.IsAny<IBoardCommandFactory>())).Returns (ret);
builder.AddSelectable (Point.Make(1, 1), moq.Object);
var board = builder.GetBoard();
var selection = board.Select (Point.Make(1, 1));
Assert.AreEqual(ret,selection);
}
private void Initialize()
{
var builder = new GameBoardBuilder();
IGameBoardDirector director;
_redArmy.Initialize(1, 1, 1);
_blueArmy.Initialize(1, 1, 1);
switch (_unit)
{
case UnitType.ARCHER:
_player = _redArmy.Archer;
break;
case UnitType.FIREMAN:
_player = _redArmy.FireMan;
break;
case UnitType.ICEMAN:
_player = _redArmy.IceMan;
break;
}
switch (_level)
{
case Level.EASY:
director = new LightGameBoardDirector(builder);
break;
case Level.MEDIUM:
director = new MediumGameBoardDirector(builder);
break;
case Level.HARD:
director = new HardGameBoardDirector(builder);
break;
default:
throw new NotSupportedException();
}
director.Create(_redArmy.Units, _blueArmy.Units, _life, _weapon);
GameBoard = builder.GetGameBoard();
}
public void WalkAUnit()
{
GameBoardBuilder builder = new GameBoardBuilder ();
var unity = GameUnit.Basic ().CanWalk (10,10);
var zeroPoint = Point.Make (0, 0);
var selectable = new GameUnitSelectableAdapter (unity);
builder.AddSelectable (zeroPoint, selectable);
var board = builder.GetBoard ();
var selection = board.Select (zeroPoint);
var visitor = new WalkVisitor (Point.Make (1, 1));
selection.Commands.Visit (visitor);
Assert.That (board.IsEmpty (zeroPoint));
}
public void WalkCmdDontHaveOrigin()
{
GameBoardBuilder builder = new GameBoardBuilder ();
var unity = GameUnit.Basic ().CanWalk (10,10);
var zeroPoint = Point.Make (0, 0);
var selectable = new GameUnitSelectableAdapter (unity);
builder.AddSelectable (zeroPoint, selectable);
var board = builder.GetBoard ();
var selection = board.Select (zeroPoint);
var moq = new Mock<IBoardCommandsVisitor> ();
moq.Setup((x) => x.WalkCommand(It.IsAny<IBoardWalkCommand>())).Callback<IBoardWalkCommand>((cmd)=>{
Assert.That(!cmd.PossiblePoints.Contains(zeroPoint));
});
selection.Commands.Visit (moq.Object);
}
public void Should_BuildGameBoard_WithSpecifiedCriteria(int gridSize, int battleshipsCount, int destroyersCount)
{
// Arrange
// Act
var gameBoard = new GameBoardBuilder(gridSize)
.WithShips(battleshipsCount, ShipType.Battleship)
.WithShips(destroyersCount, ShipType.Destroyer)
.Build();
// Assert
gameBoard.Should().NotBeNull();
gameBoard.GridSize.Should().Be(gridSize);
gameBoard.Ships.Should().NotBeNull();
gameBoard.Ships.Should().HaveCount(battleshipsCount + destroyersCount);
gameBoard.Ships.Where(x => x.ShipType == ShipType.Battleship).Should().HaveCount(battleshipsCount);
gameBoard.Ships.Where(x => x.ShipType == ShipType.Destroyer).Should().HaveCount(destroyersCount);
// Check if no ships are overlapping
gameBoard.Ships.Any(ship => ship.Fields
.Any(shipField => gameBoard.Ships.Except(new[] { ship })
.SelectMany(x => x.Fields).Contains(shipField))).Should().BeFalse();
}
