Пример #1
0
        private static string GetStatHazardConditionTypeClientString(SurvivalStatType type)
        {
            switch (type)
            {
            case SurvivalStatType.Health:
                return("Wound");

            case SurvivalStatType.Satiety:
                return("Hunger");

            case SurvivalStatType.Hydration:
                return("Thrist");

            case SurvivalStatType.Intoxication:
                return("Intoxication");

            case SurvivalStatType.Undefined:
                Debug.Fail("Undefined condition.");
                return("Empty");

            default:
                Debug.Fail($"Unknown condition type {type}.");
                return("Empty");
            }
        }
Пример #2
0
 private static SurvivalStatHazardCondition GetCurrentСondition(IConditionsModule сonditionModule,
                                                                SurvivalStatType statType)
 {
     return(сonditionModule.Items
            .OfType <SurvivalStatHazardCondition>()
            .SingleOrDefault(x => x.Type == statType));
 }
Пример #3
0
 public void Init(SurvivalStatType type, SurvivalStatHazardLevel level)
 {
     Type  = type;
     Level = level;
     SelectIcon(type);
     HighlightLevel(level);
 }
Пример #4
0
 private static SurvivalStatHazardEffect GetCurrentEffect(IEffectsModule currentEffects,
                                                          SurvivalStatType statType)
 {
     return(currentEffects.Items
            .OfType <SurvivalStatHazardEffect>()
            .SingleOrDefault(x => x.Type == statType));
 }
Пример #5
0
        private void DecreaseSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (level)
            {
            case PersonRuleLevel.Lesser:
                Person.Survival.DecreaseStat(statType,
                                             PropMetrics.SurvivalLesserRestoreValue - 1);
                break;

            case PersonRuleLevel.Normal:
                Person.Survival.DecreaseStat(statType,
                                             PropMetrics.SurvivalNormalRestoreValue - 1);
                break;

            case PersonRuleLevel.Grand:
                Person.Survival.DecreaseStat(statType,
                                             PropMetrics.SurvivalGrandRestoreValue - 1);
                break;

            case PersonRuleLevel.None:
                throw new NotSupportedException();

            case PersonRuleLevel.Absolute:
                throw new NotSupportedException();

            default:
                throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
            }
        }
Пример #6
0
        public SurvivalStatHazardEffect(SurvivalStatType type, SurvivalStatHazardLevel level)
        {
            Type  = type;
            Level = level;

            Rules = CalcRules();
        }
Пример #7
0
        /// <summary>
        /// Помещает в список бонус на ХП.
        /// </summary>
        /// <param name="level"> Уровень бонуса. </param>
        /// <param name="direction"> Направление бонуса. </param>
        /// <param name="bonuses">
        /// Аккумулирующий список бонусов.
        /// Отмечен ref, чтобы показать, что изменяется внутри метода.
        /// </param>
        private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction,
                                   ref List <SurvivalStatBonus> bonuses)
        {
            const SurvivalStatType HP_STAT_TYPE = SurvivalStatType.Health;
            var hpStat = Stats.SingleOrDefault(x => x.Type == HP_STAT_TYPE);

            if (hpStat != null)
            {
                var bonus = 0;
                bonus = GetBonusByLevel(level);

                if (direction == PersonRuleDirection.Negative)
                {
                    bonus *= -1;
                }

                var currentBonus = bonuses.SingleOrDefault(x => x.SurvivalStatType == HP_STAT_TYPE);
                if (currentBonus == null)
                {
                    currentBonus = new SurvivalStatBonus(HP_STAT_TYPE);
                    bonuses.Add(currentBonus);
                }

                currentBonus.ValueBonus += bonus;
            }
        }
