867999344

Build Type

github

Committed by GitHub

Commit Message

Merge afd435c3f into 00d2fa5b7

Pull Request Pull Request #1124: Feature 1100 autoplay mode

Run Details

2298 of 3696 branches covered (62.18%)

Branch coverage included in aggregate %.

50 of 58 new or added lines in 15 files covered. (86.21%)

28 existing lines in 13 files now uncovered.

6146 of 8034 relevant lines covered (76.5%)

41512.47 hits per line

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

75.32

/Zilon.Core/Zilon.Core/PersonModules/CombatActModule.cs

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

using Newtonsoft.Json;

using Zilon.Core.Common;
using Zilon.Core.Components;
using Zilon.Core.LogicCalculations;
using Zilon.Core.Persons;
using Zilon.Core.Props;
using Zilon.Core.Schemes;

namespace Zilon.Core.PersonModules
{
    /// <summary>
    /// Базовая реализация объекта для хранения сведений о тактических действиях персонажа.
    /// </summary>
    public sealed class CombatActModule : ICombatActModule
    {
        private readonly ITacticalActScheme _defaultActScheme;
        private readonly IEquipmentModule _equipmentModule;
        private readonly IEvolutionModule _evolutionModule;
        private readonly IConditionsModule _сonditionsModule;

        public CombatActModule(
            ITacticalActScheme defaultActScheme,
            IEquipmentModule equipmentModule,
            IConditionsModule сonditionsModule,
            IEvolutionModule evolutionModule)
        {
            IsActive = true;

            _defaultActScheme = defaultActScheme;
            _equipmentModule = equipmentModule;
            _сonditionsModule = сonditionsModule;
            _evolutionModule = evolutionModule;
        }

        private static IEnumerable<ITacticalAct> CalcActs(ITacticalActScheme defaultActScheme,
            IEnumerable<Equipment?> equipments,
            IConditionsModule сonditionModule,
            IEnumerable<IPerk> perks)
        {
            var defaultAct = CreateTacticalAct(defaultActScheme, null, сonditionModule, perks);
            yield return defaultAct;

            var equipmentActs = CalcActsFromEquipments(equipments, сonditionModule, perks);
            foreach (var act in equipmentActs)
            {
                yield return act;
            }
        }

        private static IEnumerable<ITacticalAct> CalcActsFromEquipments(
            IEnumerable<Equipment?> equipments,
            IConditionsModule сondition,
            IEnumerable<IPerk> perks)
        {
            if (equipments == null)
            {
                yield break;
            }

            foreach (var equipment in equipments)
            {
                if (equipment == null)
                {
                    continue;
                }

                foreach (var actScheme in equipment.Acts)
                {
                    var act = CreateTacticalAct(actScheme, equipment, сondition, perks);

                    yield return act;
                }
            }
        }

        private static void CalcPerksBonusesOnTacticalAct([NotNull] IEnumerable<IPerk> archievedPerks,
            [MaybeNull] Equipment? equipment,
            ref int toHitModifierValue,
            ref int efficientModifierValue)
        {
            foreach (var perk in archievedPerks)
            {
                if (perk.Scheme.IsBuildIn)
                {
                    if (perk.Scheme.Levels != null)
                    {
                        var perkLevelSubScheme0 = perk.Scheme.Levels[0];
                        if (perkLevelSubScheme0 is null)
                        {
                            continue;
                        }

                        var rules = perkLevelSubScheme0.Rules;

                        if (rules is null)
                        {
                            continue;
                        }

                        ProcessRulesBonuses(equipment, ref toHitModifierValue, ref efficientModifierValue, rules);
                    }
                }
                else
                {
                    var currentLevel = perk.CurrentLevel;
                    if (currentLevel is null)
                    {
                        continue;
                    }

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

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

                    if (currentLevelScheme is null)
                    {
                        continue;
                    }

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

                    for (var i = 0; i <= currentLevel.Sub; i++)
                    {
                        var rules = currentLevelScheme.Rules;
                        ProcessRulesBonuses(equipment, ref toHitModifierValue, ref efficientModifierValue, rules);
                    }
                }
            }
        }

