private static void HandleMoveCommand(IServiceScope serviceScope, ISectorUiState uiState,
ISectorNode playerActorSectorNode, string inputText)
{
var components = inputText.Split(' ');
var x = int.Parse(components[1], CultureInfo.InvariantCulture);
var y = int.Parse(components[2], CultureInfo.InvariantCulture);
var offsetCoords = new OffsetCoords(x, y);
ISectorMap map = playerActorSectorNode.Sector.Map;
var targetNode = map.Nodes.OfType <HexNode>()
.SingleOrDefault(node => node.OffsetCoords == offsetCoords);
var command = serviceScope.ServiceProvider.GetRequiredService <MoveCommand>();
uiState.SelectedViewModel = new NodeViewModel {
Node = targetNode
};
if (command.CanExecute())
{
command.Execute();
}
else
{
Console.WriteLine(UiResource.CommandCantExecuteMessage);
}
}
private static void HandleMoveCommand(
IServiceScope serviceScope,
ISectorUiState uiState,
ICommandPool commandManager,
ISectorNode playerActorSectorNode,
string inputText)
{
var components = inputText.Split(' ');
var x = int.Parse(components[1], CultureInfo.InvariantCulture);
var y = int.Parse(components[2], CultureInfo.InvariantCulture);
var offsetCoords = new OffsetCoords(x, y);
ISectorMap map = playerActorSectorNode.Sector.Map;
var targetNode = map.Nodes.OfType <HexNode>()
.SingleOrDefault(node => node.OffsetCoords == offsetCoords);
var command = serviceScope.ServiceProvider.GetRequiredService <MoveCommand>();
uiState.SelectedViewModel = new NodeViewModel {
Node = targetNode
};
PushCommandToExecution(commandManager, command);
}
private List <MapNodeVM> InitNodeViewModels(ISectorMap map)
{
var nodeViewModels = new List <MapNodeVM>();
foreach (var node in map.Nodes)
{
var mapNodeObj = _diContainer.InstantiatePrefab(MapNodePrefab, transform);
var mapNodeVm = mapNodeObj.GetComponent <MapNodeVM>();
var hexNode = (HexNode)node;
var nodeWorldPositionParts = HexHelper.ConvertToWorld(hexNode.OffsetCoords);
var worldPosition = new Vector3(nodeWorldPositionParts[0], nodeWorldPositionParts[1] / 2);
mapNodeVm.transform.position = worldPosition;
mapNodeVm.Node = hexNode;
mapNodeVm.Neighbors = map.GetNext(node).Cast <HexNode>().ToArray();
if (map.Transitions.ContainsKey(node))
{
mapNodeVm.IsExit = true;
}
nodeViewModels.Add(mapNodeVm);
mapNodeVm.OnSelect += MapNodeVm_Select;
mapNodeVm.MouseEnter += MapNodeVm_MouseEnter;
}
return(nodeViewModels);
}
public Sector(ISectorMap map,
IActorManager actorManager,
IStaticObjectManager staticObjectManager,
IDropResolver dropResolver,
ISchemeService schemeService,
IEquipmentDurableService equipmentDurableService)
{
ActorManager = actorManager ?? throw new ArgumentNullException(nameof(actorManager));
StaticObjectManager = staticObjectManager ?? throw new ArgumentNullException(nameof(staticObjectManager));
_dropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
_schemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
_equipmentDurableService = equipmentDurableService ??
throw new ArgumentNullException(nameof(equipmentDurableService));
_diseases = new List <IDisease>();
ActorManager.Added += ActorManager_Added;
ActorManager.Removed += ActorManager_Remove;
StaticObjectManager.Added += StaticObjectManager_Added;
StaticObjectManager.Removed += StaticObjectManager_Remove;
Map = map ?? throw new ArgumentException("Не передана карта сектора.", nameof(map));
PatrolRoutes = new Dictionary <IActor, IPatrolRoute>();
}
public RoamingLogic(IActor actor,
ISectorMap map,
IActorManager actors,
IDecisionSource decisionSource,
ITacticalActUsageService actService) : base(actor, map, actors, decisionSource, actService)
{
}
public MoveTask(IActor actor, IActorTaskContext context, IGraphNode targetNode, ISectorMap map, int cost) :
base(actor, context)
{
TargetNode = targetNode ?? throw new ArgumentNullException(nameof(targetNode));
_map = map ?? throw new ArgumentNullException(nameof(map));
Cost = cost;
if (actor.Node == targetNode)
{
// Это может произойти, если источник команд выбрал целевую точку ту же, что и сам актёр
// в результате рандома.
IsComplete = true;
_path = new List <IGraphNode>(0);
}
else
{
_path = new List <IGraphNode>();
CreatePath();
if (!_path.Any())
{
IsComplete = true;
}
}
}
private static void SaveMapAsImage(ISectorMap map, string outputPath)
{
using (var bmp = MapDrawer.DrawMap(map))
{
bmp.Save(outputPath);
}
}
private static IEnumerable <IActor> CheckForIntruders(IActor actor, ISectorMap map, IActorManager actorManager)
{
foreach (var target in actorManager.Items)
{
if (target.Person.Fraction == actor.Person.Fraction ||
(target.Person.Fraction == Fractions.MilitiaFraction &&
actor.Person.Fraction == Fractions.MainPersonFraction) ||
(target.Person.Fraction == Fractions.MainPersonFraction &&
actor.Person.Fraction == Fractions.MilitiaFraction) ||
(target.Person.Fraction == Fractions.InterventionistFraction &&
actor.Person.Fraction == Fractions.TroublemakerFraction) ||
(target.Person.Fraction == Fractions.TroublemakerFraction &&
actor.Person.Fraction == Fractions.InterventionistFraction))
{
continue;
}
if (target.Person.CheckIsDead())
{
continue;
}
var isVisible = LogicHelper.CheckTargetVisible(map, actor.Node, target.Node);
if (!isVisible)
{
continue;
}
yield return(target);
}
}
private void CreateOneRoomNodes(ISectorMap map, HashSet <string> edgeHash, Room room, Size cellSize)
{
var interiorObjects = _randomSource.RollInteriorObjects(room.Width, room.Height);
for (var x = 0; x < room.Width; x++)
{
for (var y = 0; y < room.Height; y++)
{
var nodeX = x + room.PositionX * cellSize.Width;
var nodeY = y + room.PositionY * cellSize.Height;
var isObstacle = false;
var interiorObjectMetas = interiorObjects
.SingleOrDefault(o => o.Coords.CompsEqual(x, y));
if (interiorObjectMetas != null)
{
//TODO Сделать так, чтобы укрытия не генерировались на узлах с выходами
// Как вариант - если выбираем узел, как выход, то снимаем флаг укрытия.
// Вообще, нужно поискать алгоритмы, которые бы расставляли укрытия и выходы, оставляя комнату проходимой.
isObstacle = true;
}
var node = new HexNode(nodeX, nodeY, isObstacle);
room.Nodes.Add(node);
map.AddNode(node);
RoomHelper.AddAllNeighborToMap(map, edgeHash, room, node);
}
}
CreateTransitions(map, room);
}
/// <summary>
/// Проверяем, что к сундуку есть подход.
/// </summary>
private static void ValidatePassability(
HexNode currentContainerHex,
ISectorMap sectorMap,
IGraphNode[] allContainerNodes)
{
var neighborNodes = sectorMap.GetNext(currentContainerHex);
var hasFreeNeighbor = false;
foreach (var neighborNode in neighborNodes)
{
var neighborHex = (HexNode)neighborNode;
var isContainer = allContainerNodes.Contains(neighborHex);
if (!isContainer)
{
hasFreeNeighbor = true;
break;
}
}
if (!hasFreeNeighbor)
{
throw new SectorValidationException($"Контейнер {currentContainerHex} не имеет подступов.");
}
}
/// <summary>
/// Проверяет, допустимая ли дистанция для совершения действия.
/// </summary>
/// <param name="act"> Проверяемое действие. </param>
/// <param name="currentNode"> Узел, из которого совершается действие. </param>
/// <param name="targetNode"> Целевой узел. </param>
/// <returns>Возвращает true, если дистанция допустима.</returns>
public static bool CheckDistance(this ITacticalAct act,
IGraphNode currentNode,
IGraphNode targetNode,
ISectorMap map)
{
if (act is null)
{
throw new System.ArgumentNullException(nameof(act));
}
if (currentNode is null)
{
throw new System.ArgumentNullException(nameof(currentNode));
}
if (targetNode is null)
{
throw new System.ArgumentNullException(nameof(targetNode));
}
if (map is null)
{
throw new System.ArgumentNullException(nameof(map));
}
var range = act.Stats.Range;
var distance = map.DistanceBetween(currentNode, targetNode);
var isInDistance = range.Contains(distance);
return(isInDistance);
}
public static IStaticObject FindContainer(IActor actor, IStaticObjectManager staticObjectManager,
ISectorMap map)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (staticObjectManager is null)
{
throw new ArgumentNullException(nameof(staticObjectManager));
}
if (map is null)
{
throw new ArgumentNullException(nameof(map));
}
var containerStaticObjects = staticObjectManager.Items
.Where(x => x.HasModule <IPropContainer>());
var foundContainers = LootHelper.FindAvailableContainers(containerStaticObjects,
actor.Node,
map);
var orderedContainers = foundContainers.OrderBy(x => map.DistanceBetween(actor.Node, x.Node));
var nearbyContainer = orderedContainers.FirstOrDefault();
return(nearbyContainer);
}
public override void CreateRoomNodes(ISectorMap map, IEnumerable <Room> rooms, HashSet <string> edgeHash)
{
foreach (var room in rooms)
{
CreateOneRoomNodes(map, edgeHash, room);
}
}
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;
}
public DefeatTargetLogicState(ISectorManager sectorManager,
ITacticalActUsageService actService,
IActorManager actorManager)
{
_map = sectorManager.CurrentSector.Map;
_actService = actService ?? throw new ArgumentNullException(nameof(actService));
_actorManager = actorManager ?? throw new ArgumentNullException(nameof(actorManager));
}
/// <summary>
/// Создаёт узлы комнат на карте.
/// </summary>
/// <param name="map">Карта, в рамках которой происходит генерация.</param>
/// <param name="rooms">Комнаты, для которых создаются узлы графа карты.</param>
/// <param name="edgeHash">Хэш рёбер. Нужен для оптимизации при создании узлов графа карты.</param>
public void CreateRoomNodes(ISectorMap map, IEnumerable <Room> rooms, HashSet <string> edgeHash)
{
var cellSize = CalcCellSize(rooms);
foreach (var room in rooms)
{
CreateOneRoomNodes(map, edgeHash, room, cellSize);
}
}
public PatrolLogic(IActor actor,
IPatrolRoute patrolRoute,
ISectorMap map,
IActorManager actors,
IDecisionSource decisionSource,
ITacticalActUsageService actService) : base(actor, map, actors, decisionSource, actService)
{
_patrolRoute = patrolRoute;
}
private static IGraphNode[] CreateExpectedPath(ISectorMap map)
{
return(new IGraphNode[] {
map.Nodes.SelectByHexCoords(4, 4),
map.Nodes.SelectByHexCoords(3, 4),
map.Nodes.SelectByHexCoords(2, 4),
map.Nodes.SelectByHexCoords(1, 5),
});
}
public OpenContainerTask([NotNull] IActor actor,
[NotNull] IStaticObject staticObject,
[NotNull] IOpenContainerMethod method,
[NotNull] ISectorMap map) : base(actor)
{
_staticObject = staticObject ?? throw new ArgumentNullException(nameof(staticObject));
_method = method ?? throw new ArgumentNullException(nameof(method));
_map = map ?? throw new ArgumentNullException(nameof(map));
}
private void CreateOneRoomNodes(ISectorMap map, HashSet <string> edgeHash, Room room, Size cellSize)
{
var interiorObjects = _randomSource.RollInteriorObjects(room.Width, room.Height);
for (var x = 0; x < room.Width; x++)
{
for (var y = 0; y < room.Height; y++)
{
var nodeX = x + room.PositionX * cellSize.Width;
var nodeY = y + room.PositionY * cellSize.Height;
var isObstacle = false;
var interiorObjectForCoords = interiorObjects
.SingleOrDefault(o => o.Coords.CompsEqual(x, y));
if (interiorObjectForCoords != null)
{
//TODO Сделать так, чтобы укрытия не генерировались на узлах с выходами
// Как вариант - если выбираем узел, как выход, то снимаем флаг укрытия.
// Вообще, нужно поискать алгоритмы, которые бы расставляли укрытия и выходы, оставляя комнату проходимой.
isObstacle = true;
}
var node = new HexNode(nodeX, nodeY, isObstacle);
room.Nodes.Add(node);
map.AddNode(node);
var neighbors = HexNodeHelper.GetSpatialNeighbors(node, room.Nodes);
foreach (var neighbor in neighbors)
{
var isExists = IsExistsEdge(edgeHash, node, neighbor);
if (!isExists)
{
AddEdgeToMap(map, edgeHash, node, neighbor);
}
}
}
}
// создаём переходы, если они есть в данной комнате
if (room.Transitions.Any())
{
//TODO Отфильтровать узлы, которые на входах в коридор
var availableNodes = room.Nodes.Where(x => !x.IsObstacle);
var openRoomNodes = new List <HexNode>(availableNodes);
foreach (var transition in room.Transitions)
{
var transitionNode = _randomSource.RollTransitionNode(openRoomNodes);
map.Transitions.Add(transitionNode, transition);
openRoomNodes.Remove(transitionNode);
}
}
}
public OpenContainerTask([NotNull] IActor actor,
[NotNull] IPropContainer container,
[NotNull] IOpenContainerMethod method,
[NotNull] ISectorMap map) : base(actor)
{
_container = container ?? throw new ArgumentNullException(nameof(container));
_method = method ?? throw new ArgumentNullException(nameof(method));
_map = map ?? throw new ArgumentNullException(nameof(map));
}
private static void CreateTransitions(SectorTransition[] transitions, ISectorMap map)
{
var nodes = map.Nodes.ToArray();
for (var i = 0; i < transitions.Count(); i++)
{
map.Transitions.Add(nodes[i], transitions[i]);
}
}
public LootLogicState(ISectorManager sectorManager)
{
if (sectorManager is null)
{
throw new System.ArgumentNullException(nameof(sectorManager));
}
_map = sectorManager.CurrentSector.Map;
_sectorManager = sectorManager;
}
protected MoveLogicStateBase(IDecisionSource decisionSource, ISectorManager sectorManager)
{
if (sectorManager is null)
{
throw new ArgumentNullException(nameof(sectorManager));
}
DecisionSource = decisionSource ?? throw new ArgumentNullException(nameof(decisionSource));
Map = sectorManager.CurrentSector.Map;
}
private void UseAct(IActor actor, ActTargetInfo target, ITacticalAct act, ISectorMap map)
{
bool isInDistance;
if ((act.Stats.Targets & TacticalActTargets.Self) > 0 && actor == target)
{
isInDistance = true;
}
else
{
isInDistance = IsInDistance(actor, target.TargetNode, act, map);
}
if (!isInDistance)
{
// Это может произойти, если цель, в процессе применения действия
// успела выйти из радиуса применения.
// TODO Лучше сделать, чтобы этот метод возвращал объект с результатом выполнения действия.
// А внешний код пусть либо считает исход допустимым, либо выбрасывает исключения типа UsageOutOfDistanceException
return;
}
var targetNode = target.TargetNode;
var targetIsOnLine = map.TargetIsOnLine(
actor.Node,
targetNode);
if (targetIsOnLine)
{
actor.UseAct(targetNode, act);
var tacticalActRoll = GetActEfficient(act);
var actHandler = _actUsageHandlerSelector.GetHandler(target.TargetObject);
actHandler.ProcessActUsage(actor, target.TargetObject, tacticalActRoll);
UseActResources(actor, act);
}
else
{
// Ситация, когда цель за стеной может произойти по следующим причинам:
// 1. В момент начала применения действия цель была доступна. К моменту выполнения дейтвия цель скрылась.
// В этом случае изымаем патроны и начинаем КД по действию, так как фактически ресурсы на него потрачены. Но на цель не воздействуем.
// 2. Ошибка во внешнем коде, когда не провели предварительную проверку. Это проверяется сравнением ячейки в которую целились
// на момент начала действия и текущую ячейку цели.
if (target.TargetNode == target.TargetObject.Node)
{
throw new UsageThroughtWallException();
}
UseActResources(actor, act);
}
}
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());
}
/// <summary>
/// Проверяет, допустимая ли дистанция для совершения действия.
/// </summary>
/// <param name="act"> Проверяемое действие. </param>
/// <param name="currentNode"> Узел, из которого совершается действие. </param>
/// <param name="targetNode"> Целевой узел. </param>
/// <returns>Возвращает true, если дистанция допустима.</returns>
public static bool CheckDistance(this ITacticalAct act,
IMapNode currentNode,
IMapNode targetNode,
ISectorMap map)
{
var range = act.Stats.Range;
var distance = map.DistanceBetween(currentNode, targetNode);
var isInDistance = range.Contains(distance);
return(isInDistance);
}
public ISector Create(ISectorMap map)
{
var sector = new Sector(map,
_actorManager,
_propContainerManager,
_dropResolver,
_schemeService,
_equipmentDurableService);
return(sector);
}
protected AgressiveLogicBase(IActor actor,
ISectorMap map,
IActorManager actorManager,
IDecisionSource decisionSource,
ITacticalActUsageService actService)
{
Actor = actor;
Map = map;
DecisionSource = decisionSource;
_actorManager = actorManager;
_actService = actService;
_pursuitCounter = PursuitCounter;
}
private void CreateRegionsAndTranstions(ISectorMap map, int mapSize, HexNode centerNode,
IEnumerable <SectorTransition> transitions)
{
var availableNodes = map.Nodes.OfType <HexNode>().ToList();
// start region
var startX = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.X;
var startY = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.Y;
var startRegionNodes = new[] { availableNodes.Single(x => x.OffsetCoords.CompsEqual(startX, startY)) };
var startRegion = new MapRegion(START_REGION_ID, startRegionNodes)
{
IsStart = true
};
map.Regions.Add(startRegion);
foreach (var node in startRegionNodes)
{
availableNodes.Remove(node);
}
// transition regions
var transitionsList = transitions.ToArray();
for (var i = 0; i < transitionsList.Length; i++)
{
var roundPart = Math.PI * 2 * i / transitionsList.Length;
var x = (int)(Math.Cos(roundPart) * mapSize) + centerNode.OffsetCoords.X;
var y = (int)(Math.Sin(roundPart) * mapSize) + centerNode.OffsetCoords.Y;
var transitionRegionNodes = new[] { availableNodes.Single(node => node.OffsetCoords.CompsEqual(x, y)) };
var transitionRegionId = START_REGION_ID + i + 1;
var transitionRegion = new MapRegion(transitionRegionId, transitionRegionNodes);
transitionRegion.ExitNodes = transitionRegion.Nodes;
map.Regions.Add(transitionRegion);
foreach (var node in transitionRegionNodes)
{
availableNodes.Remove(node);
map.Transitions[node] = transitionsList[i];
}
}
// main region
var mainRegion = new MapRegion(1000, availableNodes.ToArray());
map.Regions.Add(mainRegion);
}
public void AddSectorMap(ISectorMap sectorMap)
{
//_sectorMaps.Add(sectorMap);
}