Пример #8
0
        private static SurvivalStat CreateStat(
            SurvivalStatType type,
            PersonSurvivalStatType schemeStatType,
            IPersonSurvivalStatSubScheme[] survivalStats)
        {
            var statScheme = survivalStats.SingleOrDefault(x => x.Type == schemeStatType);

            if (statScheme is null)
            {
                return(null);
            }

            var keySegmentList = new List <SurvivalStatKeySegment>();

            if (statScheme.KeyPoints != null)
            {
                AddKeyPointFromScheme(SurvivalStatHazardLevel.Max, PersonSurvivalStatKeypointLevel.Max, statScheme.KeyPoints, keySegmentList);
                AddKeyPointFromScheme(SurvivalStatHazardLevel.Strong, PersonSurvivalStatKeypointLevel.Strong, statScheme.KeyPoints, keySegmentList);
                AddKeyPointFromScheme(SurvivalStatHazardLevel.Lesser, PersonSurvivalStatKeypointLevel.Lesser, statScheme.KeyPoints, keySegmentList);
            }

            var stat = new SurvivalStat(statScheme.StartValue, statScheme.MinValue, statScheme.MaxValue)
            {
                Type         = type,
                Rate         = 1,
                KeySegments  = keySegmentList.ToArray(),
                DownPassRoll = statScheme.DownPassRoll.GetValueOrDefault(SurvivalStat.DEFAULT_DOWN_PASS_VALUE)
            };

            return(stat);
        }
Пример #9
0
        private static SurvivalStat CreateStat(SurvivalStatType type)
        {
            var stat = new SurvivalStat(50)
            {
                Type      = type,
                Range     = new Range <int>(-100, 100),
                Rate      = 1,
                KeyPoints = new[] {
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Lesser,
                        Value = 0
                    },
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Strong,
                        Value = -25
                    },
                    new SurvivalStatKeyPoint {
                        Level = SurvivalStatHazardLevel.Max,
                        Value = -50
                    }
                }
            };

            return(stat);
        }
Пример #10
0
        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);
        }
Пример #11
0
        public int Update_ModifiedDownPass_StatDownCorrectly(int statDownPass, int downPassRoll)
        {
            // ARRANGE

            const int STAT_RATE              = 1;
            const int MIN_STAT_VALUE         = 0;
            const int MAX_STAT_VALUE         = 1;
            const int START_STAT_VALUE       = MAX_STAT_VALUE;
            const SurvivalStatType STAT_TYPE = SurvivalStatType.Satiety;

            var survivalRandomSourceMock = new Mock <ISurvivalRandomSource>();

            survivalRandomSourceMock.Setup(x => x.RollSurvival(It.IsAny <SurvivalStat>()))
            .Returns(downPassRoll);
            var survivalRandomSource = survivalRandomSourceMock.Object;

            var survivalStats = new[]
            {
                new SurvivalStat(START_STAT_VALUE, MIN_STAT_VALUE, MAX_STAT_VALUE)
                {
                    Type         = STAT_TYPE,
                    Rate         = STAT_RATE,
                    DownPassRoll = statDownPass
                }
            };

            var survivalData = new HumanSurvivalModule(survivalStats, survivalRandomSource);

            // ACT
            survivalData.Update();

            // ASSERT
            return(survivalStats[0].Value);
        }
