public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
var map = context.Sector.Map;
var staticObjectManager = context.Sector.StaticObjectManager;
var staticObject = FindContainer(actor, staticObjectManager, map);
if (staticObject == null || !staticObject.GetModule <IPropContainer>().Content.CalcActualItems().Any())
{
Complete = true;
return(null);
}
var distance = map.DistanceBetween(actor.Node, staticObject.Node);
if (distance <= 1)
{
return(TakeAllFromContainerTask(actor, staticObject, context.Sector));
}
var storedMoveTask = _moveTask;
var moveTask = MoveToContainerTask(actor, staticObject.Node, storedMoveTask, context.Sector);
_moveTask = moveTask;
return(moveTask);
}
public bool Test(
IActor actor,
ISectorTaskSourceContext context,
ILogicState currentState,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (currentState is null)
{
throw new ArgumentNullException(nameof(currentState));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
return(TestInner(actor, context, currentState, strategyData));
}
public bool Test(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (currentState is null)
{
throw new ArgumentNullException(nameof(currentState));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
if (!actor.Person.HasModule <IInventoryModule>() || !actor.Person.HasModule <IEquipmentModule>())
{
return(false);
}
var inventoryModule = actor.Person.GetModule <IInventoryModule>();
var inventoryProps = inventoryModule.CalcActualItems();
var currentInventoryEquipments = inventoryProps.OfType <Equipment>();
if (!currentInventoryEquipments.Any())
{
strategyData.TargetEquipment = null;
strategyData.TargetEquipmentSlotIndex = null;
return(false);
}
var equipmentModule = actor.Person.GetModule <IEquipmentModule>();
for (var slotIndex = 0; slotIndex < equipmentModule.Slots.Length; slotIndex++)
{
var slotScheme = equipmentModule.Slots[slotIndex];
var equiped = equipmentModule[slotIndex];
if (equiped is null)
{
var availableEquipments = from equipment in currentInventoryEquipments
where IsApplicableForSlot(equipment, slotScheme.Types)
where EquipmentCarrierHelper.CanBeEquiped(equipmentModule, slotIndex,
equipment)
select equipment;
var targetEquipmentFromInventory = availableEquipments.FirstOrDefault();
if (targetEquipmentFromInventory != null)
{
strategyData.TargetEquipment = targetEquipmentFromInventory;
strategyData.TargetEquipmentSlotIndex = slotIndex;
return(true);
}
}
}
return(false);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
var hpStat = actor.Person.Survival.Stats.SingleOrDefault(x => x.Type == SurvivalStatType.Health);
var hpStatCoeff = (float)hpStat.Value / (hpStat.Range.Max - hpStat.Range.Min);
var isLowHp = hpStatCoeff <= 0.5f;
if (!isLowHp)
{
Complete = true;
return(null);
}
var props = actor.Person.Inventory.CalcActualItems();
var resources = props.OfType <Resource>();
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(resources,
ConsumeCommonRuleType.Health);
if (bestResource == null)
{
Complete = true;
return(null);
}
return(new UsePropTask(actor, bestResource));
}
public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
var usePropTask = CreateTask(actor, context, strategyData);
if (usePropTask != null)
{
Complete = true;
return(usePropTask);
}
Complete = true;
return(null);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
var currentInventoryEquipments = actor.Person.Inventory.CalcActualItems().OfType <Equipment>();
var emptyEquipmentSlots = new List <PersonSlotSubScheme>();
for (int i = 0; i < actor.Person.EquipmentCarrier.Slots.Length; i++)
{
var slot = actor.Person.EquipmentCarrier.Slots[i];
var equiped = actor.Person.EquipmentCarrier[i];
if (equiped == null)
{
var availableEquipments = currentInventoryEquipments
.Where(x => (x.Scheme.Equip.SlotTypes[0] & slot.Types) > 0);
if (availableEquipments.Any())
{
var targetEquipmentFromInventory = availableEquipments.First();
var targetSlotIndex = i;
return(new EquipTask(actor, targetEquipmentFromInventory, targetSlotIndex));
}
}
}
Complete = true;
return(null);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
var inventory = actor.Person.GetModule <IInventoryModule>();
var currentInventoryProps = inventory.CalcActualItems();
var currentInventoryEquipments = currentInventoryProps.OfType <Equipment>().ToArray();
var equipmentCarrier = actor.Person.GetModule <IEquipmentModule>();
for (var slotIndex = 0; slotIndex < equipmentCarrier.Slots.Length; slotIndex++)
{
var slot = actor.Person.GetModule <IEquipmentModule>().Slots[slotIndex];
var equiped = actor.Person.GetModule <IEquipmentModule>()[slotIndex];
if (equiped == null)
{
var availableEquipments = currentInventoryEquipments
.Where(equipment => (equipment.Scheme.Equip.SlotTypes[0] & slot.Types) > 0)
.Where(equipment => EquipmentCarrierHelper.CanBeEquiped(equipmentCarrier, slotIndex, equipment))
.ToArray();
if (availableEquipments.Any())
{
var targetEquipmentFromInventory = availableEquipments.First();
var targetSlotIndex = slotIndex;
return(new EquipTask(actor, targetEquipmentFromInventory, targetSlotIndex));
}
}
}
Complete = true;
return(null);
}
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);
}
}
private MoveTask CreateBypassMoveTask(IActor actor, ILogicStrategyData strategyData)
{
IEnumerable <IGraphNode> availableNodes;
var frontNodes = WriteObservedNodes(actor, strategyData).ToArray();
if (frontNodes.Any())
{
availableNodes = frontNodes;
}
else
{
availableNodes = strategyData.ObserverdNodes;
}
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);
}
public bool Test(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (currentState is null)
{
throw new ArgumentNullException(nameof(currentState));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
var staticObjectManager = context.Sector.StaticObjectManager;
var map = context.Sector.Map;
var containers = staticObjectManager.Items.Where(x => x.HasModule <IPropContainer>());
var foundContainers = LootHelper.FindAvailableContainers(containers,
actor.Node,
map);
return(foundContainers.Any());
}
private MoveTask CreateBypassMoveTask(IActor actor, ILogicStrategyData strategyData, ISector sector)
{
var map = sector.Map;
var frontNodes = WriteObservedNodesOrGetFromFow(actor, strategyData, sector).ToArray();
if (!frontNodes.Any())
{
return(null);
}
var availableNodesArray = frontNodes as HexNode[] ?? frontNodes.ToArray();
if (availableNodesArray.Length == 0)
{
// There is no nodes available to roaming.
// We can do nothing.
return(null);
}
for (var i = 0; i < 3; i++)
{
var targetNode = DecisionSource.SelectTargetRoamingNode(availableNodesArray);
if (map.IsPositionAvailableFor(targetNode, actor))
{
var context = new ActorTaskContext(sector);
var moveTask = new MoveTask(actor, context, targetNode, map);
return(moveTask);
}
}
return(null);
}
private static IEnumerable <IGraphNode> WriteObservedNodesOrGetFromFow(IActor actor,
ILogicStrategyData strategyData,
ISector sector)
{
IEnumerable <IGraphNode> frontNodes;
var fowModule = actor.Person.GetModuleSafe <IFowData>();
if (fowModule is null)
{
frontNodes = GetNodesUsingStrategyData(actor, strategyData, sector);
}
else
{
frontNodes = GetNodesUsingFowModule(strategyData, sector, fowModule);
}
if (!frontNodes.Any())
{
var closestNode = sector.Map.GetNext(actor.Node).FirstOrDefault();
if (closestNode != null)
{
frontNodes = new[] { closestNode };
}
}
return(frontNodes);
}
private static IEnumerable <IGraphNode> GetNodesUsingFowModule(
ILogicStrategyData strategyData,
ISector sector,
IFowData fowModule)
{
IEnumerable <IGraphNode> frontNodes;
var knownNodes = GetKnownNodes(sector, fowModule);
var map = sector.Map;
var frontNodesHashSet = new HashSet <IGraphNode>();
foreach (var node in knownNodes)
{
// Примечаем выходы
if (map.Transitions.ContainsKey(node))
{
strategyData.ExitNodes.Add(node);
}
var nextUnknownNodes = map.GetNext(node).Where(x => !knownNodes.Contains(x));
if (nextUnknownNodes.Any())
{
foreach (var unknownNode in nextUnknownNodes)
{
frontNodesHashSet.Add(unknownNode);
}
}
}
frontNodes = frontNodesHashSet;
return(frontNodes);
}
public bool Test(IActor actor, ILogicState currentState, ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new System.ArgumentNullException(nameof(actor));
}
var hazardEffect = actor.Person.GetModule <IEffectsModule>().Items.OfType <SurvivalStatHazardEffect>()
.SingleOrDefault(x => x.Type == SurvivalStatType.Satiety);
if (hazardEffect == null)
{
return(false);
}
//
var props = actor.Person.GetModule <IInventoryModule>().CalcActualItems();
var resources = props.OfType <Resource>();
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(resources,
ConsumeCommonRuleType.Satiety);
if (bestResource == null)
{
return(false);
}
return(true);
}
public static bool TestHazardAndResource(
IActor actor,
ActorTaskContext taskContext,
ILogicStrategyData strategyData,
SurvivalStatType statType,
ConsumeCommonRuleType ruleType)
{
var hasHazardEffect = HasCondition(actor, statType);
if (!hasHazardEffect)
{
return(false);
}
var resource = ResourceToReduceHazard(actor, taskContext, ruleType);
if (resource is null)
{
strategyData.ResourceToReduceHazard = null;
return(false);
}
strategyData.ResourceToReduceHazard = resource;
return(true);
}
public bool Test(IActor actor, ILogicState currentState, ILogicStrategyData strategyData)
{
var foundContainers = LootHelper.FindAvailableContainers(_propContainerManager.Items,
actor.Node,
_map);
return(foundContainers.Any());
}
public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
var triggerTarget = strategyData.TriggerIntuder;
if (triggerTarget == null)
{
throw new InvalidOperationException(
$"Assign {nameof(strategyData.TriggerIntuder)} with not null valie in related trigger.");
}
var targetCanBeDamaged = triggerTarget.CanBeDamaged();
if (!targetCanBeDamaged)
{
Complete = true;
return(null);
}
var attackParams = CheckAttackAvailability(actor, triggerTarget, context.Sector.Map);
if (attackParams.IsAvailable)
{
var act = attackParams.CombatAct;
var taskContext = new ActorTaskContext(context.Sector);
var attackTask = new AttackTask(actor, taskContext, triggerTarget, act, _actService);
return(attackTask);
}
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)
{
_refreshCounter--;
return(_moveTask);
}
var map = context.Sector.Map;
_refreshCounter = REFRESH_COUNTER_VALUE;
var targetIsOnLine = map.TargetIsOnLine(actor.Node, triggerTarget.Node);
if (targetIsOnLine)
{
var taskContext = new ActorTaskContext(context.Sector);
var moveModule = actor.Person.GetModule <IMovingModule>();
var moveCost = moveModule.CalculateCost();
_moveTask = new MoveTask(actor, taskContext, triggerTarget.Node, map, moveCost);
return(_moveTask);
}
// Цел за пределами видимости. Считается потерянной.
return(null);
}
public bool Test(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
if (currentState is null)
{
throw new System.ArgumentNullException(nameof(currentState));
}
return(currentState.Complete);
}
protected override bool TestInner(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
var taskContext = new ActorTaskContext(context.Sector);
return(SurvivalHazardTriggerHelper.TestHazardAndResource(
actor,
taskContext,
strategyData,
SurvivalStatType.Satiety,
ConsumeCommonRuleType.Satiety));
}
public bool Test(IActor actor, ILogicState currentState, ILogicStrategyData strategyData)
{
foreach (var trigger in _triggers)
{
if (!trigger.Test(actor, currentState, strategyData))
{
return(false);
}
}
return(true);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (_target == null)
{
_target = GetTarget(actor);
}
var targetCanBeDamaged = _target.CanBeDamaged();
if (!targetCanBeDamaged)
{
Complete = true;
return(null);
}
var attackParams = CheckAttackAvailability(actor, _target);
if (attackParams.IsAvailable)
{
var act = attackParams.TacticalAct;
var attackTask = new AttackTask(actor, _target, act, _actService);
return(attackTask);
}
else
{
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)
{
_refreshCounter--;
return(_moveTask);
}
else
{
_refreshCounter = REFRESH_COUNTER_VALUE;
var targetIsOnLine = _map.TargetIsOnLine(actor.Node, _target.Node);
if (targetIsOnLine)
{
_moveTask = new MoveTask(actor, _target.Node, _map);
return(_moveTask);
}
else
{
// Цел за пределами видимости. Считается потерянной.
return(null);
}
}
}
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (IdleTask == null)
{
IdleTask = new IdleTask(actor, _decisionSource);
}
if (IdleTask.IsComplete)
{
Complete = true;
return(null);
}
return(IdleTask);
}
public bool Test(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (currentState is null)
{
throw new ArgumentNullException(nameof(currentState));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
//TODO Здесь лучше проверять на наличие эффекта раны
var hpStat = actor.Person.GetModule <ISurvivalModule>().Stats
.SingleOrDefault(x => x.Type == SurvivalStatType.Health);
var isLowHp = hpStat.ValueShare <= 0.5f;
if (!isLowHp)
{
return(false);
}
//
var props = actor.Person.GetModule <IInventoryModule>().CalcActualItems();
var resources = props.OfType <Resource>();
var taskContext = new ActorTaskContext(context.Sector);
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(
actor,
taskContext,
resources,
ConsumeCommonRuleType.Health);
if (bestResource == null)
{
return(false);
}
return(true);
}
/// <summary>
/// Checks situation when all nodes of a map are explored (known) by the person.
/// </summary>
/// <returns>True if all nodes are explored. False otherside.</returns>
public bool Test(IActor actor, ISectorTaskSourceContext context, ILogicState currentState,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (currentState is null)
{
throw new ArgumentNullException(nameof(currentState));
}
if (strategyData is null)
{
throw new ArgumentNullException(nameof(strategyData));
}
var fowModule = actor.Person.GetModuleSafe <IFowData>();
if (fowModule is null)
{
var notObservedNodes = context.Sector.Map.Nodes.Where(x => !strategyData.ObservedNodes.Contains(x));
var allNodesObserved = !notObservedNodes.Any();
return(allNodesObserved);
}
else
{
var fowData = fowModule.GetSectorFowData(context.Sector);
var observingNodes = fowData.GetFowNodeByState(SectorMapNodeFowState.Observing).Select(x => x.Node)
.ToArray();
var exploredNodes = fowData.GetFowNodeByState(SectorMapNodeFowState.Explored).Select(x => x.Node)
.ToArray();
var knownNodes = observingNodes.Union(exploredNodes);
var notObservedNodes = context.Sector.Map.Nodes.Where(x => !knownNodes.Contains(x));
var allNodesObserved = !notObservedNodes.Any();
return(allNodesObserved);
}
}
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);
}
private static UsePropTask CreateTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
if (strategyData.ResourceToReduceHazard is null)
{
throw new InvalidOperationException(
$"Assign {nameof(strategyData.ResourceToReduceHazard)} value in the triggers first.");
}
var taskContxt = new ActorTaskContext(context.Sector);
var prop = strategyData.ResourceToReduceHazard;
// When prop was used it no need to store anymore.
strategyData.ResourceToReduceHazard = null;
return(new UsePropTask(actor, taskContxt, prop));
}
public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
if (actor is null)
{
throw new System.ArgumentNullException(nameof(actor));
}
if (context is null)
{
throw new System.ArgumentNullException(nameof(context));
}
var hpStat = actor.Person.GetModule <ISurvivalModule>().Stats
.SingleOrDefault(x => x.Type == SurvivalStatType.Health);
if (hpStat == null)
{
Complete = true;
return(null);
}
var hpStatCoeff = (float)hpStat.Value / (hpStat.Range.Max - hpStat.Range.Min);
var isLowHp = hpStatCoeff <= 0.5f;
if (!isLowHp)
{
Complete = true;
return(null);
}
var props = actor.Person.GetModule <IInventoryModule>().CalcActualItems();
var resources = props.OfType <Resource>();
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(resources,
ConsumeCommonRuleType.Health);
if (bestResource == null)
{
Complete = true;
return(null);
}
var taskContext = new ActorTaskContext(context.Sector);
return(new UsePropTask(actor, taskContext, bestResource));
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (MoveTask == null)
{
MoveTask = CreateBypassMoveTask(actor, strategyData);
if (MoveTask != null)
{
return(MoveTask);
}
else
{
// Это может произойти, если актёр не выбрал следующий узел.
// Тогда переводим актёра в режим ожидания.
IdleTask = new IdleTask(actor, DecisionSource);
return(IdleTask);
}
}
else
{
if (!MoveTask.IsComplete)
{
// Если команда на перемещение к целевой точке патруля не закончена,
// тогда продолжаем её.
// Предварительно проверяем, не мешает ли что-либо её продолжить выполнять.
if (!MoveTask.CanExecute())
{
MoveTask = CreateBypassMoveTask(actor, strategyData);
}
if (MoveTask != null)
{
return(MoveTask);
}
IdleTask = new IdleTask(actor, DecisionSource);
return(IdleTask);
}
else
{
Complete = true;
return(null);
}
}
}
public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
if (_idleTask == null)
{
var taskContext = new ActorTaskContext(context.Sector);
_idleTask = new IdleTask(actor, taskContext, _decisionSource);
}
if (_idleTask.IsComplete)
{
Complete = true;
return(null);
}
return(_idleTask);
}
private static IEnumerable <IGraphNode> GetNodesUsingStrategyData(
IActor actor,
ILogicStrategyData strategyData,
ISector sector)
{
IEnumerable <IGraphNode> frontNodes;
var map = sector.Map;
var observeNodes = map.Nodes.Where(x => map.DistanceBetween(x, actor.Node) < 5);
foreach (var mapNode in observeNodes)
{
strategyData.ObservedNodes.Add(mapNode);
}
// Собираем пограничные неисследованные узлы.
var frontNodesHashSet = new HashSet <IGraphNode>();
foreach (var observedNode in strategyData.ObservedNodes)
{
var nextNodes = map.GetNext(observedNode);
var notObservedNextNodes = nextNodes.Where(x => !strategyData.ObservedNodes.Contains(x));
foreach (var edgeNode in notObservedNextNodes)
{
frontNodesHashSet.Add(edgeNode);
}
// Примечаем выходы
if (map.Transitions.ContainsKey(observedNode))
{
strategyData.ExitNodes.Add(observedNode);
}
}
var emptyFrontNodes = !frontNodesHashSet.Any();
var allNodesObserved = map.Nodes.All(x => strategyData.ObservedNodes.Contains(x));
Debug.Assert((emptyFrontNodes && allNodesObserved) || !emptyFrontNodes,
"Это состояние выполняется, только если есть неисследованые узлы.");
frontNodes = frontNodesHashSet;
return(frontNodes);
}