        private static void CalcSurvivalHazardOnTacticalAct(IConditionsModule сondition,
            ref int toHitModifierValue,
            ref int efficientModifierValue)
        {
            var greaterSurvivalEffect = сondition.Items.OfType<SurvivalStatHazardCondition>()
                .OrderByDescending(x => x.Level).FirstOrDefault();

            if (greaterSurvivalEffect == null)
            {
                return;
            }

            var effecientDebuffRule = greaterSurvivalEffect.GetRules()
                .FirstOrDefault(x => x.RollType == RollEffectType.Efficient);

            var toHitDebuffRule = greaterSurvivalEffect.GetRules()
                .FirstOrDefault(x => x.RollType == RollEffectType.ToHit);

            if (effecientDebuffRule != null)
            {
                efficientModifierValue += -1;
            }

            if (toHitDebuffRule != null)
            {
                toHitModifierValue += -1;
            }
        }

        private static ITacticalAct CreateTacticalAct([NotNull] ITacticalActScheme scheme,
            [MaybeNull] Equipment? equipment,
            [NotNull] IConditionsModule сonditionModule,
            [NotNull] IEnumerable<IPerk> perks)
        {
            var toHitModifierValue = 0;
            var efficientModifierValue = 0;
            var efficientRollUnmodified = scheme.Stats?.Efficient ?? new Roll(1, 1);
            CalcSurvivalHazardOnTacticalAct(сonditionModule, ref toHitModifierValue, ref efficientModifierValue);
            CalcPerksBonusesOnTacticalAct(perks, equipment, ref toHitModifierValue, ref efficientModifierValue);

            var toHitRoll = CreateTacticalActRoll(6, 1, toHitModifierValue);

            var efficientRoll = CreateTacticalActRoll(efficientRollUnmodified.Dice,
                efficientRollUnmodified.Count,
                efficientModifierValue);

            return new TacticalAct(scheme, efficientRoll, toHitRoll, equipment);
        }

        private static Roll CreateTacticalActRoll(int dice, int count, int modifierValue)
        {
            if (modifierValue == 0)
            {
                return new Roll(dice, count);
            }

            var modifier = new RollModifiers(modifierValue);
            return new Roll(dice, count, modifier);
        }

        private IEnumerable<IPerk> GetPerksSafe()
        {
            var perks = _evolutionModule?.GetArchievedPerks();
            if (perks == null)
            {
                perks = Array.Empty<IPerk>();
            }

            return perks;
        }

        private static int GetRollModifierByPerkRule(Equipment? equipment, int efficientModifierValue,
            PerkRuleSubScheme rule)
        {
            if (rule.Params is null || string.IsNullOrWhiteSpace(rule.Params))
            {
                efficientModifierValue = RuleCalculations.CalcEfficientByRuleLevel(efficientModifierValue, rule.Level);
            }
            else
            {
                var damagePerkParams = JsonConvert.DeserializeObject<DamagePerkParams>(rule.Params);

                if (damagePerkParams is null)
                {
                    throw new InvalidOperationException("Error n serialization of damagePerkParams.");
                }

                if (damagePerkParams.WeaponTags != null && equipment != null)
                {
                    var hasAllTags = true;
                    foreach (var requiredTag in damagePerkParams.WeaponTags)
                    {
                        if (equipment.Scheme.Tags?.Contains(requiredTag) != true)
                        {
                            hasAllTags = false;
                            break;
                        }
                    }

                    if (hasAllTags)
                    {
                        efficientModifierValue =
                            RuleCalculations.CalcEfficientByRuleLevel(efficientModifierValue, rule.Level);
                    }
                }
            }

            return efficientModifierValue;
        }

