public void Attack(IFleet enemyFleet, BattleStratageyType battleStratageyType)
{
foreach (IAttackImplement i in availableAttackImplements.Take(10))
{
i.Fire(enemyFleet, battleStratageyType);
}
}
private IFleet GetFirstFleetsEnemy(IFleet myFleet)
{
List <IFleet> availableFleets = GetFleetsThatAreNotMe(myFleet);
var index = rnd.Next(availableFleets.Count());
return(availableFleets[index]);
}
public void AttacKEnemyShips(IFleet enemyFleet)
{
bool resetLoopAfterFire = LessThan10LeftToFire();
Fire10Ship(enemyFleet);
ResetLoop(resetLoopAfterFire);
CheckEnemyFleetHealth(enemyFleet);
}
public void EnterFieldTest()
{
IBattleField battleField = BattleFieldFactory.CreateBattleField(BattleFieldType.Small);
IFleet myfleet = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.WeekShipsFirst);
myfleet.EnterField(battleField);
Assert.True(battleField.Fleets.Count() > 0);
}
private void Fire10Ship(IFleet enemyFleet)
{
foreach (IStarShip ship in WorkingStarShips.Where(x => !x.HasFiredThisLoop).Take(10))
{
ship.Attack(enemyFleet, myBattleStratageyType);
ship.HasFiredThisLoop = true;
}
}
private static void CheckEnemyFleetHealth(IFleet enemyFleet)
{
if (enemyFleet.WorkingStarShips.Count() == 0)
{
enemyFleet.ReportDestruction();
enemyFleet.StarShips.Clear();
}
}
private static void BuildBalancedShipsCollection(IFleet balancedShips, FleetConfigurationType?fleetConfigurationType)
{
IFleetConfiguration fleetConfiguration = FleetConfigurationFactory.CreateFleetConfiguration(FleetConfigurationType.BalancedShips);
if (fleetConfigurationType.HasValue)
{
balancedShips.myFleetConfigurationType = fleetConfigurationType.Value;
}
AddShips(balancedShips, fleetConfiguration);
}
public void StartRound(IFleet myFleet)
{
if (!CheckForVictory())
{
IFleet enemyFleet = GetFirstFleetsEnemy(myFleet);
myFleet.AttacKEnemyShips(enemyFleet);
AdvanceRound(myFleet);
StartRound(GetFleetWithTurnLeft());
}
}
private static void BuildSmallShipsCollection(IFleet smallShips, FleetConfigurationType?fleetConfigurationType)
{
IFleetConfiguration fleetConfiguration = FleetConfigurationFactory.CreateFleetConfiguration(FleetConfigurationType.SmallShips);
if (fleetConfigurationType.HasValue)
{
smallShips.myFleetConfigurationType = fleetConfigurationType.Value;
}
AddShips(smallShips, fleetConfiguration);
}
public IList <IShipInfo> CreateMultipleFromFleet(IFleet fleet)
{
IList <IShipInfo> shipInfoList = new List <IShipInfo>();
IList <IShip> shipList = fleet.GetAllShips();
/* Go through each ship in the ship list of the fleet and create a ship info object.*/
foreach (var ship in shipList)
{
shipInfoList.Add(new ShipInfo(ship));
}
return(shipInfoList);
}
private void ReportBattleWon()
{
foreach (IFleet fleet in DisabledFleets)
{
fleet.LeaveField(this);
}
IFleet winner = Fleets.Where(x => x.WorkingStarShips.Count > 0).FirstOrDefault();
BattleResults.Messages.Add("The battle has been won and only the " + winner.Name + " fleet survives!");
BattleResults.Messages.Add("The " + winner.Name + " fleet still has " + Fleets.Where(x => x.WorkingStarShips.Count > 0).FirstOrDefault().WorkingStarShips.Count + " ship's left!");
}
public void AttackEnemyShipsTest()
{
IFleet myfleet = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.WeekShipsFirst);
IFleet enemyfleet = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.WeekShipsFirst);
var oTotalHealthAndArmor = enemyfleet.StarShips.Sum(x => x.Health) + enemyfleet.StarShips.Sum(x => x.Armor);
myfleet.AttacKEnemyShips(enemyfleet);
var newTotalHealthAndArmor = enemyfleet.StarShips.Sum(x => x.Health) + enemyfleet.StarShips.Sum(x => x.Armor);
var shipsDestroyed = enemyfleet.StarShips.Where(x => x.Health == 0).ToList();
Assert.True(oTotalHealthAndArmor > newTotalHealthAndArmor);
}
public void LaserAmmoNeverUnAvailableTest()
{
IAttackImplement ai = AttackImplementFactory.CreateAttackImplement(AttackImplementType.Laser);
IFleet fleet = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.WeekShipsFirst);
for (int i = 0; i < 600; i++)
{
ai.Fire(fleet, BattleStratageyType.StrongShipsFirst);
}
Assert.True(ai.AmmoAvailable);
Assert.False(ai.Ammo.HasValue);
}
public IList <IShipInfo> CreateMultipleFromFleet(IFleet fleet)
{
IList <IShip> ships = fleet.GetAllShips();
List <IShipInfo> shipInfo = new List <IShipInfo>();
if (ships != null)
{
for (int i = 0; i < ships.Count; i++)
{
shipInfo.Add(new ShipInfo(ships[i]));
}
}
return(shipInfo);
}
public void PositionShipOnGrid_RetrievesTheGameFromTheRepositoryThenGetsThePlayerAndUsesTheFleetOfThePlayerToPositionTheShip()
{
//Arrange
Guid userId = Guid.NewGuid();
Guid gameId = Guid.NewGuid();
ShipKind shipKind = ShipKind.All.NextRandomElement();
GridCoordinate[] segmentCoordinates =
{
new GridCoordinateBuilder().Build(),
new GridCoordinateBuilder().Build()
};
var gridMock = new Mock <IGrid>();
IGrid grid = gridMock.Object;
Result expectedResult = Result.CreateSuccessResult();
var fleetMock = new Mock <IFleet>();
fleetMock.Setup(f => f.TryMoveShipTo(shipKind, segmentCoordinates, grid)).Returns(expectedResult);
IFleet fleet = fleetMock.Object;
var playerMock = new Mock <IPlayer>();
IPlayer player = playerMock.Object;
playerMock.SetupGet(p => p.Fleet).Returns(fleet);
playerMock.SetupGet(p => p.Grid).Returns(grid);
var existingGameMock = new Mock <IGame>();
existingGameMock.Setup(g => g.GetPlayerById(userId)).Returns(player);
IGame existingGame = existingGameMock.Object;
_gameRepositoryMock.Setup(repo => repo.GetById(gameId)).Returns(existingGame);
//Act
var result = _service.PositionShipOnGrid(gameId, userId, shipKind, segmentCoordinates);
//Assert
Assert.That(result, Is.SameAs(expectedResult),
"The Result returned should be an instance created by the TryMoveShipTo method of the Fleet of the Player.");
_gameRepositoryMock.Verify();
existingGameMock.Verify();
fleetMock.Verify();
}
private static IBattleField SetUpBattleField()
{
IBattleField battleField = BattleFieldFactory.CreateBattleField(BattleFieldType.Large);
IFleet fleet1 = FleetFactory.CreateFleet(FleetConfigurationType.SmallShips, BattleStratageyType.WeekShipsFirst);
IFleet fleet2 = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.StrongShipsFirst);
IFleet fleet3 = FleetFactory.CreateFleet(FleetConfigurationType.HeavyShips, BattleStratageyType.NoPriority);
IFleet fleet4 = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.WeekShipsFirst);
IFleet fleet5 = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.NoPriority);
IFleet fleet6 = FleetFactory.CreateFleet(FleetConfigurationType.BalancedShips, BattleStratageyType.NoPriority);
fleet1.EnterField(battleField);
fleet2.EnterField(battleField);
fleet3.EnterField(battleField);
fleet4.EnterField(battleField);
fleet5.EnterField(battleField);
fleet6.EnterField(battleField);
return(battleField);
}
public IStarShip GetTargetShip(BattleStratageyType?battleStratageyType, IFleet enemyFleet)
{
switch (battleStratageyType)
{
case BattleStratageyType.WeekShipsFirst:
var first25Week = enemyFleet.WorkingStarShips.OrderBy(x => x.Power).OrderBy(x => x.Health).OrderBy(x => x.Armor).Take(25).ToList();
return(FindShip(first25Week));
case BattleStratageyType.StrongShipsFirst:
var first25Strong = enemyFleet.WorkingStarShips.OrderByDescending(x => x.Power).OrderByDescending(x => x.Health).OrderByDescending(x => x.Armor).Take(25).ToList();
return(FindShip(first25Strong));
case BattleStratageyType.NoPriority:
var first25Health = enemyFleet.WorkingStarShips.OrderByDescending(x => x.Health).Take(25).ToList();
return(FindShip(first25Health));
default:
var first25Null = enemyFleet.WorkingStarShips.OrderByDescending(x => x.Health).Take(25).ToList();
return(FindShip(first25Null));
}
}
public ActionResult Index(Battle battle)
{
battle = SessionController.GetSessionOrNewBattle(battle, Session["BattleField"]);
IFleet fleet = FleetFactory.CreateFleet(battle.fleetConfigurationType, battle.battleStratageyType);
if (fleet != null)
{
if (battle.myBattleField != null)
{
fleet.EnterField(battle.myBattleField);
Session.Add("BattleField", battle.myBattleField);
}
}
if (fleet != null)
{
return RedirectToRoute("Default", new { controller = "Battle", action = "Index" });
}
return View(battle);
}
