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 IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (!strategyData.ExitNodes.Any())
{
Complete = true;
return(null);
}
if (_moveTask == null || _moveTask.IsComplete || !_moveTask.CanExecute())
{
var nearbyExitNode = strategyData.ExitNodes
.OrderBy(x => _map.DistanceBetween(actor.Node, x))
.First();
_moveTask = CreateMoveTask(actor, nearbyExitNode);
if (_moveTask == null)
{
Complete = true;
return(null);
}
return(_moveTask);
}
else
{
return(_moveTask);
}
}
/// <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);
}
/// <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 IActorTask GetCurrentTask()
{
// На каждом шаге осматриваем окрестности
// на предмет нарушителей.
var intruders = CheckForIntruders();
var orderedIntruders = intruders.OrderBy(x => Map.DistanceBetween(Actor.Node, x.Node));
var nearbyIntruder = orderedIntruders.FirstOrDefault();
if (nearbyIntruder != null)
{
_mode = Mode.Pursuit;
_targetIntruder = nearbyIntruder;
_idleTask = null;
ProcessIntruderDetected();
}
else
{
if (_idleTask == null || _idleTask.IsComplete)
{
_mode = Mode.Bypass;
_targetIntruder = null;
_idleTask = null;
}
}
switch (_mode)
{
case Mode.Bypass:
return(HandleBypassMode());
case Mode.Pursuit:
return(HandlePersuitMode());
case Mode.Idle:
return(HandleIdleMode());
default:
throw new InvalidOperationException($"Неизвестный режим {_mode}");
}
}
private IAttackTarget GetTarget(IActor actor)
{
//TODO Убрать дублирование кода с IntruderDetectedTrigger
// Этот фрагмент уже однажды был использован неправильно,
// что привело к трудноуловимой ошибке.
var intruders = CheckForIntruders(actor);
var orderedIntruders = intruders.OrderBy(x => _map.DistanceBetween(actor.Node, x.Node));
var nearbyIntruder = orderedIntruders.FirstOrDefault();
return(nearbyIntruder);
}
public bool Test(IActor actor, ILogicState currentState, ILogicStrategyData strategyData)
{
// На каждом шаге осматриваем окрестности
// на предмет нарушителей.
var intruders = CheckForIntruders(actor);
var orderedIntruders = intruders.OrderBy(x => _map.DistanceBetween(actor.Node, x.Node));
var nearbyIntruder = orderedIntruders.FirstOrDefault();
if (nearbyIntruder == null)
{
return(false);
}
return(true);
}
protected override void ExecuteTask()
{
var distance = _map.DistanceBetween(Actor.Node, _staticObject.Node);
if (distance > 1)
{
throw new InvalidOperationException("Невозможно взаимодействовать с контейнером на расстоянии больше 1.");
}
var targetIsOnLine = _map.TargetIsOnLine(Actor.Node, _staticObject.Node);
if (!targetIsOnLine)
{
throw new InvalidOperationException("Задачу на открытие сундука нельзя выполнить сквозь стены.");
}
Actor.OpenContainer(_staticObject, _method);
}
protected override void ExecuteTask()
{
var distance = _map.DistanceBetween(Actor.Node, _staticObject.Node);
if (distance > 1)
{
throw new InvalidOperationException("Невозможно взаимодействовать с объектом на расстоянии больше 1.");
}
var targetIsOnLine = _map.TargetIsOnLine(Actor.Node, _staticObject.Node);
if (!targetIsOnLine)
{
throw new InvalidOperationException("Задачу на добычу нельзя выполнить сквозь стены.");
}
Actor.MineDeposit(_staticObject, _method);
}
public static bool CheckTargetVisible(ISectorMap map, IMapNode node, IMapNode target)
{
var distance = map.DistanceBetween(node, target);
var isInSignRange = distance <= SIGN_RANGE;
if (!isInSignRange)
{
return(false);
}
var isVisible = map.TargetIsOnLine(node, target);
if (!isVisible)
{
return(false);
}
return(true);
}
private MoveTask CreateBypassMoveTask(IActor actor)
{
var availableNodes = _map.Nodes.Where(x => _map.DistanceBetween(x, actor.Node) < 5);
var availableNodesArray = availableNodes as HexNode[] ?? availableNodes.ToArray();
for (var i = 0; i < 3; i++)
{
var targetNode = _decisionSource.SelectTargetRoamingNode(availableNodesArray);
if (_map.IsPositionAvailableFor(targetNode, actor))
{
var moveTask = new MoveTask(actor, targetNode, _map);
return(moveTask);
}
}
return(null);
}
private IEnumerable <IMapNode> WriteObservedNodes(IActor actor, ILogicStrategyData strategyData)
{
var observeNodes = _map.Nodes.Where(x => _map.DistanceBetween(x, actor.Node) < 5);
foreach (var mapNode in observeNodes)
{
strategyData.ObserverdNodes.Add(mapNode);
}
var edgeNodes = new HashSet <IMapNode>();
foreach (var observedNode in strategyData.ObserverdNodes)
{
var nextNodes = _map.GetNext(observedNode);
var notObservedNextNodes = nextNodes.Where(x => !strategyData.ObserverdNodes.Contains(x));
foreach (var edgeNode in notObservedNextNodes)
{
edgeNodes.Add(edgeNode);
}
// Примечаем выходы
if (_map.Transitions.ContainsKey(observedNode))
{
strategyData.ExitNodes.Add(observedNode);
}
}
var emptyEdgeNodes = !edgeNodes.Any();
var allNodesObserved = _map.Nodes.All(x => strategyData.ObserverdNodes.Contains(x));
if (!((emptyEdgeNodes && allNodesObserved) || !emptyEdgeNodes))
{
}
Debug.Assert((emptyEdgeNodes && allNodesObserved) || !emptyEdgeNodes,
"Если нет крайних узлов карты, значит все узлы карты исследованы.");
return(edgeNodes);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (!strategyData.ExitNodes.Any())
{
Complete = true;
return(null);
}
var actorNode = actor.Node;
if (_map.Transitions.TryGetValue(actorNode, out var currentTransition))
{
_sector.UseTransition(currentTransition);
Complete = true;
return(null);
}
if (_moveTask == null || _moveTask.IsComplete || !_moveTask.CanExecute())
{
var nearbyExitNode = strategyData.ExitNodes
.OrderBy(x => _map.DistanceBetween(actor.Node, x))
.First();
_moveTask = CreateMoveTask(actor, nearbyExitNode);
if (_moveTask == null)
{
Complete = true;
return(null);
}
return(_moveTask);
}
else
{
return(_moveTask);
}
}
private IEnumerable <IMapNode> WriteObservedNodes(IActor actor, ILogicStrategyData strategyData)
{
var observeNodes = _map.Nodes.Where(x => _map.DistanceBetween(x, actor.Node) < 5);
foreach (var mapNode in observeNodes)
{
strategyData.ObserverdNodes.Add(mapNode);
}
// Собираем пограничные неисследованные узлы.
var frontNodes = new HashSet <IMapNode>();
foreach (var observedNode in strategyData.ObserverdNodes)
{
var nextNodes = _map.GetNext(observedNode);
var notObservedNextNodes = nextNodes.Where(x => !strategyData.ObserverdNodes.Contains(x));
foreach (var edgeNode in notObservedNextNodes)
{
frontNodes.Add(edgeNode);
}
// Примечаем выходы
if (_map.Transitions.ContainsKey(observedNode))
{
strategyData.ExitNodes.Add(observedNode);
}
}
var emptyFrontNodes = !frontNodes.Any();
var allNodesObserved = _map.Nodes.All(x => strategyData.ObserverdNodes.Contains(x));
Debug.Assert((emptyFrontNodes && allNodesObserved) || !emptyFrontNodes,
"Это состояние выполняется, только если есть неисследованые узлы.");
return(frontNodes);
}
public static IActor GetIntruder(IActor actor, ISectorMap map, IActorManager actorManager)
{
if (actor is null)
{
throw new System.ArgumentNullException(nameof(actor));
}
if (map is null)
{
throw new System.ArgumentNullException(nameof(map));
}
if (actorManager is null)
{
throw new System.ArgumentNullException(nameof(actorManager));
}
var intruders = CheckForIntruders(actor, map, actorManager);
var orderedIntruders = intruders.OrderBy(x => map.DistanceBetween(actor.Node, x.Node));
var nearbyIntruder = orderedIntruders.FirstOrDefault();
return(nearbyIntruder);
}
public static bool CheckTargetVisible(ISectorMap map, IGraphNode node, IGraphNode target)
{
if (map is null)
{
throw new ArgumentNullException(nameof(map));
}
var distance = map.DistanceBetween(node, target);
var isInSignRange = distance <= SIGN_RANGE;
if (!isInSignRange)
{
return(false);
}
var isVisible = map.TargetIsOnLine(node, target);
if (!isVisible)
{
return(false);
}
return(true);
}
public int GetDistanceBetween(IGraphNode current, IGraphNode target)
{
return(_map.DistanceBetween(current, target));
}