602152824

Build Type

github

Committed by GitHub

Commit Message

Merge c0321fa06 into 1a67f178b

Pull Request Pull Request #1046: Add test to PerkHelper.ConvertLevelSubsToTotal

Run Details

2175 of 3422 branches covered (63.56%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 1 file covered. (100.0%)

31 existing lines in 7 files now uncovered.

5923 of 7648 relevant lines covered (77.45%)

47971.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.91

/Zilon.Core/Zilon.Core/PersonModules/CombatStatsModule.cs

﻿using System;
using System.Collections.Generic;
using System.Linq;

using Zilon.Core.Components;
using Zilon.Core.Persons;
using Zilon.Core.Schemes;

namespace Zilon.Core.PersonModules
{
    /// <summary>
    /// Базовая реализация набора навыков для боя.
    /// </summary>
    public sealed class CombatStatsModule : ICombatStatsModule
    {
        private readonly IEquipmentModule _equipmentModule;
        private readonly IEvolutionModule _evolutionModule;

        public CombatStatsModule(IEvolutionModule evolutionModule, IEquipmentModule equipmentModule)
        {
            DefenceStats = new PersonDefenceStats(Array.Empty<PersonDefenceItem>(), Array.Empty<PersonArmorItem>());
            IsActive = true;

            _evolutionModule = evolutionModule ?? throw new ArgumentNullException(nameof(evolutionModule));
            _equipmentModule = equipmentModule ?? throw new ArgumentNullException(nameof(equipmentModule));

            _equipmentModule.EquipmentChanged += EquipmentModule_EquipmentChanged;
        }

        private static void AddStatToDict(Dictionary<SkillStatType, float> bonusDict,
            SkillStatType targetStatType,
            PersonRuleLevel level,
            PersonRuleDirection direction)
        {
            bonusDict.TryGetValue(targetStatType, out float value);

            float q;
            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    q = 0.1f;
                    break;

                case PersonRuleLevel.Normal:
                    q = 0.3f;
                    break;

                case PersonRuleLevel.Grand:
                    q = 0.5f;
                    break;

                case PersonRuleLevel.None:
                    throw new NotSupportedException();

                case PersonRuleLevel.Absolute:
                    throw new NotSupportedException();

                default:
                    throw new NotSupportedException($"Неизветный уровень угрозы выживания {level}.");
            }

            switch (direction)
            {
                case PersonRuleDirection.Positive:
                    // Бонус изначально расчитывается, как положительный. Ничего не делаем.
                    break;
                case PersonRuleDirection.Negative:
                    q *= -1;
                    break;

                default:
                    throw new NotSupportedException($"Неизветный уровень угрозы выживания {direction}.");
            }

            value += q;

            bonusDict[targetStatType] = value;
        }

        /// <summary>
        /// Применение бонуса к характеристике навыка.
        /// </summary>
        /// <param name="bonusValue"> Величина бонуса. </param>
        /// <param name="stat"> Характеристика навыка. </param>
        private static void ApplyBonusToStat(float bonusValue, SkillStatItem stat)
        {
            stat.Value += stat.Value * bonusValue;

            if (stat.Value <= 1)
            {
                stat.Value = 1;
            }
        }

        private void CalcCombatStats()
        {
            var bonusDict = new Dictionary<SkillStatType, float>();

            if (_evolutionModule.Perks != null)
            {
                CalcPerkBonuses(bonusDict);
            }

            if (_evolutionModule.Stats != null)
            {
                foreach (var bonusItem in bonusDict)
                {
                    var stat = _evolutionModule.Stats.SingleOrDefault(x => x.Stat == bonusItem.Key);
                    if (stat != null)
                    {
                        ApplyBonusToStat(bonusItem.Value, stat);
                    }
                }

                foreach (var statItem in _evolutionModule.Stats)
                {
                    statItem.Value = (float)Math.Round(statItem.Value, 1);
                }
            }

            RecalculatePersonArmor();
        }

        /// <summary>
        /// Расчёт бонусов, которые дают перки.
        /// </summary>
        /// <param name="bonusDict"> Текущее состояние бонусов. </param>
        private void CalcPerkBonuses(Dictionary<SkillStatType, float> bonusDict)
        {
            var archievedPerks = _evolutionModule.GetArchievedPerks();
            foreach (var archievedPerk in archievedPerks)
            {
                PerkLevel currentLevel = archievedPerk.CurrentLevel;

                if (archievedPerk.Scheme.IsBuildIn)
                {
                    if (archievedPerk.Scheme.Levels is null)
                    {
                        continue;
                    }

                    currentLevel = new PerkLevel(1, 1);
                }

                var currentLevelScheme = archievedPerk.Scheme.Levels[currentLevel.Primary - 1];

                if (currentLevelScheme.Rules == null)
                {
                    continue;
                }

                for (var i = 1; i <= currentLevel.Sub; i++)
                {
                    foreach (var rule in currentLevelScheme.Rules)
                    {
                        CalcRuleBonuses(rule, bonusDict);
                    }
                }
            }
        }

        /// <summary>
        /// Расчёт бонуса, который даёт правило перка.
        /// </summary>
        /// <param name="rule"> Правило перка. </param>
        /// <param name="bonusDict"> Текущее состояние бонусов. </param>
        private static void CalcRuleBonuses(PerkRuleSubScheme rule, Dictionary<SkillStatType, float> bonusDict)
        {
            switch (rule.Type)
            {
                case PersonRuleType.Melee:
                    AddStatToDict(bonusDict, SkillStatType.Melee, rule.Level, PersonRuleDirection.Positive);
                    break;

                case PersonRuleType.Ballistic:
                    AddStatToDict(bonusDict, SkillStatType.Ballistic, rule.Level, PersonRuleDirection.Positive);
                    break;

                case PersonRuleType.Health:
                case PersonRuleType.Damage:
                case PersonRuleType.ToHit:
                case PersonRuleType.HealthIfNoBody:
                case PersonRuleType.HungerResistance:
                case PersonRuleType.ThristResistance:
                    // This perk rule is not impact to combat stats.
                    break;

                case PersonRuleType.Undefined:
                    throw new InvalidOperationException("Undefined rule");

                default:
                    throw new InvalidOperationException($"Rule {rule.Type} unknown");
            }
        }

        private void EquipmentModule_EquipmentChanged(object sender, EquipmentChangedEventArgs e)
        {
            CalcCombatStats();
        }

        private static int GetArmorModifierByLevel(PersonRuleLevel level)
        {
            switch (level)
            {
                case PersonRuleLevel.None:
                    return 0;

                case PersonRuleLevel.Lesser:
                    return 1;

                case PersonRuleLevel.Normal:
                    return 2;

                case PersonRuleLevel.Grand:
                    return 3;

                case PersonRuleLevel.Absolute:
                    return 5;

                default:
                    throw new ArgumentException($"Неизвестное значение уровня {level}.", nameof(level));
            }
        }

        private static IEnumerable<PersonArmorItem> GetEquipmentArmors(IEnumerable<IPropArmorItemSubScheme> armors)
        {
            foreach (var propArmor in armors)
            {
                var personArmorItem = new PersonArmorItem(propArmor.Impact,
                    propArmor.AbsorbtionLevel,
                    propArmor.ArmorRank);

                yield return personArmorItem;
            }
        }

        private static int GetLevelDiff(PersonRuleLevel level, PersonRuleLevel baseLevel)
        {
            var a = GetArmorModifierByLevel(level);
            var b = GetArmorModifierByLevel(baseLevel);
            return a - b;
        }

        private static IEnumerable<PersonArmorItem> MergeArmor(IEnumerable<PersonArmorItem> equipmentArmors)
        {
            var armorGroups = equipmentArmors.GroupBy(x => x.Impact).OrderBy(x => x.Key);

            foreach (var armorGroup in armorGroups)
            {
                var orderedArmors = from armor in armorGroup
                                    orderby armor.AbsorbtionLevel, armor.ArmorRank
                                    select armor;

                float? rankRaw = null;
                PersonRuleLevel? armorLevel = null;
                var minInited = false;
                foreach (var armor in orderedArmors)
                {
                    //т.к. вся броня упорядочена от худшей
                    // первым будет обработан элемент с худшими показателями
                    if (!minInited)
                    {
                        minInited = true;
                        rankRaw = armor.ArmorRank;
                        armorLevel = armor.AbsorbtionLevel;
                    }
                    else
                    {
                        rankRaw += armor.ArmorRank * 0.5f;

                        var levelDiff = GetLevelDiff(armor.AbsorbtionLevel, armorLevel.Value);
                        if (levelDiff > 0)
                        {
                            rankRaw += armor.ArmorRank * 0.33f * levelDiff;
                        }
                    }
                }

                if (rankRaw != null)
                {
                    var totalRankRaw = Math.Round(rankRaw.Value);

                    yield return new PersonArmorItem(armorGroup.Key,
                        armorLevel.Value,
                        (int)totalRankRaw);
                }
            }
        }

        /// <summary>
        /// Пересчёт показателей брони персонажа.
        /// </summary>
        private void RecalculatePersonArmor()
        {
            var equipmentModule = _equipmentModule;

            var equipmentArmors = new List<PersonArmorItem>();
            foreach (var equipment in equipmentModule)
            {
                if (equipment == null)
                {
                    continue;
                }

                var equipStats = equipment.Scheme.Equip;

                if (equipStats.Armors != null)
                {
                    var currentEquipmentArmors = GetEquipmentArmors(equipStats.Armors);
                    equipmentArmors.AddRange(currentEquipmentArmors);
                }
            }

            var mergedArmors = MergeArmor(equipmentArmors);

            DefenceStats.SetArmors(mergedArmors.ToArray());
        }

        /// <summary>
        /// Навыки обороны против наступательных действий.
        /// </summary>
        public IPersonDefenceStats DefenceStats { get; set; }

        /// <inheritdoc />
        public string Key => nameof(ICombatStatsModule);

        /// <inheritdoc />
        public bool IsActive { get; set; }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.Components;
6	using Zilon.Core.Persons;
7	using Zilon.Core.Schemes;
8
9	namespace Zilon.Core.PersonModules
10	{
11	/// <summary>
12	/// Базовая реализация набора навыков для боя.
13	/// </summary>
14	public sealed class CombatStatsModule : ICombatStatsModule
15	{
16	private readonly IEquipmentModule _equipmentModule;
17	private readonly IEvolutionModule _evolutionModule;
18
19	public CombatStatsModule(IEvolutionModule evolutionModule, IEquipmentModule equipmentModule)	71✔
20	{
21	DefenceStats = new PersonDefenceStats(Array.Empty<PersonDefenceItem>(), Array.Empty<PersonArmorItem>());	71✔
22	IsActive = true;	71✔
23
24	_evolutionModule = evolutionModule ?? throw new ArgumentNullException(nameof(evolutionModule));	71!
25	_equipmentModule = equipmentModule ?? throw new ArgumentNullException(nameof(equipmentModule));	71!
26
27	_equipmentModule.EquipmentChanged += EquipmentModule_EquipmentChanged;	71✔
28	}	71✔
29
30	private static void AddStatToDict(Dictionary<SkillStatType, float> bonusDict,
31	SkillStatType targetStatType,
32	PersonRuleLevel level,
33	PersonRuleDirection direction)
34	{
35	bonusDict.TryGetValue(targetStatType, out float value);	×
36
37	float q;
38	switch (level)
39	{
40	case PersonRuleLevel.Lesser:
41	q = 0.1f;	×
42	break;	×
43
44	case PersonRuleLevel.Normal:
45	q = 0.3f;	×
46	break;	×
47
48	case PersonRuleLevel.Grand:
49	q = 0.5f;	×
50	break;	×
51
52	case PersonRuleLevel.None:
53	throw new NotSupportedException();	×
54
55	case PersonRuleLevel.Absolute:
56	throw new NotSupportedException();	×
57
58	default:
59	throw new NotSupportedException($"Неизветный уровень угрозы выживания {level}.");	×
60	}
61
62	switch (direction)
63	{
64	case PersonRuleDirection.Positive:
65	// Бонус изначально расчитывается, как положительный. Ничего не делаем.
66	break;
67	case PersonRuleDirection.Negative:
68	q *= -1;	×
69	break;	×
70
71	default:
72	throw new NotSupportedException($"Неизветный уровень угрозы выживания {direction}.");	×
73	}
74
75	value += q;	×
76
77	bonusDict[targetStatType] = value;	×
78	}	×
79
80	/// <summary>
81	/// Применение бонуса к характеристике навыка.
82	/// </summary>
83	/// <param name="bonusValue"> Величина бонуса. </param>
84	/// <param name="stat"> Характеристика навыка. </param>
85	private static void ApplyBonusToStat(float bonusValue, SkillStatItem stat)
86	{
87	stat.Value += stat.Value * bonusValue;	×
88
89	if (stat.Value <= 1)	×
90	{
91	stat.Value = 1;	×
92	}
93	}	×
94
95	private void CalcCombatStats()
96	{
97	var bonusDict = new Dictionary<SkillStatType, float>();	60✔
98
99	if (_evolutionModule.Perks != null)	60✔
100	{
101	CalcPerkBonuses(bonusDict);	60✔
102	}
103
104	if (_evolutionModule.Stats != null)	60✔
105	{
106	foreach (var bonusItem in bonusDict)	120!
107	{
108	var stat = _evolutionModule.Stats.SingleOrDefault(x => x.Stat == bonusItem.Key);	×
109	if (stat != null)	×
110	{
111	ApplyBonusToStat(bonusItem.Value, stat);	×
112	}
113	}
114
115	foreach (var statItem in _evolutionModule.Stats)	360✔
116	{
117	statItem.Value = (float)Math.Round(statItem.Value, 1);	120✔
118	}
119	}
120
121	RecalculatePersonArmor();	60✔
122	}	60✔
123
124	/// <summary>
125	/// Расчёт бонусов, которые дают перки.
126	/// </summary>
127	/// <param name="bonusDict"> Текущее состояние бонусов. </param>
128	private void CalcPerkBonuses(Dictionary<SkillStatType, float> bonusDict)
129	{
130	var archievedPerks = _evolutionModule.GetArchievedPerks();	60✔
131	foreach (var archievedPerk in archievedPerks)	120!
132	{
UNCOV 133	PerkLevel currentLevel = archievedPerk.CurrentLevel;	×
134
UNCOV 135	if (archievedPerk.Scheme.IsBuildIn)	×
136	{
UNCOV 137	if (archievedPerk.Scheme.Levels is null)	×
138	{
139	continue;
140	}
141
UNCOV 142	currentLevel = new PerkLevel(1, 1);	×
143	}
144
UNCOV 145	var currentLevelScheme = archievedPerk.Scheme.Levels[currentLevel.Primary - 1];	×
146
UNCOV 147	if (currentLevelScheme.Rules == null)	×
148	{
149	continue;
150	}
151
UNCOV 152	for (var i = 1; i <= currentLevel.Sub; i++)	×
153	{
UNCOV 154	foreach (var rule in currentLevelScheme.Rules)	×
155	{
UNCOV 156	CalcRuleBonuses(rule, bonusDict);	×
157	}
158	}
159	}
160	}	60✔
161
162	/// <summary>
163	/// Расчёт бонуса, который даёт правило перка.
164	/// </summary>
165	/// <param name="rule"> Правило перка. </param>
166	/// <param name="bonusDict"> Текущее состояние бонусов. </param>
167	private static void CalcRuleBonuses(PerkRuleSubScheme rule, Dictionary<SkillStatType, float> bonusDict)
168	{
UNCOV 169	switch (rule.Type)	×
170	{
171	case PersonRuleType.Melee:
172	AddStatToDict(bonusDict, SkillStatType.Melee, rule.Level, PersonRuleDirection.Positive);	×
173	break;	×
174
175	case PersonRuleType.Ballistic:
176	AddStatToDict(bonusDict, SkillStatType.Ballistic, rule.Level, PersonRuleDirection.Positive);	×
177	break;	×
178
179	case PersonRuleType.Health:
180	case PersonRuleType.Damage:
181	case PersonRuleType.ToHit:
182	case PersonRuleType.HealthIfNoBody:
183	case PersonRuleType.HungerResistance:
184	case PersonRuleType.ThristResistance:
185	// This perk rule is not impact to combat stats.
186	break;
187
188	case PersonRuleType.Undefined:
189	throw new InvalidOperationException("Undefined rule");	×
190
191	default:
192	throw new InvalidOperationException($"Rule {rule.Type} unknown");	×
193	}
UNCOV 194	}	×
195
196	private void EquipmentModule_EquipmentChanged(object sender, EquipmentChangedEventArgs e)
197	{
198	CalcCombatStats();	60✔
199	}	60✔
200
201	private static int GetArmorModifierByLevel(PersonRuleLevel level)
202	{
203	switch (level)
204	{
205	case PersonRuleLevel.None:
206	return 0;	×
207
208	case PersonRuleLevel.Lesser:
209	return 1;	14✔
210
211	case PersonRuleLevel.Normal:
212	return 2;	14✔
213
214	case PersonRuleLevel.Grand:
215	return 3;	×
216
217	case PersonRuleLevel.Absolute:
218	return 5;	×
219
220	default:
221	throw new ArgumentException($"Неизвестное значение уровня {level}.", nameof(level));	×
222	}
223	}
224
225	private static IEnumerable<PersonArmorItem> GetEquipmentArmors(IEnumerable<IPropArmorItemSubScheme> armors)
226	{
227	foreach (var propArmor in armors)
228	{
229	var personArmorItem = new PersonArmorItem(propArmor.Impact,
230	propArmor.AbsorbtionLevel,
231	propArmor.ArmorRank);
232
233	yield return personArmorItem;
234	}
235	}
236
237	private static int GetLevelDiff(PersonRuleLevel level, PersonRuleLevel baseLevel)
238	{
239	var a = GetArmorModifierByLevel(level);	14✔
240	var b = GetArmorModifierByLevel(baseLevel);	14✔
241	return a - b;	14✔
242	}
243
244	private static IEnumerable<PersonArmorItem> MergeArmor(IEnumerable<PersonArmorItem> equipmentArmors)
245	{
246	var armorGroups = equipmentArmors.GroupBy(x => x.Impact).OrderBy(x => x.Key);
247
248	foreach (var armorGroup in armorGroups)
249	{
250	var orderedArmors = from armor in armorGroup
251	orderby armor.AbsorbtionLevel, armor.ArmorRank
252	select armor;
253
254	float? rankRaw = null;
255	PersonRuleLevel? armorLevel = null;
256	var minInited = false;
257	foreach (var armor in orderedArmors)
258	{
259	//т.к. вся броня упорядочена от худшей
260	// первым будет обработан элемент с худшими показателями
261	if (!minInited)
262	{
263	minInited = true;
264	rankRaw = armor.ArmorRank;
265	armorLevel = armor.AbsorbtionLevel;
266	}
267	else
268	{
269	rankRaw += armor.ArmorRank * 0.5f;
270
271	var levelDiff = GetLevelDiff(armor.AbsorbtionLevel, armorLevel.Value);
272	if (levelDiff > 0)
273	{
274	rankRaw += armor.ArmorRank * 0.33f * levelDiff;
275	}
276	}
277	}
278
279	if (rankRaw != null)
280	{
281	var totalRankRaw = Math.Round(rankRaw.Value);
282
283	yield return new PersonArmorItem(armorGroup.Key,
284	armorLevel.Value,
285	(int)totalRankRaw);
286	}
287	}
288	}
289
290	/// <summary>
291	/// Пересчёт показателей брони персонажа.
292	/// </summary>
293	private void RecalculatePersonArmor()
294	{
295	var equipmentModule = _equipmentModule;	60✔
296
297	var equipmentArmors = new List<PersonArmorItem>();	60✔
298	foreach (var equipment in equipmentModule)	960✔
299	{
300	if (equipment == null)	420✔
301	{
302	continue;
303	}
304
305	var equipStats = equipment.Scheme.Equip;	99✔
306
307	if (equipStats.Armors != null)	99✔
308	{
309	var currentEquipmentArmors = GetEquipmentArmors(equipStats.Armors);	41✔
310	equipmentArmors.AddRange(currentEquipmentArmors);	41✔
311	}
312	}
313
314	var mergedArmors = MergeArmor(equipmentArmors);	60✔
315
316	DefenceStats.SetArmors(mergedArmors.ToArray());	60✔
317	}	60✔
318
319	/// <summary>
320	/// Навыки обороны против наступательных действий.
321	/// </summary>
322	public IPersonDefenceStats DefenceStats { get; set; }
323
324	/// <inheritdoc />
325	public string Key => nameof(ICombatStatsModule);	71✔
326
327	/// <inheritdoc />
328	public bool IsActive { get; set; }
329	}
330	}

kreghek / Zilon_Roguelike / 602152824

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous