public async Task ExecuteTest_MapWithWalls_ActorAvoidWallsAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
map.RemoveEdge(3, 3, 3, 4);
map.RemoveEdge(3, 3, 2, 3);
var expectedPath = CreateExpectedPath(map);
var startNode = expectedPath.First();
var finishNode = expectedPath.Last();
var actor = CreateActor(map, (HexNode)startNode);
var contextMock = new Mock <IActorTaskContext>();
var context = contextMock.Object;
var task = new MoveTask(actor, context, finishNode, map);
// ACT
for (var step = 1; step < expectedPath.Length; step++)
{
task.Execute();
// ASSERT
actor.Node.Should().Be(expectedPath[step]);
}
}
public async Task ExecuteTest_FindingPathAndMove_IsCompleteTrueAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var expectedPath = CreateExpectedPath(map);
var startNode = expectedPath.First();
var finishNode = expectedPath.Last();
var actor = CreateActor(map, (HexNode)startNode);
var contextMock = new Mock <IActorTaskContext>();
var context = contextMock.Object;
var task = new MoveTask(actor, context, finishNode, map);
// ACT
for (var step = 1; step < expectedPath.Length; step++)
{
task.Execute();
}
// ASSERT
task.IsComplete.Should().BeTrue();
}
public async System.Threading.Tasks.Task ExecuteTest_MapWithWalls_ActorAvoidWallsAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
map.RemoveEdge(3, 3, 3, 4);
map.RemoveEdge(3, 3, 2, 3);
var expectedPath = new IMapNode[] {
map.Nodes.Cast <HexNode>().SelectBy(4, 4),
map.Nodes.Cast <HexNode>().SelectBy(3, 4),
map.Nodes.Cast <HexNode>().SelectBy(2, 4),
map.Nodes.Cast <HexNode>().SelectBy(1, 5),
};
var startNode = expectedPath.First();
var finishNode = expectedPath.Last();
var actor = CreateActor(map, (HexNode)startNode);
var task = new MoveTask(actor, finishNode, map);
// ACT
for (var step = 1; step < expectedPath.Length; step++)
{
task.Execute();
// ASSERT
actor.Node.Should().Be(expectedPath[step]);
}
}
public async Task CreateSectorAsync(int mapSize)
{
var mapFactory = (FuncMapFactory)Container.GetInstance <IMapFactory>();
mapFactory.SetFunc(async() =>
{
var map = await SquareMapFactory.CreateAsync(mapSize);
return(map);
});
var sectorManager = Container.GetInstance <ISectorManager>();
var sectorGenerator = Container.GetInstance <ISectorGenerator>();
var humanPlayer = Container.GetInstance <HumanPlayer>();
var locationScheme = new TestLocationScheme
{
SectorLevels = new ISectorSubScheme[]
{
new TestSectorSubScheme
{
RegularMonsterSids = new[] { "rat" },
}
}
};
var globeNode = new GlobeRegionNode(0, 0, locationScheme);
humanPlayer.GlobeNode = globeNode;
await sectorManager.CreateSectorAsync();
}
public async System.Threading.Tasks.Task ExecuteTest_FindingPathAndMove_IsCompleteTrueAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var expectedPath = new IMapNode[] {
map.Nodes.Cast <HexNode>().SelectBy(4, 4),
map.Nodes.Cast <HexNode>().SelectBy(3, 4),
map.Nodes.Cast <HexNode>().SelectBy(2, 4),
map.Nodes.Cast <HexNode>().SelectBy(1, 5),
};
var startNode = expectedPath.First();
var finishNode = expectedPath.Last();
var actor = CreateActor(map, (HexNode)startNode);
var task = new MoveTask(actor, finishNode, map);
// ACT
for (var step = 1; step < expectedPath.Length; step++)
{
task.Execute();
}
// ASSERT
task.IsComplete.Should().BeTrue();
}
public async Task Execute_ValidLength_ActorOpenedContainerAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var actorNode = map.Nodes.Cast <HexNode>().SelectBy(0, 0);
var actorMock = new Mock <IActor>();
actorMock.SetupGet(x => x.Node).Returns(actorNode);
var actor = actorMock.Object;
var containerNode = map.Nodes.Cast <HexNode>().SelectBy(1, 0);
var container = CreateContainer(containerNode);
var method = CreateMethod();
var task = new OpenContainerTask(actor, container, method, map);
// ACT
task.Execute();
// ASSERT
actorMock.Verify(x => x.OpenContainer(It.IsAny <IPropContainer>(), It.IsAny <IOpenContainerMethod>()));
}
// Ограничение по времени добавлено на случай, если эта тут наступит бесконечное ожидание.
//[Timeout(1000)]
public async Task GetActorTaskAsync_GetActorTaskAfterIntention_ReturnsActorTask2()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var actorNode = map.Nodes.SelectByHexCoords(0, 0);
var actor = CreateActor(map, actorNode);
var taskMock = new Mock <IActorTask>();
var task = taskMock.Object;
var intentionMock = new Mock <IIntention>();
intentionMock.Setup(x => x.CreateActorTask(It.IsAny <IActor>())).Returns(task);
var intention = intentionMock.Object;
var taskSource = new HumanActorTaskSource(actor);
// ACT
taskSource.Intent(intention);
var getActorTaskTask = taskSource.GetActorTaskAsync(actor);
var factActorTask = await getActorTaskTask.ConfigureAwait(false);
// ASSERT
factActorTask.Should().Be(task);
}
public async Task Intent_TargetToStartPoint_GenerateMoveCommandAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var actor = CreateActor(map, startNode);
var taskSource = InitTaskSource(actor);
var moveIntention = new MoveIntention(startNode, map);
// ACT
var tasks = SetHumanIntention(actor, taskSource, moveIntention);
// ASSERT
tasks.Should().NotBeNullOrEmpty();
tasks[0].Should().BeOfType <MoveTask>();
}
public async Task Create_FixedMap_EdgesAreCorrectAsync()
{
// ARRANGE
// ACT
var map = await SquareMapFactory.CreateAsync(7);
// ASSERT
AssertEdge(map, 0, 0, 1, 0);
AssertEdge(map, 3, 1, 4, 2);
// полный набор соседей
AssertEdge(map, 1, 1, 0, 1);
AssertEdge(map, 1, 1, 1, 0);
AssertEdge(map, 1, 1, 2, 0);
AssertEdge(map, 1, 1, 2, 1);
AssertEdge(map, 1, 1, 2, 2);
AssertEdge(map, 1, 1, 1, 2);
// полный набор соседей для углового
AssertEdge(map, 6, 6, 5, 6);
AssertEdge(map, 6, 6, 5, 5);
AssertEdge(map, 6, 6, 6, 5);
}
public async Task DropIntention_WaitTask_InteruptsTaskWaiting()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var actorNode = map.Nodes.SelectByHexCoords(0, 0);
var actor = CreateActor(map, actorNode);
var context = Mock.Of <ISectorTaskSourceContext>();
using var taskSource = new HumanActorTaskSource <ISectorTaskSourceContext>();
// ACT
var getActorTaskTask = taskSource.GetActorTaskAsync(actor, context);
taskSource.DropIntentionWaiting();
Func <Task> act = async() =>
{
var _ = await getActorTaskTask.ConfigureAwait(false);
};
// ASSERT
await act.Should().ThrowAsync <TaskCanceledException>().ConfigureAwait(false);
}
public async Task IntentOpenContainer_SetContainerAndMethod_ReturnsTaskAsync()
{
//ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(0, 0);
var actor = CreateActor(map, startNode);
var taskSource = InitTaskSource(actor);
var containerMock = new Mock <IPropContainer>();
var container = containerMock.Object;
var methodMock = new Mock <IOpenContainerMethod>();
var method = methodMock.Object;
var intention = new Intention <OpenContainerTask>(a => new OpenContainerTask(a, container, method, map));
// ACT
var tasks = SetHumanIntention(actor, taskSource, intention);
// ASSERT
tasks.Should().NotBeNullOrEmpty();
tasks[0].Should().BeOfType <OpenContainerTask>();
}
public async Task IntentAttack_SetTarget_ReturnsAttackTaskAsync()
{
//ARRANGE
var usageService = _container.GetInstance <ITacticalActUsageService>();
var map = await SquareMapFactory.CreateAsync(10);
var attackerStartNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var targetStartNode = map.Nodes.Cast <HexNode>().SelectBy(2, 3);
var attackerActor = CreateActor(map, attackerStartNode);
var targetActor = CreateActor(map, targetStartNode);
var taskSource = InitTaskSource(attackerActor);
var attackIntention = new Intention <AttackTask>(a => new AttackTask(a, targetActor, usageService));
// ACT
var tasks = SetHumanIntention(attackerActor, taskSource, attackIntention);
// ASSERT
tasks.Should().NotBeNullOrEmpty();
tasks[0].Should().BeOfType <AttackTask>();
}
public async Task AttackTask_NoWall_NotThrowsInvalidOperationException()
{
// Подготовка. Два актёра через клетку. Радиус действия 1-2, достаёт.
_testMap = await SquareMapFactory.CreateAsync(3).ConfigureAwait(false);
var tacticalActMock = new Mock <ITacticalAct>();
tacticalActMock.SetupGet(x => x.Stats).Returns(new TestTacticalActStatsSubScheme
{
Range = new Range <int>(1, 2)
});
var tacticalAct = tacticalActMock.Object;
var combatActModuleMock = new Mock <ICombatActModule>();
combatActModuleMock.Setup(x => x.CalcCombatActs())
.Returns(new[] { tacticalAct });
var combatActModule = combatActModuleMock.Object;
var personMock = new Mock <IPerson>();
personMock.Setup(x => x.GetModule <ICombatActModule>(It.IsAny <string>())).Returns(combatActModule);
var person = personMock.Object;
var actorMock = new Mock <IActor>();
var actorNode = _testMap.Nodes.SelectByHexCoords(0, 0);
actorMock.SetupGet(x => x.Node).Returns(actorNode);
actorMock.SetupGet(x => x.Person).Returns(person);
actorMock.Setup(x => x.UseAct(It.IsAny <IGraphNode>(), It.IsAny <ITacticalAct>()))
.Raises <IGraphNode, ITacticalAct>(x => x.UsedAct += null,
(target1, act1) => new UsedActEventArgs(target1, act1));
_actor = actorMock.Object;
var targetMock = new Mock <IActor>();
var targetNode = _testMap.Nodes.SelectByHexCoords(2, 0);
targetMock.Setup(x => x.CanBeDamaged()).Returns(true);
targetMock.SetupGet(x => x.Node).Returns(targetNode);
var target = targetMock.Object;
var actServiceMock = new Mock <ITacticalActUsageService>();
var actService = actServiceMock.Object;
var taskContextMock = new Mock <IActorTaskContext>();
var taskContext = taskContextMock.Object;
// Создаём саму команду
_attackTask = new AttackTask(_actor, taskContext, target, tacticalAct, actService);
Action act = () =>
{
// ACT
_attackTask.Execute();
};
// ASSERT
act.Should().NotThrow <InvalidOperationException>();
}
public async Task SetUpAsync()
{
_map = await SquareMapFactory.CreateAsync(10);
var playerMock = new Mock <IPlayer>();
_player = playerMock.Object;
var actorMock = new Mock <IActor>();
actorMock.SetupGet(x => x.Node).Returns(() => _factActorNode);
actorMock.Setup(x => x.MoveToNode(It.IsAny <IMapNode>()))
.Callback <IMapNode>(node => _factActorNode = node);
actorMock.SetupGet(x => x.Owner).Returns(_player);
_actor = actorMock.Object;
// Маршрут из 3-х точек
var patrolRoute3PointsMock = new Mock <IPatrolRoute>();
var route3Points = new IMapNode[] {
_map.Nodes.OfType <HexNode>().SelectBy(1, 1),
_map.Nodes.OfType <HexNode>().SelectBy(5, 3),
_map.Nodes.OfType <HexNode>().SelectBy(3, 5)
};
patrolRoute3PointsMock
.SetupGet(x => x.Points)
.Returns(route3Points);
_patrolRoute3Points = patrolRoute3PointsMock.Object;
// Маршрут из 2-х точек по диагонали комнаты
var patrolRoute2DiagonalPointsMock = new Mock <IPatrolRoute>();
var route2DiagonalPoints = new IMapNode[] {
_map.Nodes.OfType <HexNode>().SelectBy(0, 0),
_map.Nodes.OfType <HexNode>().SelectBy(9, 9)
};
patrolRoute2DiagonalPointsMock
.SetupGet(x => x.Points)
.Returns(route2DiagonalPoints);
_patrolRoute2DiagonalPoints = patrolRoute2DiagonalPointsMock.Object;
var actors = new List <IActor> {
_actor
};
var actorListMock = new Mock <IActorManager>();
actorListMock.SetupGet(x => x.Items).Returns(actors);
_actorList = actorListMock.Object;
var decisionSourceMock = new Mock <IDecisionSource>();
decisionSourceMock.Setup(x => x.SelectIdleDuration(It.IsAny <int>(), It.IsAny <int>()))
.Returns(ExpectedIdleDuration);
_decisionSource = decisionSourceMock.Object;
}
/// <summary>
/// Создаёт сектор фрагмента дикого окружения.
/// </summary>
/// <param name="globe">Объект мира.</param>
/// <param name="globeNode">Узел провинции, на основе которого генерируется сектор.</param>
/// <returns>
/// Возвращает созданный сектор.
/// </returns>
/// <remarks>
/// Нужно будет передавать параметры окружения и количество
/// и характеристики монстров.
/// </remarks>
public async Task <ISector> GenerateWildAsync(Globe globe, GlobeRegionNode globeNode)
{
var map = await SquareMapFactory.CreateAsync(10);
var sector = _sectorFactory.Create(map);
return(sector);
}
public async System.Threading.Tasks.Task SetUpAsync()
{
_container = new ServiceContainer();
_map = await SquareMapFactory.CreateAsync(10);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(_map);
var sector = sectorMock.Object;
var sectorManagerMock = new Mock <ISectorManager>();
sectorManagerMock.SetupGet(x => x.CurrentSector).Returns(sector);
var sectorManager = sectorManagerMock.Object;
_actorListInner = new List <IActor>();
_testedActor = CreateBotActor(1, 1);
var actorManagerMock = new Mock <IActorManager>();
actorManagerMock.SetupGet(x => x.Items).Returns(_actorListInner);
var actorManager = actorManagerMock.Object;
var routePoints = new IMapNode[] {
_map.Nodes.Cast <HexNode>().SelectBy(1, 1),
_map.Nodes.Cast <HexNode>().SelectBy(9, 9)
};
var routeMock = new Mock <IPatrolRoute>();
routeMock.SetupGet(x => x.Points).Returns(routePoints);
var route = routeMock.Object;
var patrolRoutes = new Dictionary <IActor, IPatrolRoute>
{
{ _testedActor, route }
};
sectorMock.SetupGet(x => x.PatrolRoutes).Returns(patrolRoutes);
var decisionSourceMock = new Mock <IDecisionSource>();
var decisionSource = decisionSourceMock.Object;
var tacticalActUsageServiceMock = new Mock <ITacticalActUsageService>();
var tacticalActUsageService = tacticalActUsageServiceMock.Object;
_container.Register(factory => sectorManager, new PerContainerLifetime());
_container.Register(factory => (IBotPlayer)_testedActor.Owner, new PerContainerLifetime());
_container.Register(factory => actorManager, new PerContainerLifetime());
_container.Register(factory => tacticalActUsageService, new PerContainerLifetime());
_container.Register(factory => decisionSource, new PerContainerLifetime());
_container.Register <MonsterActorTaskSource>(new PerContainerLifetime());
}
public void Create_HexMapType_NoExceptions()
{
// ARRANGE
// ACT
Action act = () =>
{
var map = SquareMapFactory.CreateAsync(7);
};
// ASSERT
act.Should().NotThrow();
}
public async Task <ISector> GenerateAsync(ISectorNode sectorNode)
{
var transitions = MapFactoryHelper.CreateTransitions(sectorNode).ToArray();
var map = await SquareMapFactory.CreateAsync(transitions.Count() + 1);
CreateTransitions(transitions, map);
var locationScheme = sectorNode.Biome.LocationScheme;
var sector = _sectorFactory.Create(map, locationScheme);
return(sector);
}
public async Task SetUpAsync()
{
var actUsageRandomSourceMock = new Mock <ITacticalActUsageRandomSource>();
actUsageRandomSourceMock.Setup(x => x.RollToHit(It.IsAny <Roll>())).Returns(6);
actUsageRandomSourceMock.Setup(x => x.RollEfficient(It.IsAny <Roll>())).Returns(1);
_actUsageRandomSource = actUsageRandomSourceMock.Object;
_perkResolverMock = new Mock <IPerkResolver>();
_perkResolver = _perkResolverMock.Object;
var personMock = new Mock <IPerson>();
_person = personMock.Object;
var evolutionDataMock = new Mock <IEvolutionData>();
var evolutionData = evolutionDataMock.Object;
personMock.SetupGet(x => x.EvolutionData).Returns(evolutionData);
var actScheme = new TestTacticalActStatsSubScheme
{
Offence = new TestTacticalActOffenceSubScheme
{
Type = OffenseType.Tactical,
Impact = ImpactType.Kinetic,
ApRank = 10
}
};
var actMock = new Mock <ITacticalAct>();
actMock.SetupGet(x => x.Stats).Returns(actScheme);
_act = actMock.Object;
var sectorManagerMock = new Mock <ISectorManager>();
var sectorManager = sectorManagerMock.Object;
var map = await SquareMapFactory.CreateAsync(3);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(map);
var sector = sectorMock.Object;
sectorManagerMock.SetupGet(x => x.CurrentSector).Returns(sector);
_sectorManager = sectorManager;
}
public async Task Intent_AssignAfterTaskComplete_NoNullCommandAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var finishNode = map.Nodes.Cast <HexNode>().SelectBy(1, 5);
var finishNode2 = map.Nodes.Cast <HexNode>().SelectBy(3, 2);
var actor = CreateActor(map, startNode);
var taskSource = InitTaskSource(actor);
var moveIntention = new MoveIntention(finishNode, map);
var moveIntention2 = new MoveIntention(finishNode2, map);
// ACT
// 1. Ждём, пока задача на перемещение не отработает.
// В конце текущая задача актёра будет IsComplete.
var tasks = SetHumanIntention(actor, taskSource, moveIntention);
for (var i = 0; i < 3; i++)
{
foreach (var task in tasks)
{
task.Execute();
}
}
foreach (var task in tasks)
{
task.IsComplete.Should().Be(true);
}
// 2. Указываем намерение на ещё одну задачу.
var factTasks = SetHumanIntention(actor, taskSource, moveIntention2);
// ASSERT
factTasks.Should().NotBeNullOrEmpty();
}
/// <summary>
/// Создаёт сектор квартала города.
/// </summary>
/// <param name="globe">Объект мира.</param>
/// <param name="globeNode">Узел провинции, на основе которого генерируется сектор.</param>
/// <returns>
/// Возвращает созданный сектор.
/// </returns>
/// <remarks>
/// Нужно будет передавать параметры зданий, наличие персонажей и станков для крафта.
/// Вместо общей информации об узле.
/// </remarks>
public async Task <ISector> GenerateTownQuarterAsync(Globe globe, GlobeRegionNode globeNode)
{
var map = await SquareMapFactory.CreateAsync(10);
var sector = _sectorFactory.Create(map);
var traderDropTable = _schemeService.GetScheme <IDropTableScheme>("trader");
var trader = new Trader(traderDropTable, map.Nodes.ElementAt(10), _dropResolver);
_traderManager.Add(trader);
map.HoldNode(trader.Node, trader);
map.Transitions.Add(map.Nodes.Last(), RoomTransition.CreateGlobalExit());
return(sector);
}
public async Task Intent_AssignTaskBeforeCurrentTaskComplete_NoNullCommandAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var finishNode = map.Nodes.Cast <HexNode>().SelectBy(1, 5);
var finishNode2 = map.Nodes.Cast <HexNode>().SelectBy(3, 2);
var actor = CreateActor(map, startNode);
var taskSource = InitTaskSource(actor);
var moveIntention = new MoveIntention(finishNode, map);
var moveIntention2 = new MoveIntention(finishNode2, map);
// ACT
// 1. Продвигаем выполнение текущего намерения. НО НЕ ДО ОКОНЧАНИЯ.
var tasks = SetHumanIntention(actor, taskSource, moveIntention);
for (var i = 0; i < 1; i++)
{
foreach (var task in tasks)
{
task.Execute();
}
}
foreach (var task in tasks)
{
task.IsComplete.Should().Be(false);
}
// 2. Указываем другое намерение до того, как текущая задача на перемещение выполнена до конца.
var factTasks = SetHumanIntention(actor, taskSource, moveIntention2);
// ASSERT
factTasks.Should().NotBeNullOrEmpty();
}
public async System.Threading.Tasks.Task ExecuteTest_OpenGridMap_ActorReachPointAndTaskCompleteAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var finishNode = map.Nodes.Cast <HexNode>().SelectBy(1, 5);
var expectedPath = new[] {
map.Nodes.Cast <HexNode>().SelectBy(2, 3),
map.Nodes.Cast <HexNode>().SelectBy(2, 4),
finishNode
};
var actor = CreateActor(map, startNode);
var task = new MoveTask(actor, finishNode, map);
// ACT
for (var step = 1; step <= expectedPath.Length; step++)
{
task.Execute();
// ASSERT
var expectedIsComplete = step >= 3;
task.IsComplete.Should().Be(expectedIsComplete);
actor.Node.Should().Be(expectedPath[step - 1]);
}
// ASSERT
task.IsComplete.Should().Be(true);
actor.Node.Should().Be(finishNode);
}
public async Task SetUpAsync()
{
var actUsageRandomSourceMock = new Mock <ITacticalActUsageRandomSource>();
actUsageRandomSourceMock.Setup(x => x.RollToHit(It.IsAny <Roll>())).Returns(6);
actUsageRandomSourceMock.Setup(x => x.RollEfficient(It.IsAny <Roll>())).Returns(1);
_actUsageRandomSource = actUsageRandomSourceMock.Object;
var personMock = new Mock <IPerson>();
_person = personMock.Object;
var evolutionModuleMock = new Mock <IEvolutionModule>();
var evolutionModule = evolutionModuleMock.Object;
personMock.Setup(x => x.GetModule <IEvolutionModule>(It.IsAny <string>())).Returns(evolutionModule);
var actScheme = new TestTacticalActStatsSubScheme
{
Offence = new TestTacticalActOffenceSubScheme
{
Type = OffenseType.Tactical,
Impact = ImpactType.Kinetic,
ApRank = 10
}
};
var actMock = new Mock <ITacticalAct>();
actMock.SetupGet(x => x.Stats).Returns(actScheme);
_act = actMock.Object;
var map = await SquareMapFactory.CreateAsync(3).ConfigureAwait(false);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(map);
_sector = sectorMock.Object;
}
public async Task Intent_SetNullTarget_ThrownExceptionAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10);
var startNode = map.Nodes.Cast <HexNode>().SelectBy(3, 3);
var actor = CreateActor(map, startNode);
var taskSource = InitTaskSource(actor);
// ACT
Action act = () => { taskSource.Intent(null); };
// ASSERT
act.Should().Throw <ArgumentException>();
}
public async Task ExecuteTest_OpenGridMap_ActorReachPointAndTaskCompleteAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var startNode = map.Nodes.SelectByHexCoords(3, 3);
var finishNode = map.Nodes.SelectByHexCoords(1, 5);
var expectedPath = new[]
{
map.Nodes.SelectByHexCoords(2, 3),
map.Nodes.SelectByHexCoords(2, 4),
finishNode
};
var actor = CreateActor(map, startNode);
var contextMock = new Mock <IActorTaskContext>();
var context = contextMock.Object;
var task = new MoveTask(actor, context, finishNode, map);
// ACT
for (var step = 1; step <= expectedPath.Length; step++)
{
task.Execute();
// ASSERT
var expectedIsComplete = step >= 3;
task.IsComplete.Should().Be(expectedIsComplete);
actor.Node.Should().Be(expectedPath[step - 1]);
}
// ASSERT
task.IsComplete.Should().Be(true);
actor.Node.Should().Be(finishNode);
}
public async Task Execute_ValidLength_ActorOpenedContainerAsync()
{
// ARRANGE
var map = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var actorNode = map.Nodes.SelectByHexCoords(0, 0);
var actorMock = new Mock <IActor>();
actorMock.SetupGet(x => x.Node).Returns(actorNode);
var actor = actorMock.Object;
var containerNode = map.Nodes.SelectByHexCoords(1, 0);
var container = CreateContainer(containerNode);
var method = CreateMethod();
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(map);
var sector = sectorMock.Object;
var contextMock = new Mock <IActorTaskContext>();
contextMock.SetupGet(x => x.Sector).Returns(sector);
var context = contextMock.Object;
var task = new OpenContainerTask(actor, context, container, method);
// ACT
task.Execute();
// ASSERT
actorMock.Verify(x => x.OpenContainer(It.IsAny <IStaticObject>(), It.IsAny <IOpenContainerMethod>()));
}
public async System.Threading.Tasks.Task SetUpAsync()
{
_map = await SquareMapFactory.CreateAsync(10);
var playerMock = new Mock <IPlayer>();
_player = playerMock.Object;
var enemyPlayerMock = new Mock <IPlayer>();
var enemyPlayer = enemyPlayerMock.Object;
var actorMock = new Mock <IActor>();
actorMock.SetupGet(x => x.Node).Returns(() => _factActorNode);
actorMock.Setup(x => x.MoveToNode(It.IsAny <IMapNode>()))
.Callback <IMapNode>(node => _factActorNode = node);
actorMock.SetupGet(x => x.Owner).Returns(_player);
_actor = actorMock.Object;
var personMock = new Mock <IPerson>();
var person = personMock.Object;
actorMock.SetupGet(x => x.Person).Returns(person);
var tacticalActCarrierMock = new Mock <ITacticalActCarrier>();
var tacticalActCarrier = tacticalActCarrierMock.Object;
personMock.SetupGet(x => x.TacticalActCarrier).Returns(tacticalActCarrier);
var actMock = new Mock <ITacticalAct>();
actMock.SetupGet(x => x.Stats).Returns(new TestTacticalActStatsSubScheme());
var act = actMock.Object;
tacticalActCarrierMock.SetupGet(x => x.Acts).Returns(new[] { act });
var intruderPersonMock = new Mock <IPerson>();
var intruderPerson = intruderPersonMock.Object;
var intruderSurvivalMock = new Mock <ISurvivalData>();
intruderSurvivalMock.SetupGet(x => x.IsDead).Returns(false);
var intruderSurvival = intruderSurvivalMock.Object;
intruderPersonMock.SetupGet(x => x.Survival).Returns(intruderSurvival);
var intruderMock = new Mock <IActor>();
intruderMock.SetupGet(x => x.Owner).Returns(enemyPlayer);
intruderMock.SetupGet(x => x.Node).Returns(() => _factIntruderNode);
intruderMock.Setup(x => x.MoveToNode(It.IsAny <IMapNode>()))
.Callback <IMapNode>(node => _factIntruderNode = node);
intruderMock.SetupGet(x => x.Person).Returns(intruderPerson);
_intruder = intruderMock.Object;
var actors = new List <IActor> {
_actor, _intruder
};
var actorListMock = new Mock <IActorManager>();
actorListMock.SetupGet(x => x.Items).Returns(actors);
_actorList = actorListMock.Object;
var decisionSourceMock = new Mock <IDecisionSource>();
decisionSourceMock.Setup(x => x.SelectIdleDuration(It.IsAny <int>(), It.IsAny <int>()))
.Returns(ExpectedIdleDuration);
_decisionSource = decisionSourceMock.Object;
}
public async System.Threading.Tasks.Task SetUpAsync()
{
Container = new ServiceContainer();
var testMap = await SquareMapFactory.CreateAsync(10);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(testMap);
var sector = sectorMock.Object;
var sectorManagerMock = new Mock <ISectorManager>();
sectorManagerMock.SetupGet(x => x.CurrentSector).Returns(sector);
var sectorManager = sectorManagerMock.Object;
var actMock = new Mock <ITacticalAct>();
var actStatScheme = new TestTacticalActStatsSubScheme
{
Range = new Range <int>(1, 2)
};
actMock.SetupGet(x => x.Stats).Returns(actStatScheme);
var act = actMock.Object;
var actCarrierMock = new Mock <ITacticalActCarrier>();
actCarrierMock.SetupGet(x => x.Acts)
.Returns(new[] { act });
var actCarrier = actCarrierMock.Object;
var equipmentCarrierMock = new Mock <IEquipmentCarrier>();
equipmentCarrierMock.SetupGet(x => x.Slots).Returns(new[] { new PersonSlotSubScheme {
Types = EquipmentSlotTypes.Hand
} });
var equipmentCarrier = equipmentCarrierMock.Object;
var personMock = new Mock <IPerson>();
personMock.SetupGet(x => x.TacticalActCarrier).Returns(actCarrier);
personMock.SetupGet(x => x.EquipmentCarrier).Returns(equipmentCarrier);
var person = personMock.Object;
var actorMock = new Mock <IActor>();
var actorNode = testMap.Nodes.OfType <HexNode>().SelectBy(0, 0);
actorMock.SetupGet(x => x.Node).Returns(actorNode);
actorMock.SetupGet(x => x.Person).Returns(person);
var actor = actorMock.Object;
var actorVmMock = new Mock <IActorViewModel>();
actorVmMock.SetupProperty(x => x.Actor, actor);
var actorVm = actorVmMock.Object;
var humanTaskSourceMock = new Mock <IHumanActorTaskSource>();
var humanTaskSource = humanTaskSourceMock.Object;
var playerStateMock = new Mock <ISectorUiState>();
playerStateMock.SetupProperty(x => x.ActiveActor, actorVm);
playerStateMock.SetupProperty(x => x.TaskSource, humanTaskSource);
var playerState = playerStateMock.Object;
var gameLoopMock = new Mock <IGameLoop>();
var gameLoop = gameLoopMock.Object;
var usageServiceMock = new Mock <ITacticalActUsageService>();
var usageService = usageServiceMock.Object;
Container.Register(factory => sectorManager, new PerContainerLifetime());
Container.Register(factory => humanTaskSourceMock, new PerContainerLifetime());
Container.Register(factory => playerState, new PerContainerLifetime());
Container.Register(factory => gameLoop, new PerContainerLifetime());
Container.Register(factory => usageService, new PerContainerLifetime());
RegisterSpecificServices(testMap, playerStateMock);
}
public async Task SetUpAsync()
{
Container = new ServiceCollection();
var testMap = await SquareMapFactory.CreateAsync(10).ConfigureAwait(false);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.Map).Returns(testMap);
var sector = sectorMock.Object;
var sectorNodeMock = new Mock <ISectorNode>();
sectorNodeMock.SetupGet(x => x.Sector).Returns(sector);
var sectorNode = sectorNodeMock.Object;
var playerMock = new Mock <IPlayer>();
playerMock.SetupGet(x => x.SectorNode).Returns(sectorNode);
var player = playerMock.Object;
Container.AddSingleton(player);
var simpleAct = CreateSimpleAct();
var cooldownAct = CreateActWithCooldown();
var cooldownResolvedAct = CreateActWithResolvedCooldown();
var combatActModuleMock = new Mock <ICombatActModule>();
combatActModuleMock.Setup(x => x.CalcCombatActs())
.Returns(new[] { simpleAct, cooldownAct, cooldownResolvedAct });
var combatActModule = combatActModuleMock.Object;
var equipmentCarrierMock = new Mock <IEquipmentModule>();
equipmentCarrierMock.SetupGet(x => x.Slots).Returns(new[]
{
new PersonSlotSubScheme
{
Types = EquipmentSlotTypes.Hand
}
});
var equipmentCarrier = equipmentCarrierMock.Object;
var personMock = new Mock <IPerson>();
personMock.Setup(x => x.GetModule <ICombatActModule>(It.IsAny <string>())).Returns(combatActModule);
personMock.Setup(x => x.GetModule <IEquipmentModule>(It.IsAny <string>())).Returns(equipmentCarrier);
personMock.SetupGet(x => x.PhysicalSize).Returns(PhysicalSizePattern.Size1);
var person = personMock.Object;
var actorMock = new Mock <IActor>();
var actorNode = testMap.Nodes.SelectByHexCoords(0, 0);
actorMock.SetupGet(x => x.Node).Returns(actorNode);
actorMock.SetupGet(x => x.Person).Returns(person);
var actor = actorMock.Object;
var actorVmMock = new Mock <IActorViewModel>();
actorVmMock.SetupProperty(x => x.Actor, actor);
var actorVm = actorVmMock.Object;
var humanTaskSourceMock = new Mock <IHumanActorTaskSource <ISectorTaskSourceContext> >();
var humanTaskSource = humanTaskSourceMock.Object;
var playerStateMock = new Mock <ISectorUiState>();
playerStateMock.SetupProperty(x => x.ActiveActor, actorVm);
playerStateMock.SetupGet(x => x.TaskSource).Returns(humanTaskSource);
playerStateMock.SetupProperty(x => x.TacticalAct, simpleAct);
var playerState = playerStateMock.Object;
sectorMock.SetupGet(x => x.ActorManager)
.Returns(() => ServiceProvider.GetRequiredService <IActorManager>());
var usageServiceMock = new Mock <ITacticalActUsageService>();
var usageService = usageServiceMock.Object;
Container.AddSingleton(factory => humanTaskSourceMock);
Container.AddSingleton(factory => playerState);
Container.AddSingleton(factory => usageService);
RegisterSpecificServices(testMap, playerStateMock);
ServiceProvider = Container.BuildServiceProvider();
}
