public void GivenАктёрЗначениеСытостьРавное(string statName, int statValue)
        {
            var actor    = Context.GetActiveActor();
            var survival = actor.Person.Survival;

            SurvivalStatType statType;

            switch (statName)
            {
            case "сытость":
                statType = SurvivalStatType.Satiety;
                break;

            case "вода":
                statType = SurvivalStatType.Water;
                break;

            default:
                throw new NotSupportedException("Передан неподдерживаемый тип характеристики.");
            }

            var stat     = survival.Stats.Single(x => x.Type == statType);
            var oldValue = stat.Value;

            survival.SetStatForce(statType, statValue);

            var keyPoints = stat.KeyPoints.CalcKeyPointsInRange(oldValue, statValue);

            var survivalRandomSource = Context.Container.GetInstance <ISurvivalRandomSource>();
            var effect = new SurvivalStatHazardEffect(statType, keyPoints.First().Level, survivalRandomSource);

            actor.Person.Effects.Add(effect);
        }
    private void CreateSurvivalHazardEffect(SurvivalStatHazardEffect survivalHazardEffect)
    {
        var effectViewModelObj = _diContainer.InstantiatePrefab(SurvivalHazardEffectPrefab, EffectParent);
        var effectViewModel    = effectViewModelObj.GetComponent <SurvivalHazardEffectViewModel>();

        effectViewModel.Init(survivalHazardEffect.Type, survivalHazardEffect.Level);
    }
Example #3
0
        /// <summary>
        /// Обновление эффекта модуля выживания.
        /// </summary>
        /// <param name="currentEffects"> Текущий список эффектов. </param>
        /// <param name="stat"> Характеристика, на которую влияет эффект. </param>
        /// <param name="keyPoints"> Ключевые точки, которые учавствуют в изменении характеристик. </param>
        /// <param name="survivalRandomSource"> Источник рандома выживания. </param>
        public static void UpdateSurvivalEffect(
            [NotNull] EffectCollection currentEffects,
            [NotNull] SurvivalStat stat,
            [NotNull][ItemNotNull] IEnumerable <SurvivalStatKeyPoint> keyPoints,
            [NotNull] ISurvivalRandomSource survivalRandomSource)
        {
            CheckArguments(currentEffects, stat, keyPoints, survivalRandomSource);

            var statType          = stat.Type;
            var currentTypeEffect = GetCurrentEffect(currentEffects, statType);

            var keyPoint = keyPoints.Last();

            if (currentTypeEffect != null)
            {
                // Эффект уже существует. Изменим его уровень.
                if (stat.Value <= keyPoint.Value)
                {
                    currentTypeEffect.Level = keyPoint.Level;
                }
                else
                {
                    if (keyPoint.Level == SurvivalStatHazardLevel.Lesser)
                    {
                        currentEffects.Remove(currentTypeEffect);
                    }
                    else
                    {
                        switch (keyPoint.Level)
                        {
                        case SurvivalStatHazardLevel.Strong:
                            currentTypeEffect.Level = SurvivalStatHazardLevel.Lesser;
                            break;

                        case SurvivalStatHazardLevel.Max:
                            currentTypeEffect.Level = SurvivalStatHazardLevel.Strong;
                            break;

                        case SurvivalStatHazardLevel.Undefined:
                            throw new NotSupportedException();

                        case SurvivalStatHazardLevel.Lesser:
                            throw new NotSupportedException();

                        default:
                            throw new InvalidOperationException("Уровень эффекта, который не обрабатывается.");
                        }
                    }
                }
            }
            else
            {
                // Создаём эффект
                var newCurrentTypeEffect = new SurvivalStatHazardEffect(statType,
                                                                        keyPoint.Level,
                                                                        survivalRandomSource);

                currentEffects.Add(newCurrentTypeEffect);
            }
        }
