public void GivenForwardAction_WhenHeadingIs18AndSpeedIs6_ThenDistanceTraveledIs6()
{
SetupFakeWorld(true, false);
var bot = FakeGameObjectProvider.GetBotAt(new Position(0, 0));
bot.PendingActions = new List <PlayerAction>
{
new PlayerAction
{
Action = PlayerActions.Forward,
Heading = 23,
PlayerId = bot.Id
}
};
bot.Speed = 6;
var expectedEndpoint = new Position(6, 2);
var expectedDistance = VectorCalculatorService.GetDistanceBetween(bot.Position, expectedEndpoint);
Assert.DoesNotThrow(() => engineService.SimulateTickForBots(WorldStateService.GetPlayerBots()));
Assert.DoesNotThrow(() => WorldStateService.ApplyAfterTickStateChanges());
var resultingDistanceTravelled = VectorCalculatorService.GetDistanceBetween(new Position(0, 0), bot.Position);
var varianceBetweenExpectedAndActualEndpoint = VectorCalculatorService.GetDistanceBetween(bot.Position, expectedEndpoint);
var pathPoints = VectorCalculatorService.CollectCollisionDetectionPointsAlongPath(new Position(0, 0), new Position(6, 2), 23);
Assert.AreEqual(6, expectedDistance);
Assert.AreEqual(expectedEndpoint, bot.Position);
Assert.AreEqual(expectedDistance, resultingDistanceTravelled);
Assert.Zero(varianceBetweenExpectedAndActualEndpoint);
}
public void GivenListOf4PlayerSeedsAndEmptyList_WhenGeneratePlayerStartingFood_ThenReturnListOfFood()
{
var positions = new List <Position>();
for (var i = 0; i < EngineConfigFake.Value.BotCount; i++)
{
positions.Add(
VectorCalculatorService.GetNewPlayerStartingPosition(
i,
EngineConfigFake.Value.BotCount,
EngineConfigFake.Value.StartRadius));
}
var playerSeeds = new List <int>
{
12354789,
58228,
656846,
7108040
};
List <GameObject> foodList = worldObjectGenerationService.GeneratePlayerStartingFood(playerSeeds, new List <GameObject>());
for (int i = 0; i < foodList.Count; i++)
{
var playerIndex = (int)Math.Floor((double)i / EngineConfigFake.Value.WorldFood.PlayerSafeFood);
var distanceBetween = VectorCalculatorService.GetDistanceBetween(positions[playerIndex], foodList[i].Position);
Assert.IsTrue(
EngineConfigFake.Value.StartingPlayerSize + EngineConfigFake.Value.WorldFood.MinSeparation <= distanceBetween);
Assert.IsTrue(distanceBetween <= EngineConfigFake.Value.WorldFood.MaxSeparation);
}
Assert.AreEqual(EngineConfigFake.Value.WorldFood.PlayerSafeFood * EngineConfigFake.Value.BotCount, foodList.Count);
}
public void GivenTorpedo_WhenProcessTick_ThenTorpedoMoves()
{
SetupFakeWorld(true, false);
var bot = FakeGameObjectProvider.GetBotWithActions();
bot.CurrentHeading = 90;
bot.Speed = 20;
bot.IsMoving = true;
var torpedoPosition = VectorCalculatorService.GetPositionFrom(bot.Position, bot.Size + EngineConfigFake.Value.Torpedo.Size + 1, bot.CurrentAction.Heading);
var torpedoSalvo = new TorpedoGameObject()
{
Id = Guid.NewGuid(),
Position = torpedoPosition,
Size = EngineConfigFake.Value.Torpedo.Size,
Speed = EngineConfigFake.Value.Torpedo.Speed,
CurrentHeading = 45,
FiringPlayerId = bot.Id,
IsMoving = true
};
WorldStateService.AddGameObject(torpedoSalvo);
tickProcessingService = new TickProcessingService(
collisionHandlerResolver,
VectorCalculatorService,
WorldStateService,
collisionService);
Assert.DoesNotThrow(() => tickProcessingService.SimulateTick());
Assert.AreNotEqual(torpedoPosition, torpedoSalvo.Position);
}
public void GivenWorldState_WhenApplyAfterTickStateChanges_ReturnFirstWormholePairRemoved()
{
WorldStateService.GenerateStartingWorld();
var state = WorldStateService.GetState();
List <Tuple <GameObject, GameObject> > wormholes = state.WormholePairs;
var countBefore = state.WormholePairs.Count;
var distanceFromOrigin = 0;
foreach (Tuple <GameObject, GameObject> t in wormholes)
{
var item1Distance = VectorCalculatorService.GetDistanceBetween(new Position(0, 0), t.Item1.Position) + t.Item1.Size;
var item2Distance = VectorCalculatorService.GetDistanceBetween(new Position(0, 0), t.Item2.Position) + t.Item2.Size;
var longerDistance = item1Distance > item2Distance ? item1Distance : item2Distance;
distanceFromOrigin = distanceFromOrigin > longerDistance ? distanceFromOrigin : longerDistance;
}
var firstSize = wormholes[0].Item1.Size;
for (var i = 0; i < EngineConfigFake.Value.MapRadius - (distanceFromOrigin - firstSize); i++)
{
WorldStateService.ApplyAfterTickStateChanges();
}
Assert.Less(state.WormholePairs.Count, countBefore);
}
public void GivenBotAndWormhole_WhenResolveCollision_ReturnBotInNewPositionAndShrunkWormholes()
{
WorldStateService.GenerateStartingWorld();
var state = WorldStateService.GetState();
List <Tuple <GameObject, GameObject> > wormholes = state.WormholePairs;
var wormhole = wormholes[0].Item1;
var wormholeSize = wormhole.Size;
var bot = FakeGameObjectProvider.GetBotAt(
new Position(wormhole.Position.X + wormhole.Size + 5, wormhole.Position.Y + wormhole.Size + 5));
var handler = collisionHandlerResolver.ResolveHandler(wormhole, bot);
handler.ResolveCollision(wormhole, bot);
var expectedPosition = VectorCalculatorService.GetPositionFrom(
wormholes[0].Item2.Position,
wormholeSize + bot.Size,
bot.CurrentHeading);
Assert.AreEqual(expectedPosition.X, bot.Position.X);
Assert.AreEqual(expectedPosition.Y, bot.Position.Y);
Assert.AreEqual(EngineConfigFake.Value.ScoreRates[GameObjectType.Wormhole], bot.Score);
Assert.True(state.WormholePairs[0].Item1.Size < wormholeSize);
Assert.True(state.WormholePairs[0].Item2.Size < wormholeSize);
Assert.True(state.WormholePairs[0].Item2.Size == state.WormholePairs[0].Item1.Size);
}
public void GivenWorldState_WhenApplyAfterTickStateChanges_ReturnWormholesOutOfRadiusRemoved()
{
WorldStateService.GenerateStartingWorld();
var state = WorldStateService.GetState();
List <Tuple <GameObject, GameObject> > wormholes = state.WormholePairs;
var wormhole = wormholes[0].Item1;
var distanceFromOrigin = VectorCalculatorService.GetDistanceBetween(new Position(0, 0), wormhole.Position);
for (var i = 0; i < EngineConfigFake.Value.MapRadius - distanceFromOrigin; i++)
{
WorldStateService.ApplyAfterTickStateChanges();
}
Assert.Null(WorldStateService.GetWormholePair(wormhole.Id));
}
public void GivenListenGameObjects_WhenGenerateWormholes_ThenReturnListOfWormholePairs()
{
var gameObjects = new List <GameObject>();
var wormholeSeed = EngineConfigFake.Value.Wormholes.Seed ??
new Random().Next(EngineConfigFake.Value.Wormholes.MinSeed, EngineConfigFake.Value.Wormholes.MaxSeed);
List <Tuple <GameObject, GameObject> > wormholePairs = worldObjectGenerationService.GenerateWormholes(gameObjects, wormholeSeed);
Assert.AreEqual(EngineConfigFake.Value.Wormholes.Count / 2, wormholePairs.Count);
Assert.AreEqual(EngineConfigFake.Value.Wormholes.Count, gameObjects.Count);
foreach (Tuple <GameObject, GameObject> pair in wormholePairs)
{
Tuple <GameObject, GameObject> mainPair = pair;
foreach (Tuple <GameObject, GameObject> internalPair in wormholePairs)
{
if (mainPair.Equals(internalPair))
{
continue;
}
var distanceBetween1 = VectorCalculatorService.GetDistanceBetween(mainPair.Item1.Position, internalPair.Item1.Position);
var distanceBetween2 = VectorCalculatorService.GetDistanceBetween(mainPair.Item1.Position, internalPair.Item2.Position);
var distanceBetween3 = VectorCalculatorService.GetDistanceBetween(mainPair.Item2.Position, internalPair.Item1.Position);
var distanceBetween4 = VectorCalculatorService.GetDistanceBetween(mainPair.Item2.Position, internalPair.Item2.Position);
var distanceBetween5 = VectorCalculatorService.GetDistanceBetween(mainPair.Item1.Position, mainPair.Item2.Position);
var distanceBetween6 = VectorCalculatorService.GetDistanceBetween(
internalPair.Item1.Position,
internalPair.Item2.Position);
Assert.IsTrue(
distanceBetween1 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
Assert.IsTrue(
distanceBetween2 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
Assert.IsTrue(
distanceBetween3 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
Assert.IsTrue(
distanceBetween4 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
Assert.IsTrue(
distanceBetween5 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
Assert.IsTrue(
distanceBetween6 >= EngineConfigFake.Value.Wormholes.MinSeparation + EngineConfigFake.Value.Wormholes.MaxSize * 2);
}
}
}
public void GivenBot_WhenActionIsProcessed_ThenVectorIsStepwiseCalculated()
{
SetupFakeWorld(true, false);
var bot = FakeGameObjectProvider.GetBotWithActions();
bot.IsMoving = true;
vectorCalculatorServiceMock.Setup(x => x.GetPointFrom(It.IsAny <Position>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(VectorCalculatorService.GetPointFrom(bot.Position, 1, bot.CurrentHeading));
vectorCalculatorServiceMock.Setup(x => x.IsInWorldBounds(It.IsAny <Position>(), It.IsAny <int>())).Returns(true);
vectorCalculatorServiceMock
.Setup(vcs => vcs.CollectCollisionDetectionPointsAlongPath(It.IsAny <Position>(), It.IsAny <Position>(), It.IsAny <int>()))
.Returns(
new List <Position> {
new Position(0, 0),
new Position(1, 1),
new Position(2, 2)
});
Assert.DoesNotThrow(() => tickProcessingService.SimulateTick());
}
public void GivenPlayerSeedsAndStartingFood_WhenGenerateWorldFood_ThenReturnListOfWorldFood()
{
var playerSeeds = new List <int>
{
12354789,
58228,
656846,
7108040
};
List <GameObject> startingFoodList =
worldObjectGenerationService.GeneratePlayerStartingFood(playerSeeds, new List <GameObject>());
List <GameObject> placedFoodList =
worldObjectGenerationService.GenerateWorldFood(startingFoodList, playerSeeds, new List <GameObject>());
var foodPerOrigin =
(EngineConfigFake.Value.WorldFood.StartingFoodCount -
EngineConfigFake.Value.BotCount * EngineConfigFake.Value.WorldFood.PlayerSafeFood) /
(EngineConfigFake.Value.BotCount * EngineConfigFake.Value.WorldFood.PlayerSafeFood);
for (var j = 0; j <= playerSeeds.Count; j++)
{
for (var i = foodPerOrigin * j; i < foodPerOrigin * (j + 1) - 1; i++)
{
var distanceBetween = VectorCalculatorService.GetDistanceBetween(
placedFoodList[i].Position,
placedFoodList[i + 1].Position);
Assert.IsTrue(
EngineConfigFake.Value.WorldFood.FoodSize * 2 + EngineConfigFake.Value.WorldFood.MinSeparation <= distanceBetween);
Assert.IsTrue(distanceBetween <= EngineConfigFake.Value.WorldFood.MaxSeparation);
}
}
Assert.AreEqual(
EngineConfigFake.Value.WorldFood.StartingFoodCount -
EngineConfigFake.Value.BotCount * EngineConfigFake.Value.WorldFood.PlayerSafeFood,
placedFoodList.Count + 4);
List <GameObject> placedSuperfoodList = placedFoodList.FindAll(p => p.GameObjectType == GameObjectType.Superfood);
Assert.AreEqual(80, placedSuperfoodList.Count);
}
public void GivenWorldSetup_WhenPlaceWormholeWithOrigin_ThenReturnGameObject()
{
var gameObjects = new List <GameObject>();
var wormholeSeed = 4648964;
var worldCenter = new Position(0, 0);
var maxPlacementDistance = EngineConfigFake.Value.MapRadius;
for (var j = 0; j < EngineConfigFake.Value.Wormholes.Count / 2; j++)
{
var wormhole = worldObjectGenerationService.PlaceWormholeWithOrigin(
gameObjects,
ref wormholeSeed,
worldCenter,
maxPlacementDistance,
0,
true);
var distanceBetween = VectorCalculatorService.GetDistanceBetween(worldCenter, wormhole.Position);
Assert.True(distanceBetween <= maxPlacementDistance);
}
Assert.AreEqual(EngineConfigFake.Value.Wormholes.Count / 2, gameObjects.Count);
}
public void GivenWorldState_WhenApplyAfterTickStateChanges_ReturnFoodRemoved()
{
WorldStateService.GenerateStartingWorld();
var state = WorldStateService.GetState();
List <GameObject> objects = state.GameObjects;
var countBefore = objects.Count(a => a.GameObjectType == GameObjectType.Food);
var distanceFromOrigin = 0;
foreach (var food in objects.Where(a => a.GameObjectType == GameObjectType.Food))
{
var itemDistance = VectorCalculatorService.GetDistanceBetween(new Position(0, 0), food.Position);
distanceFromOrigin = distanceFromOrigin > itemDistance ? distanceFromOrigin : itemDistance;
}
for (var i = 0; i < EngineConfigFake.Value.MapRadius - (distanceFromOrigin - EngineConfigFake.Value.WorldFood.FoodSize); i++)
{
WorldStateService.ApplyAfterTickStateChanges();
}
Assert.AreEqual(countBefore - 1, objects.Count(a => a.GameObjectType == GameObjectType.Food));
}
public new void Setup()
{
base.Setup();
vectorCalculatorService = new VectorCalculatorService();
}