Пример #12
0
        private static SurvivalStat CreateStatFromScheme(IPersonSurvivalStatSubScheme[] survivalStats,
                                                         SurvivalStatType statType,
                                                         PersonSurvivalStatType schemeStatType)
        {
            var stat = CreateStat(statType, schemeStatType, survivalStats);

            return(stat ?? null);
        }
        public void Update_StatNearKeyPoint_RaiseEventWithCorrectValues()
        {
            // ARRANGE
            const SurvivalStatType STAT_TYPE = SurvivalStatType.Satiety;

            const int MIN_STAT_VALUE   = 0;
            const int MAX_STAT_VALUE   = 1;
            const int START_STAT_VALUE = MAX_STAT_VALUE;

            const int LESSER_SURVIVAL_STAT_KEYPOINT = 0;
            const SurvivalStatHazardLevel LESSER_SURVIVAL_STAT_KEYPOINT_TYPE = SurvivalStatHazardLevel.Lesser;

            const int STAT_RATE = 1;

            const int EXPECTED_SURVIVAL_STAT_KEYPOINT = LESSER_SURVIVAL_STAT_KEYPOINT;

            const int FAKE_ROLL_SURVIVAL_RESULT = 6;

            var survivalRandomSourceMock = new Mock <ISurvivalRandomSource>();

            survivalRandomSourceMock.Setup(x => x.RollSurvival(It.IsAny <SurvivalStat>()))
            .Returns(FAKE_ROLL_SURVIVAL_RESULT);
            var survivalRandomSource = survivalRandomSourceMock.Object;

            var survivalStats = new SurvivalStat[] {
                new SurvivalStat(START_STAT_VALUE, MIN_STAT_VALUE, MAX_STAT_VALUE)
                {
                    Type      = STAT_TYPE,
                    Rate      = STAT_RATE,
                    KeyPoints = new[] {
                        new SurvivalStatKeyPoint(
                            LESSER_SURVIVAL_STAT_KEYPOINT_TYPE,
                            LESSER_SURVIVAL_STAT_KEYPOINT)
                    }
                }
            };

            var survivalData = new HumanSurvivalData(_personScheme,
                                                     survivalStats,
                                                     survivalRandomSource);



            // ACT
            using (var monitor = survivalData.Monitor())
            {
                survivalData.Update();



                // ASSERT
                monitor.Should().Raise(nameof(ISurvivalData.StatCrossKeyValue))
                .WithArgs <SurvivalStatChangedEventArgs>(args =>
                                                         args.Stat.Type == STAT_TYPE &&
                                                         args.KeyPoints.FirstOrDefault().Level == LESSER_SURVIVAL_STAT_KEYPOINT_TYPE &&
                                                         args.KeyPoints.FirstOrDefault().Value == EXPECTED_SURVIVAL_STAT_KEYPOINT);
            }
        }
Пример #14
0
        public void RestoreStat(SurvivalStatType type, int value)
        {
            var stat = Stats.SingleOrDefault(x => x.Type == type);

            if (stat != null)
            {
                ChangeStatInner(stat, value);
            }
        }
        /// <summary>Форсированно установить запас здоровья.</summary>
        /// <param name="type">Тип характеритсики, которая будет произведено влияние.</param>
        /// <param name="value">Целевое значение запаса характеристики.</param>
        public void SetStatForce(SurvivalStatType type, int value)
        {
            var stat = Stats.SingleOrDefault(x => x.Type == type);

            if (stat != null)
            {
                stat.Value = value;
            }
        }
        /// <summary>Снижение характеристики.</summary>
        /// <param name="type">Тип характеритсики, которая будет произведено влияние.</param>
        /// <param name="value">Значение, на которое снижается текущий запас.</param>
        public void DecreaseStat(SurvivalStatType type, int value)
        {
            ValidateStatChangeValue(value);

            var stat = Stats.SingleOrDefault(x => x.Type == type);

            if (stat != null)
            {
                ChangeStatInner(stat, -value);
            }
        }
Пример #17
0
        private static SurvivalStat CreateUselessStat(SurvivalStatType statType)
        {
            var stat = new SurvivalStat(100, 0, 100)
            {
                Type         = statType,
                Rate         = 1,
                DownPassRoll = 0
            };

            return(stat);
        }
        public SurvivalStatHazardEffect(SurvivalStatType type,
                                        SurvivalStatHazardLevel level,
                                        [NotNull] ISurvivalRandomSource survivalRandomSource)
        {
            Type  = type;
            Level = level;

            _survivalRandomSource = survivalRandomSource ?? throw new ArgumentNullException(nameof(survivalRandomSource));

            _rules = CalcRules();
        }
Пример #19
0
        /// <summary>Форсированно установить запас здоровья.</summary>
        /// <param name="type">Тип характеритсики, которая будет произведено влияние.</param>
        /// <param name="value">Целевое значение запаса характеристики.</param>
        public void SetStatForce(SurvivalStatType type, int value)
        {
            var stat = Stats.SingleOrDefault(x => x.Type == type);

            if (stat != null)
            {
                stat.Value = value;

                ProcessIfHealth(stat, valueDiff: 0);
                ProcessIfWound(stat);
            }
        }
