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);
}
private void ProcessPositiveRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
{
switch (type)
{
case ConsumeCommonRuleType.Satiety:
RestoreStat(SurvivalStatType.Satiety, ruleLevel);
break;
case ConsumeCommonRuleType.Thirst:
RestoreStat(SurvivalStatType.Hydration, ruleLevel);
break;
case ConsumeCommonRuleType.Health:
RestoreStat(SurvivalStatType.Health, ruleLevel);
break;
case ConsumeCommonRuleType.Intoxication:
RiseStat(SurvivalStatType.Intoxication, ruleLevel);
break;
case ConsumeCommonRuleType.Undefined:
default:
throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");
}
}
public static IEnumerable <ResourceSelection> FindConsumableResourcesByRule(
IActor actor,
IActorTaskContext context,
IEnumerable <Resource> resources,
ConsumeCommonRuleType ruleType)
{
foreach (var resource in resources)
{
var rule = resource.Scheme.Use?.CommonRules?
.SingleOrDefault(x => x.Type == ruleType && x.Direction == PersonRuleDirection.Positive);
if (rule != null)
{
var isAllow = UsePropHelper.CheckPropAllowedByRestrictions(resource, actor, context);
if (!isAllow)
{
continue;
}
yield return(new ResourceSelection
{
Resource = resource,
Rule = rule
});
}
}
}
public static Resource FindBestConsumableResourceByRule(IEnumerable <Resource> resources,
ConsumeCommonRuleType ruleType)
{
var foundResources = FindConsumableResourcesByRule(resources, ruleType);
var orderedResources = foundResources.OrderByDescending(x => x.Rule.Level);
var bestResource = orderedResources.FirstOrDefault();
return(bestResource?.Resource);
}
public ConsumeCommonRule(ConsumeCommonRuleType type,
PersonRuleLevel level,
PersonRuleDirection direction = PersonRuleDirection.Positive)
{
Type = type;
Level = level;
Direction = direction;
if (Direction == 0)
{
Direction = PersonRuleDirection.Positive;
}
}
private static Resource ResourceToReduceHazard(IActor actor, ConsumeCommonRuleType ruleType)
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
var props = actor.Person.GetModule <IInventoryModule>().CalcActualItems();
var resources = props.OfType <Resource>();
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(resources,
ruleType);
return(bestResource);
}
private static TestPropScheme CreateTestPropScheme(string propSid, PersonRuleDirection direction,
ConsumeCommonRuleType consumeRuleType)
{
return(new TestPropScheme
{
Sid = propSid,
Use = new TestPropUseSubScheme
{
Consumable = true,
CommonRules = new[]
{
new ConsumeCommonRule(consumeRuleType, PersonRuleLevel.Lesser, direction)
}
}
});
}
public static IEnumerable <ResourceSelection> FindConsumableResourcesByRule(IEnumerable <Resource> resources,
ConsumeCommonRuleType ruleType)
{
foreach (var resource in resources)
{
var rule = resource.Scheme.Use?.CommonRules?
.SingleOrDefault(x => x.Type == ruleType && x.Direction == PersonRuleDirection.Positive);
if (rule != null)
{
yield return(new ResourceSelection
{
Resource = resource,
Rule = rule
});
}
}
}
private UsePropTask CheckHazard(IActor actor, SurvivalStatType hazardType, ConsumeCommonRuleType resourceType)
{
var hazardEffect = actor.Person.Effects.Items.OfType <SurvivalStatHazardEffect>()
.SingleOrDefault(x => x.Type == hazardType);
if (hazardEffect == null)
{
return(null);
}
var props = actor.Person.Inventory.CalcActualItems();
var resources = props.OfType <Resource>();
var bestResource = ResourceFinder.FindBestConsumableResourceByRule(resources,
resourceType);
if (bestResource == null)
{
return(null);
}
return(new UsePropTask(actor, bestResource));
}
private static void ParseProvisionStat(string provisionStat, out PersonRuleDirection direction,
out ConsumeCommonRuleType consumeRuleType)
{
direction = PersonRuleDirection.Positive;
switch (provisionStat)
{
case "сытость":
consumeRuleType = ConsumeCommonRuleType.Satiety;
break;
case "вода":
consumeRuleType = ConsumeCommonRuleType.Thirst;
break;
case "хп":
consumeRuleType = ConsumeCommonRuleType.Health;
break;
case "-сытость":
consumeRuleType = ConsumeCommonRuleType.Satiety;
direction = PersonRuleDirection.Negative;
break;
case "-вода":
consumeRuleType = ConsumeCommonRuleType.Thirst;
direction = PersonRuleDirection.Negative;
break;
case "-хп":
consumeRuleType = ConsumeCommonRuleType.Health;
direction = PersonRuleDirection.Negative;
break;
default:
throw new NotSupportedException("Передан неподдерживаемый тип характеристики.");
}
}
