794716003

Build Type

github

Committed by GitHub

Commit Message

Merge f64077e7e into 0ebf2c3bd

Pull Request Pull Request #1079: Refactor in new client

Run Details

2333 of 3744 branches covered (62.31%)

Branch coverage included in aggregate %.

49 of 97 new or added lines in 16 files covered. (50.52%)

49 existing lines in 14 files now uncovered.

6193 of 8081 relevant lines covered (76.64%)

34822.21 hits per line

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

41.38

/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);
            var q = level switch
            {
                PersonRuleLevel.Lesser => 0.1f,
                PersonRuleLevel.Normal => 0.3f,
                PersonRuleLevel.Grand => 0.5f,
                PersonRuleLevel.None => throw new NotSupportedException(),
                PersonRuleLevel.Absolute => throw new NotSupportedException(),
                _ => 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 levels = archievedPerk.Scheme.Levels;
                if (levels is null)
                {
                    continue;
                }

                if (currentLevel is null)
                {
                    continue;
                }

                var currentLevelScheme = levels[currentLevel.Primary - 1];

                if (currentLevelScheme is null)
                {
                    continue;
                }

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

                for (var i = 1; i <= currentLevel.Sub; i++)
                {
                    foreach (var rule in currentLevelScheme.Rules)
                    {
                        if (rule is null)
                        {
                            continue;
                        }

                        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)
        {
            return level switch
            {
                PersonRuleLevel.None => 0,
                PersonRuleLevel.Lesser => 1,
                PersonRuleLevel.Normal => 2,
                PersonRuleLevel.Grand => 3,
                PersonRuleLevel.Absolute => 5,
                _ => 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;
                foreach (var armor in orderedArmors)
                {
                    // Because all armors are ordered by desc.
                    // First the armor with minimun level will be processed.
                    if (armorLevel is null)
                    {
                        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 && armorLevel != 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;

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

kreghek / Zilon_Roguelike / 794716003

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