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("Передан неподдерживаемый тип характеристики."); } }