Ejemplo n.º 1
0
        public void UseProp(IProp usedProp)
        {
            if (usedProp is null)
            {
                throw new ArgumentNullException(nameof(usedProp));
            }

            var useData = usedProp.Scheme.Use;

            if (useData?.CommonRules is null)
            {
                throw new InvalidOperationException();
            }

            foreach (var rule in useData.CommonRules)
            {
                if (rule is null)
                {
                    continue;
                }

                switch (rule.Direction)
                {
                // Если направление не указано, то будет считаться положительное значение
                //TODO При десериализации указывать значение Positive по умолчанию
                default:
                case PersonRuleDirection.Positive:
                    ProcessPositiveRule(rule.Type, rule.Level);
                    break;

                case PersonRuleDirection.Negative:
                    ProcessNegativeRule(rule.Type, rule.Level);
                    break;
                }
            }

            if (useData.Consumable && Person.GetModuleSafe <IInventoryModule>() != null)
            {
                ConsumeResource(usedProp);

                if (_perkResolver != null)
                {
                    var consumeProgress = new ConsumeProviantJobProgress();
                    _perkResolver.ApplyProgress(consumeProgress, Person.GetModule <IEvolutionModule>());
                }
            }

            UsedProp?.Invoke(this, new UsedPropEventArgs(usedProp));
        }
Ejemplo n.º 2
0
        public void UseProp(IProp usedProp)
        {
            var useData = usedProp.Scheme.Use;

            foreach (var rule in useData.CommonRules)
            {
                switch (rule.Direction)
                {
                case PersonRuleDirection.Positive:
                    switch (rule.Type)
                    {
                    case ConsumeCommonRuleType.Satiety:
                        RestoreStat(SurvivalStatType.Satiety, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Thirst:
                        RestoreStat(SurvivalStatType.Hydration, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Health:
                        RestoreStat(SurvivalStatType.Health, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Intoxication:
                        RiseStat(SurvivalStatType.Intoxication, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Undefined:
                    default:
                        throw new ArgumentOutOfRangeException($"Правило поглощения {rule.Type} не поддерживается.");
                    }
                    break;

                case PersonRuleDirection.Negative:
                    switch (rule.Type)
                    {
                    case ConsumeCommonRuleType.Satiety:
                        DecreaseStat(SurvivalStatType.Satiety, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Thirst:
                        DecreaseStat(SurvivalStatType.Hydration, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Health:
                        DecreaseStat(SurvivalStatType.Health, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Intoxication:
                        DecreaseStat(SurvivalStatType.Intoxication, rule.Level);
                        break;

                    case ConsumeCommonRuleType.Undefined:
                    default:
                        throw new ArgumentOutOfRangeException($"Правило поглощения {rule.Type} не поддерживается.");
                    }
                    break;
                }
            }

            if (useData.Consumable && Person.Inventory != null)
            {
                ConsumeResource(usedProp);

                if (_perkResolver != null)
                {
                    var consumeProgress = new ConsumeProviantJobProgress();
                    _perkResolver.ApplyProgress(consumeProgress, Person.EvolutionData);
                }
            }
        }