        private static void GetRuleModifierValue(PerkRuleSubScheme rule, Equipment? equipment,
            ref int toHitModifierValue, ref int efficientModifierValue)
        {
            switch (rule.Type)
            {
                case PersonRuleType.Damage:
                    efficientModifierValue = GetRollModifierByPerkRule(equipment, efficientModifierValue, rule);
                    break;

                case PersonRuleType.ToHit:
                    toHitModifierValue = GetRollModifierByPerkRule(equipment, toHitModifierValue, rule);
                    break;

                case PersonRuleType.Undefined:
                    throw new InvalidOperationException("Rule is not defined.");

                case PersonRuleType.Health:
                case PersonRuleType.HealthIfNoBody:
                case PersonRuleType.HungerResistance:
                case PersonRuleType.ThristResistance:
                    // This perk rule is not influence to combat.
                    break;

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

        private static void ProcessRulesBonuses(Equipment? equipment, ref int toHitModifierValue,
            ref int efficientModifierValue, PerkRuleSubScheme?[] rules)
        {
            foreach (var rule in rules)
            {
                if (rule is null)
                {
                    continue;
                }

                GetRuleModifierValue(rule, equipment, ref toHitModifierValue, ref efficientModifierValue);
            }
        }

        public string Key => nameof(ICombatActModule);
        public bool IsActive { get; set; }

        public IEnumerable<ITacticalAct> CalcCombatActs()
        {
            var perks = GetPerksSafe();
            return CalcActs(_defaultActScheme, _equipmentModule, _сonditionsModule, perks);
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5
6	using Newtonsoft.Json;
7
8	using Zilon.Core.Common;
9	using Zilon.Core.Components;
10	using Zilon.Core.LogicCalculations;
11	using Zilon.Core.Persons;
12	using Zilon.Core.Props;
13	using Zilon.Core.Schemes;
14
15	namespace Zilon.Core.PersonModules
16	{
17	/// <summary>
18	/// Базовая реализация объекта для хранения сведений о тактических действиях персонажа.
19	/// </summary>
20	public sealed class CombatActModule : ICombatActModule
21	{
22	private readonly ITacticalActScheme _defaultActScheme;
23	private readonly IEquipmentModule _equipmentModule;
24	private readonly IEvolutionModule _evolutionModule;
25	private readonly IConditionsModule _сonditionsModule;
26
27	public CombatActModule(	71✔
28	ITacticalActScheme defaultActScheme,	71✔
29	IEquipmentModule equipmentModule,	71✔
30	IConditionsModule сonditionsModule,	71✔
31	IEvolutionModule evolutionModule)	71✔
32	{
33	IsActive = true;	71✔
34
35	_defaultActScheme = defaultActScheme;	71✔
36	_equipmentModule = equipmentModule;	71✔
37	_сonditionsModule = сonditionsModule;	71✔
38	_evolutionModule = evolutionModule;	71✔
39	}	71✔
40
41	private static IEnumerable<ITacticalAct> CalcActs(ITacticalActScheme defaultActScheme,
42	IEnumerable<Equipment?> equipments,
43	IConditionsModule сonditionModule,
44	IEnumerable<IPerk> perks)
45	{
46	var defaultAct = CreateTacticalAct(defaultActScheme, null, сonditionModule, perks);
47	yield return defaultAct;
48
49	var equipmentActs = CalcActsFromEquipments(equipments, сonditionModule, perks);
50	foreach (var act in equipmentActs)
51	{
52	yield return act;
53	}
54	}
55
56	private static IEnumerable<ITacticalAct> CalcActsFromEquipments(
57	IEnumerable<Equipment?> equipments,
58	IConditionsModule сondition,
59	IEnumerable<IPerk> perks)
60	{
61	if (equipments == null)
62	{
63	yield break;
64	}
65
66	foreach (var equipment in equipments)
67	{
68	if (equipment == null)
69	{
70	continue;
71	}
72
73	foreach (var actScheme in equipment.Acts)
74	{
75	var act = CreateTacticalAct(actScheme, equipment, сondition, perks);
76
77	yield return act;
78	}
79	}
80	}
81
82	private static void CalcPerksBonusesOnTacticalAct([NotNull] IEnumerable<IPerk> archievedPerks,
83	[MaybeNull] Equipment? equipment,
84	ref int toHitModifierValue,
85	ref int efficientModifierValue)
86	{
87	foreach (var perk in archievedPerks)	37,340✔
88	{
89	if (perk.Scheme.IsBuildIn)	10,582✔
90	{
91	if (perk.Scheme.Levels != null)	10,511✔
92	{
93	var perkLevelSubScheme0 = perk.Scheme.Levels[0];	7,201✔
94	if (perkLevelSubScheme0 is null)	7,201✔
95	{
96	continue;
97	}
98
99	var rules = perkLevelSubScheme0.Rules;	7,201✔
100
101	if (rules is null)	7,201✔
102	{
103	continue;
104	}
105
106	ProcessRulesBonuses(equipment, ref toHitModifierValue, ref efficientModifierValue, rules);	7,201✔
107	}
108	}
109	else
110	{
111	var currentLevel = perk.CurrentLevel;	71✔
112	if (currentLevel is null)	71✔
113	{
114	continue;
115	}
116
117	if (perk.Scheme.Levels is null)	71✔
118	{
119	continue;
120	}
121
122	var currentLevelScheme = perk.Scheme.Levels[currentLevel.Primary - 1];	71✔
123
124	if (currentLevelScheme is null)	71✔
125	{
126	continue;
127	}
128
129	if (currentLevelScheme.Rules is null)	71✔
130	{
131	continue;
132	}
133
134	for (var i = 0; i <= currentLevel.Sub; i++)	426✔
135	{
136	var rules = currentLevelScheme.Rules;	142✔
137	ProcessRulesBonuses(equipment, ref toHitModifierValue, ref efficientModifierValue, rules);	142✔
138	}
139	}
140	}
141	}	8,088✔
142
143	private static void CalcSurvivalHazardOnTacticalAct(IConditionsModule сondition,
144	ref int toHitModifierValue,
145	ref int efficientModifierValue)
146	{
147	var greaterSurvivalEffect = сondition.Items.OfType<SurvivalStatHazardCondition>()	8,088✔
148	.OrderByDescending(x => x.Level).FirstOrDefault();	8,088✔
149
150	if (greaterSurvivalEffect == null)	8,088✔
151	{
152	return;	2,820✔
153	}
154
155	var effecientDebuffRule = greaterSurvivalEffect.GetRules()	5,268✔
156	.FirstOrDefault(x => x.RollType == RollEffectType.Efficient);	5,268✔
157
158	var toHitDebuffRule = greaterSurvivalEffect.GetRules()	5,268✔
159	.FirstOrDefault(x => x.RollType == RollEffectType.ToHit);	5,268✔
160
161	if (effecientDebuffRule != null)	5,268✔
162	{
163	efficientModifierValue += -1;	5,268✔
164	}
165
166	if (toHitDebuffRule != null)	5,268✔
167	{
168	toHitModifierValue += -1;	3,823✔
169	}
170	}	5,268✔
171
172	private static ITacticalAct CreateTacticalAct([NotNull] ITacticalActScheme scheme,
173	[MaybeNull] Equipment? equipment,
174	[NotNull] IConditionsModule сonditionModule,
175	[NotNull] IEnumerable<IPerk> perks)
176	{
177	var toHitModifierValue = 0;	8,088✔
178	var efficientModifierValue = 0;	8,088✔
179	var efficientRollUnmodified = scheme.Stats?.Efficient ?? new Roll(1, 1);	8,088!
180	CalcSurvivalHazardOnTacticalAct(сonditionModule, ref toHitModifierValue, ref efficientModifierValue);	8,088✔
181	CalcPerksBonusesOnTacticalAct(perks, equipment, ref toHitModifierValue, ref efficientModifierValue);	8,088✔
182
183	var toHitRoll = CreateTacticalActRoll(6, 1, toHitModifierValue);	8,088✔
184
185	var efficientRoll = CreateTacticalActRoll(efficientRollUnmodified.Dice,	8,088✔
186	efficientRollUnmodified.Count,	8,088✔
187	efficientModifierValue);	8,088✔
188
189	return new TacticalAct(scheme, efficientRoll, toHitRoll, equipment);	8,088✔
190	}
191
192	private static Roll CreateTacticalActRoll(int dice, int count, int modifierValue)
193	{
194	if (modifierValue == 0)	16,176✔
195	{
196	return new Roll(dice, count);	7,076✔
197	}
198
199	var modifier = new RollModifiers(modifierValue);	9,100✔
200	return new Roll(dice, count, modifier);	9,100✔
201	}
202
203	private IEnumerable<IPerk> GetPerksSafe()
204	{
205	var perks = _evolutionModule?.GetArchievedPerks();	7,556!
206	if (perks == null)	7,556!
207	{
208	perks = Array.Empty<IPerk>();	×
209	}
210
211	return perks;	7,556✔
212	}
213
214	private static int GetRollModifierByPerkRule(Equipment? equipment, int efficientModifierValue,
215	PerkRuleSubScheme rule)
216	{
217	if (rule.Params is null \|\| string.IsNullOrWhiteSpace(rule.Params))	142!
218	{
219	efficientModifierValue = RuleCalculations.CalcEfficientByRuleLevel(efficientModifierValue, rule.Level);	142✔
220	}
221	else
222	{
223	var damagePerkParams = JsonConvert.DeserializeObject<DamagePerkParams>(rule.Params);	×
224
NEW 225	if (damagePerkParams is null)	×
226	{
NEW 227	throw new InvalidOperationException("Error n serialization of damagePerkParams.");	×
228	}
229
UNCOV 230	if (damagePerkParams.WeaponTags != null && equipment != null)	×
231	{
232	var hasAllTags = true;	×
233	foreach (var requiredTag in damagePerkParams.WeaponTags)	×
234	{
235	if (equipment.Scheme.Tags?.Contains(requiredTag) != true)	×
236	{
237	hasAllTags = false;	×
238	break;	×
239	}
240	}
241
242	if (hasAllTags)	×
243	{
244	efficientModifierValue =	×
245	RuleCalculations.CalcEfficientByRuleLevel(efficientModifierValue, rule.Level);	×
246	}
247	}
248	}
249
250	return efficientModifierValue;	142✔
251	}
252
253	private static void GetRuleModifierValue(PerkRuleSubScheme rule, Equipment? equipment,
254	ref int toHitModifierValue, ref int efficientModifierValue)
255	{
256	switch (rule.Type)	7,343!
257	{
258	case PersonRuleType.Damage:
259	efficientModifierValue = GetRollModifierByPerkRule(equipment, efficientModifierValue, rule);	142✔
260	break;	142✔
261
262	case PersonRuleType.ToHit:
263	toHitModifierValue = GetRollModifierByPerkRule(equipment, toHitModifierValue, rule);	×
264	break;	×
265
266	case PersonRuleType.Undefined:
267	throw new InvalidOperationException("Rule is not defined.");	×
268
269	case PersonRuleType.Health:
270	case PersonRuleType.HealthIfNoBody:
271	case PersonRuleType.HungerResistance:
272	case PersonRuleType.ThristResistance:
273	// This perk rule is not influence to combat.
274	break;
275
276	default:
277	throw new InvalidOperationException($"Rule {rule.Type} unknown.");	×
278	}
279	}	7,201✔
280
281	private static void ProcessRulesBonuses(Equipment? equipment, ref int toHitModifierValue,
282	ref int efficientModifierValue, PerkRuleSubScheme?[] rules)
283	{
284	foreach (var rule in rules)	29,372✔
285	{
286	if (rule is null)	7,343✔
287	{
288	continue;
289	}
290
291	GetRuleModifierValue(rule, equipment, ref toHitModifierValue, ref efficientModifierValue);	7,343✔
292	}
293	}	7,343✔
294
295	public string Key => nameof(ICombatActModule);	71✔
296	public bool IsActive { get; set; }
297
298	public IEnumerable<ITacticalAct> CalcCombatActs()
299	{
300	var perks = GetPerksSafe();	7,556✔
301	return CalcActs(_defaultActScheme, _equipmentModule, _сonditionsModule, perks);	7,556✔
302	}
303	}
304	}

kreghek / Zilon_Roguelike / 867999344

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