Пример #20
0
        private Texture2D GetStatHazardConditionTypeClient(SurvivalStatType type)
        {
            if (_survivalStatConditionIcons is null)
            {
                throw new InvalidOperationException("Survival condition icons is not loaded.");
            }

            if (!_survivalStatConditionIcons.TryGetValue(type, out var iconTexture))
            {
                Debug.Fail("Every stat must has its own icon.");
            }

            return(iconTexture);
        }
Пример #21
0
        /// <summary>Пополнение запаса характеристики.</summary>
        /// <param name="type">Тип характеритсики, которая будет произведено влияние.</param>
        /// <param name="value">Значение, на которое восстанавливается текущий запас.</param>
        public void RestoreStat(SurvivalStatType type, int value)
        {
            ValidateStatChangeValue(value);

            var stat = Stats.SingleOrDefault(x => x.Type == type);

            if (stat != null)
            {
                if (stat.Value < stat.Range.Max)
                {
                    ChangeStatInner(stat, value);
                }
            }
        }
Пример #22
0
        /// <summary>
        /// Помещает в список бонус на ХП.
        /// </summary>
        /// <param name="level"> Уровень бонуса. </param>
        /// <param name="direction"> Направление бонуса. </param>
        /// <param name="bonuses">
        /// Аккумулирующий список бонусов.
        /// Отмечен ref, чтобы показать, что изменяется внутри метода.
        /// </param>
        private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction,
                                   ref List <SurvivalStatBonus> bonuses)
        {
            const SurvivalStatType HP_STAT_TYPE = SurvivalStatType.Health;
            var hpStat = Stats.SingleOrDefault(x => x.Type == HP_STAT_TYPE);

            if (hpStat != null)
            {
                var bonus = 0;
                switch (level)
                {
                case PersonRuleLevel.Lesser:
                    bonus = 1;
                    break;

                case PersonRuleLevel.Normal:
                    bonus = 3;
                    break;

                case PersonRuleLevel.Grand:
                    bonus = 5;
                    break;

                case PersonRuleLevel.Absolute:
                    bonus = 10;
                    break;

                case PersonRuleLevel.None:
                    throw new InvalidOperationException("Неопределённое правило.");

                default:
                    throw new InvalidOperationException($"Правило {level} не обрабатывается.");
                }

                if (direction == PersonRuleDirection.Negative)
                {
                    bonus *= -1;
                }

                var currentBonus = bonuses.SingleOrDefault(x => x.SurvivalStatType == HP_STAT_TYPE);
                if (currentBonus == null)
                {
                    currentBonus = new SurvivalStatBonus(HP_STAT_TYPE);
                    bonuses.Add(currentBonus);
                }

                currentBonus.ValueBonus += bonus;
            }
        }
        private static SurvivalStat CreateStat(SurvivalStatType type)
        {
            var stat = new SurvivalStat(START_SURVIVAL_STAT, MIN_SURVIVAL_STAT, MAX_SURVIVAL_STAT)
            {
                Type      = type,
                Rate      = 1,
                KeyPoints = new[] {
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Max, MAX_SURVIVAL_STAT_KEYPOINT),
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Strong, STRONG_SURVIVAL_STAT_KEYPOINT),
                    new SurvivalStatKeyPoint(SurvivalStatHazardLevel.Lesser, LESSER_SURVIVAL_STAT_KEYPOINT)
                }
            };

            return(stat);
        }
Пример #24
0
        private void DecreaseStat(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (statType)
            {
            case SurvivalStatType.Satiety:
            case SurvivalStatType.Hydration:
            case SurvivalStatType.Intoxication:
                DecreaseSurvivalStatInner(statType, level);
                break;

            case SurvivalStatType.Health:
                DecreaseHp(level);
                break;
            }
        }