Example #4
0
        public void UpdateSurvivalEffect_HasLesserEffectAndValueMoreThatKetValue_HasNoEffect()
        {
            //ARRANGE

            var currentEffects = new EffectCollection();

            var testedEffect = new SurvivalStatHazardEffect(SurvivalStatType.Satiety, SurvivalStatHazardLevel.Lesser);

            currentEffects.Add(testedEffect);

            var stat = new SurvivalStat(1)
            {
                Type      = SurvivalStatType.Satiety,
                KeyPoints = new[] {
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Lesser,
                        Value = 0
                    }
                }
            };



            // ACT
            PersonEffectHelper.UpdateSurvivalEffect(currentEffects, stat, stat.KeyPoints[0]);



            // ASSERT
            var factEffect = currentEffects.Items.OfType <SurvivalStatHazardEffect>()
                             .SingleOrDefault(x => x.Type == SurvivalStatType.Satiety);

            factEffect.Should().BeNull();
        }
Example #5
0
        public void GivenАктёрИмеетЭффектStartEffect(string startEffect)
        {
            var actor = _context.GetActiveActor();

            GetEffectStatAndLevelByName(startEffect,
                                        out SurvivalStatType stat,
                                        out SurvivalStatHazardLevel level);

            var effect = new SurvivalStatHazardEffect(stat, level);

            actor.Person.Effects.Add(effect);
        }
Example #6
0
        /// <summary>
        /// Обновление эффекта модуля выживания.
        /// </summary>
        /// <param name="currentEffects"> Текущий список эффектов. </param>
        /// <param name="stat"> Характеристика, на которую влияет эффект. </param>
        /// <param name="keySegments">
        /// Ключевые сегменты, которые были пересечены при изменении характеристики.
        /// <param name="survivalRandomSource"> Источник рандома выживания. </param>
        public static void UpdateSurvivalEffect(
            [NotNull] IEffectsModule currentEffects,
            [NotNull] SurvivalStat stat,
            [NotNull][ItemNotNull] SurvivalStatKeySegment[] keySegments,
            [NotNull] ISurvivalRandomSource survivalRandomSource,
            [NotNull] IPlayerEventLogService playerEventLogService)
        {
            ThrowExceptionIfArgumentsInvalid(currentEffects, stat, keySegments, survivalRandomSource);

            // Эффект выставляем на основе текущего ключевого сегмента, в которое попадает значение характеристики выживания.
            // Если текущее значение не попадает ни в один сегмент, то эффект сбрасывается.

            var currentSegments = keySegments.CalcIntersectedSegments(stat.ValueShare);

            // Если попадаем на стык с двумя сегментами, просто берём первый.
            // Иногда это будет давать более сильный штрафной эффект,
            // но пока не понятно, как по другому сделать отрезки.
            var currentSegment = currentSegments.FirstOrDefault();

            var statType          = stat.Type;
            var currentTypeEffect = GetCurrentEffect(currentEffects, statType);

            if (currentTypeEffect != null)
            {
                // Эффект уже существует. Изменим его уровень.
                // Или удалим, если текущее значение не попадает ни в один из сегментов.
                if (currentSegment == null)
                {
                    currentEffects.Remove(currentTypeEffect);
                }
                else
                {
                    currentTypeEffect.Level = currentSegment.Level;
                }
            }
            else
            {
                if (currentSegment != null)
                {
                    // Создаём эффект
                    var newEffect = new SurvivalStatHazardEffect(
                        statType,
                        currentSegment.Level,
                        survivalRandomSource)
                    {
                        PlayerEventLogService = playerEventLogService
                    };

                    currentEffects.Add(newEffect);
                }
            }
        }
        public void GivenАктёрИмеетЭффектStartEffect(string startEffect)
        {
            var survivalRandomSource = Context.Container.GetInstance <ISurvivalRandomSource>();

            var actor = Context.GetActiveActor();

            GetEffectStatAndLevelByName(startEffect,
                                        out SurvivalStatType stat,
                                        out SurvivalStatHazardLevel level);

            var effect = new SurvivalStatHazardEffect(stat, level, survivalRandomSource);

            actor.Person.Effects.Add(effect);
        }
Example #8
0
        public void GivenАктёрИмеетЭффектStartEffect(string startEffect)
        {
            var survivalRandomSource = Context.ServiceProvider.GetRequiredService <ISurvivalRandomSource>();

            var actor = Context.GetActiveActor();

            GetEffectStatAndLevelByName(startEffect,
                                        out SurvivalStatType stat,
                                        out SurvivalStatHazardLevel level);

            var effect = new SurvivalStatHazardEffect(stat, level, survivalRandomSource);

            actor.Person.GetModule <IEffectsModule>().Add(effect);
        }
