private void CountTargetActorAttack(IActor actor, IActor targetActor, ITacticalAct tacticalAct)
        {
            if (actor.Person is MonsterPerson)
            {
                // Монстры не могут прокачиваться.
                return;
            }

            if (actor.Person == null)
            {
                // Это может происходить в тестах,
                // если в моках не определили персонажа.
                //TODO Поискать решение, как всегда быть уверенным, что персонаж указан в боевых условиях, и может быть null в тестах.
                //TODO Эта же проверка нужна в CountActorDefeat (учёт убиства актёра).
                return;
            }

            var evolutionData = actor.Person.EvolutionData;

            //TODO Такую же проверку добавить в CountActorDefeat (учёт убиства актёра).
            if (evolutionData == null)
            {
                return;
            }

            var progress = new AttackActorJobProgress(targetActor, tacticalAct);

            _perkResolver.ApplyProgress(progress, evolutionData);
        }
Beispiel #2
0
        public void UseProp(IProp usedProp)
        {
            if (usedProp is null)
            {
                throw new ArgumentNullException(nameof(usedProp));
            }

            var useData = usedProp.Scheme.Use;

            foreach (var rule in useData.CommonRules)
            {
                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));
        }
        /// <summary>
        /// Расчитывает убийство целевого актёра.
        /// </summary>
        /// <param name="actor"> Актёр, который совершил действие. </param>
        /// <param name="targetActor"> Цель использования действия. </param>
        private void CountTargetActorDefeat(IActor actor, IActor targetActor)
        {
            if (actor.Person is MonsterPerson)
            {
                // Монстры не могут прокачиваться.
                return;
            }

            var evolutionData = actor.Person.EvolutionData;

            var defeatProgress = new DefeatActorJobProgress(targetActor);

            _perkResolver.ApplyProgress(defeatProgress, evolutionData);
        }
Beispiel #4
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);
                }
            }
        }