Пример #25
0
    public void Init(SurvivalStatType type, SurvivalStatHazardLevel level)
    {
        var currentLanguage = _uiSettingService.CurrentLanguage;

        Type  = type;
        Level = level;
        SelectIcon(type);
        HighlightLevel(level);

        if (UiElementTooltip != null)
        {
            var effectText = GetEffectText(currentLanguage);
            UiElementTooltip.text = effectText;
        }
    }
Пример #26
0
    private void SelectIcon(SurvivalStatType type)
    {
        switch (type)
        {
        case SurvivalStatType.Satiety:
            EffectIcon.sprite = HungerSprite;
            break;

        case SurvivalStatType.Water:
            EffectIcon.sprite = ThristSprite;
            break;

        default:
            throw new InvalidOperationException();
        }
    }
Пример #27
0
        private void DecreaseStat(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (statType)
            {
            case SurvivalStatType.Satiety:
                DecreaseSurvivalStatInner(SurvivalStatType.Satiety, level);
                break;

            case SurvivalStatType.Water:
                DecreaseSurvivalStatInner(SurvivalStatType.Water, level);
                break;

            case SurvivalStatType.Health:
                DecreaseHp(level);
                break;
            }
        }
Пример #28
0
        private static bool CheckConditionWithMaxLevel(IActor actor, SurvivalStatType effectType)
        {
            var isRestricted = false;

            var сonditionModule = actor.Person.GetModuleSafe <IConditionsModule>();

            if (сonditionModule != null)
            {
                var searchingСondition = сonditionModule.Items.OfType <SurvivalStatHazardCondition>()
                                         .SingleOrDefault(x => x.Type == effectType && x.Level == SurvivalStatHazardLevel.Max);

                if (searchingСondition != null)
                {
                    isRestricted = true;
                }
            }

            return(isRestricted);
        }
Пример #29
0
        private static void GetEffectStatAndLevelByName(string effectName, out SurvivalStatType stat, out SurvivalStatHazardLevel level)
        {
            switch (effectName)
            {
            case "нет":
                level = SurvivalStatHazardLevel.Undefined;
                stat  = SurvivalStatType.Undefined;
                break;

            case "Слабый голод":
                level = SurvivalStatHazardLevel.Lesser;
                stat  = SurvivalStatType.Satiety;
                break;

            case "Голод":
                level = SurvivalStatHazardLevel.Strong;
                stat  = SurvivalStatType.Satiety;
                break;

            case "Голодание":
                level = SurvivalStatHazardLevel.Max;
                stat  = SurvivalStatType.Satiety;
                break;

            case "Слабая жажда":
                level = SurvivalStatHazardLevel.Lesser;
                stat  = SurvivalStatType.Water;
                break;

            case "Жажда":
                level = SurvivalStatHazardLevel.Strong;
                stat  = SurvivalStatType.Water;
                break;

            case "Обезвоживание":
                level = SurvivalStatHazardLevel.Max;
                stat  = SurvivalStatType.Water;
                break;

            default:
                throw new NotSupportedException("Неизветный тип ожидаемого эффекта.");
            }
        }
Пример #30
0
        private static void BonusToDownPass(
            SurvivalStatType statType,
            PersonRuleLevel level,
            PersonRuleDirection direction,
            ref List <SurvivalStatBonus> bonuses)
        {
            var currentBonusValue = 0;
            var directionQuaff    = direction == PersonRuleDirection.Negative ? -1 : 1;

            switch (level)
            {
            case PersonRuleLevel.Lesser:
                currentBonusValue = 1 * directionQuaff;
                break;

            case PersonRuleLevel.Normal:
                currentBonusValue = 2 * directionQuaff;
                break;

            case PersonRuleLevel.Grand:
                currentBonusValue = 5 * directionQuaff;
                break;

            case PersonRuleLevel.Absolute:
                currentBonusValue = 10 * directionQuaff;
                break;

            case PersonRuleLevel.None:
                Debug.Fail("Предположительно, это ошибка.");
                break;

            default:
                Debug.Fail("Предположительно, это ошибка.");
                break;
            }

            var currentBonus = new SurvivalStatBonus(statType)
            {
                DownPassBonus = currentBonusValue
            };

            bonuses.Add(currentBonus);
        }