Example #9
0
        /// <summary>
        /// Обновление эффекта модуля выживания.
        /// </summary>
        /// <param name="currentEffects"> Текущий список эффектов. </param>
        /// <param name="stat"> Характеристика, на которую влияет эффект. </param>
        /// <param name="keyPoint"> Ключевая точка, которую учавствует в изменении характеристики. </param>
        public static void UpdateSurvivalEffect(EffectCollection currentEffects,
                                                SurvivalStat stat,
                                                SurvivalStatKeyPoint keyPoint)
        {
            var statType = stat.Type;

            var currentTypeEffect = currentEffects.Items.OfType <SurvivalStatHazardEffect>()
                                    .SingleOrDefault(x => x.Type == statType);

            // Эффект уже существует.
            // Изменим его тип.
            if (currentTypeEffect != null)
            {
                if (stat.Value <= keyPoint.Value)
                {
                    currentTypeEffect.Level = keyPoint.Level;
                }
                else
                {
                    if (keyPoint.Level == SurvivalStatHazardLevel.Lesser)
                    {
                        currentEffects.Remove(currentTypeEffect);
                    }
                    else
                    {
                        switch (keyPoint.Level)
                        {
                        case SurvivalStatHazardLevel.Strong:
                            currentTypeEffect.Level = SurvivalStatHazardLevel.Lesser;
                            break;

                        case SurvivalStatHazardLevel.Max:
                            currentTypeEffect.Level = SurvivalStatHazardLevel.Strong;
                            break;

                        default:
                            throw new InvalidOperationException("Уровень эффекта, который не обрабатывается.");
                        }
                    }
                }
            }
            else
            {
                currentTypeEffect = new SurvivalStatHazardEffect(statType, keyPoint.Level);
                currentEffects.Add(currentTypeEffect);
            }
        }
        public void UpdateSurvivalEffect_HasMaxEffectAndValueMoreThatKeyValue_HasStrongEffect()
        {
            //ARRANGE

            const SurvivalStatType expectedSurvivalHazardType = SurvivalStatType.Satiety;

            var survivalRandomSource = CreateMaxRollsRandomSource();

            var currentEffects = new EffectCollection();

            var testedEffect = new SurvivalStatHazardEffect(expectedSurvivalHazardType,
                                                            SurvivalStatHazardLevel.Strong,
                                                            survivalRandomSource);

            currentEffects.Add(testedEffect);

            var stat = new SurvivalStat(-5, -10, 10)
            {
                Type      = expectedSurvivalHazardType,
                KeyPoints = new[] {
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Lesser, 5),
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Strong, 0),
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Max, -10)
                }
            };



            // ACT
            PersonEffectHelper.UpdateSurvivalEffect(currentEffects,
                                                    stat,
                                                    new[] { stat.KeyPoints[2] },
                                                    survivalRandomSource);



            // ASSERT
            var factEffect = currentEffects.Items
                             .OfType <SurvivalStatHazardEffect>()
                             .Single(x => x.Type == expectedSurvivalHazardType);

            factEffect.Level.Should().Be(SurvivalStatHazardLevel.Strong);
        }
Example #11
0
        public void UpdateSurvivalEffect_HasStrongEffectAndValueMoreThatKetValue_HasLesserEffect()
        {
            //ARRANGE

            const SurvivalStatType expectedSurvivalHazardType = SurvivalStatType.Satiety;

            var currentEffects = new EffectCollection();

            var testedEffect = new SurvivalStatHazardEffect(expectedSurvivalHazardType, SurvivalStatHazardLevel.Lesser);

            currentEffects.Add(testedEffect);

            var stat = new SurvivalStat(-5)
            {
                Type      = expectedSurvivalHazardType,
                KeyPoints = new[] {
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Lesser,
                        Value = 0
                    },
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Strong,
                        Value = -10
                    }
                }
            };



            // ACT
            PersonEffectHelper.UpdateSurvivalEffect(currentEffects, stat, stat.KeyPoints[1]);



            // ASSERT
            var factEffect = currentEffects.Items
                             .OfType <SurvivalStatHazardEffect>()
                             .Single(x => x.Type == expectedSurvivalHazardType);

            factEffect.Level.Should().Be(SurvivalStatHazardLevel.Lesser);
        }