364076202

Build Type

github

Committed by GitHub

Commit Message

Merge ce2dc7a65 into c20d96a84

Pull Request Pull Request #892: Auto refactor by Resharper CLT

Run Details

4375 of 7126 branches covered (61.39%)

Branch coverage included in aggregate %.

1033 of 1481 new or added lines in 229 files covered. (69.75%)

54 existing lines in 41 files now uncovered.

6585 of 8896 relevant lines covered (74.02%)

773222.9 hits per line

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

46.44

/Zilon.Core/Zilon.Core/Tactics/Actor.cs

﻿using System;
using System.Diagnostics.CodeAnalysis;

using JetBrains.Annotations;

using Zilon.Core.Common;
using Zilon.Core.Components;
using Zilon.Core.Graphs;
using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
using Zilon.Core.Players;
using Zilon.Core.Props;
using Zilon.Core.Schemes;
using Zilon.Core.StaticObjectModules;
using Zilon.Core.Tactics.Behaviour;

namespace Zilon.Core.Tactics
{
    public sealed class Actor : IActor
    {
        private readonly IPerkResolver _perkResolver;

        [ExcludeFromCodeCoverage]
        public Actor(
            [NotNull] IPerson person,
            [NotNull] IActorTaskSource<ISectorTaskSourceContext> taskSource,
            [NotNull] IGraphNode node)
        {
            Person = person ?? throw new ArgumentNullException(nameof(person));
            TaskSource = taskSource ?? throw new ArgumentNullException(nameof(taskSource));
            Node = node ?? throw new ArgumentNullException(nameof(node));
        }

        public Actor(
            [NotNull] IPerson person,
            [NotNull] IActorTaskSource<ISectorTaskSourceContext> taskSource,
            [NotNull] IGraphNode node,
            [CanBeNull] IPerkResolver perkResolver) : this(person, taskSource, node)
        {
            _perkResolver = perkResolver;
        }

        public IPlayer Owner { get; }

        /// <inheritdoc/>
        public event EventHandler Moved;

        /// <inheritdoc/>
        public event EventHandler<OpenContainerEventArgs> OpenedContainer;

        /// <inheritdoc/>
        public event EventHandler<MineDepositEventArgs> DepositMined;

        /// <inheritdoc/>
        public event EventHandler<UsedActEventArgs> UsedAct;

        /// <inheritdoc/>
        public event EventHandler<DamageTakenEventArgs> DamageTaken;

        /// <inheritdoc/>
        public event EventHandler<UsedPropEventArgs> UsedProp;

        /// <inheritdoc />
        /// <summary>
        /// Песонаж, который лежит в основе актёра.
        /// </summary>
        public IPerson Person { get; }

        /// <summary>
        /// Текущий узел карты, в котором находится актёр.
        /// </summary>
        public IGraphNode Node { get; private set; }

        public PhysicalSizePattern PhysicalSize => Person.PhysicalSize;

        public IActorTaskSource<ISectorTaskSourceContext> TaskSource { get; private set; }

        public bool CanExecuteTasks => !Person.CheckIsDead();

        public bool CanBeDamaged()
        {
            if (Person.GetModuleSafe<ISurvivalModule>() is null)
            {
                return false;
            }

            return !Person.GetModule<ISurvivalModule>().IsDead;
        }

        public void MoveToNode(IGraphNode targetNode)
        {
            Node = targetNode;
            Moved?.Invoke(this, new EventArgs());
        }

        public void OpenContainer(IStaticObject container, IOpenContainerMethod method)
        {
            if (container is null)
            {
                throw new ArgumentNullException(nameof(container));
            }

            if (method is null)
            {
                throw new ArgumentNullException(nameof(method));
            }

            var openResult = method?.TryOpen(container.GetModule<IPropContainer>());

            DoOpenContainer(container, openResult);
        }

        public void UseAct(IAttackTarget target, ITacticalAct tacticalAct)
        {
            DoUseAct(target, tacticalAct);
        }

        public void UseProp(IProp usedProp)
        {
            if (usedProp is null)
            {
                throw new ArgumentNullException(nameof(usedProp));
            }

            var useData = usedProp.Scheme.Use;

            foreach (var rule in useData.CommonRules)
            {
                switch (rule.Direction)
                {
                    // Если направление не указано, то будет считаться положительное значение
                    //TODO При десериализации указывать значение Positive по умолчанию
                    default:
                    case PersonRuleDirection.Positive:
                        ProcessPositiveRule(rule.Type, rule.Level);
                        break;
                    case PersonRuleDirection.Negative:
                        ProcessNegativeRule(rule.Type, rule.Level);
                        break;
                }
            }

            if (useData.Consumable && (Person.GetModuleSafe<IInventoryModule>() != null))
            {
                ConsumeResource(usedProp);

                if (_perkResolver != null)
                {
                    var consumeProgress = new ConsumeProviantJobProgress();
                    _perkResolver.ApplyProgress(consumeProgress, Person.GetModule<IEvolutionModule>());
                }
            }

            UsedProp?.Invoke(this, new UsedPropEventArgs(usedProp));
        }

        public void TakeDamage(int value)
        {
            Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health, value);

            if ((_perkResolver != null) && (Person.GetModuleSafe<IEvolutionModule>() != null))
            {
                var takeDamageProgress = new TakeDamageJobProgress(value);
                _perkResolver.ApplyProgress(takeDamageProgress, Person.GetModule<IEvolutionModule>());

                var takeHitProgress = new TakeHitJobProgress();
                _perkResolver.ApplyProgress(takeHitProgress, Person.GetModule<IEvolutionModule>());
            }

            DoDamageTaken(value);
        }

        public void MineDeposit(IStaticObject deposit, IMineDepositMethod method)
        {
            if (deposit is null)
            {
                throw new ArgumentNullException(nameof(deposit));
            }

            if (method is null)
            {
                throw new ArgumentNullException(nameof(method));
            }

            var openResult = method?.TryMine(deposit.GetModule<IPropDepositModule>());

            DoMineDeposit(deposit, openResult);
        }

        public void SwitchTaskSource(IActorTaskSource<ISectorTaskSourceContext> actorTaskSource)
        {
            TaskSource = actorTaskSource;
        }

        private void ProcessNegativeRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
        {
            switch (type)
            {
                case ConsumeCommonRuleType.Satiety:
                    DecreaseStat(SurvivalStatType.Satiety, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Thirst:
                    DecreaseStat(SurvivalStatType.Hydration, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Health:
                    DecreaseStat(SurvivalStatType.Health, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Intoxication:
                    DecreaseStat(SurvivalStatType.Intoxication, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Undefined:
                default:
                    throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");
            }
        }

        private void ProcessPositiveRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
        {
            switch (type)
            {
                case ConsumeCommonRuleType.Satiety:
                    RestoreStat(SurvivalStatType.Satiety, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Thirst:
                    RestoreStat(SurvivalStatType.Hydration, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Health:
                    RestoreStat(SurvivalStatType.Health, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Intoxication:
                    RiseStat(SurvivalStatType.Intoxication, ruleLevel);
                    break;

                case ConsumeCommonRuleType.Undefined:
                default:
                    throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");
            }
        }

        private void ConsumeResource(IProp usedProp)
        {
            switch (usedProp)
            {
                case Resource resource:
                    var removeResource = new Resource(resource.Scheme, 1);
                    Person.GetModule<IInventoryModule>().Remove(removeResource);
                    break;

                case Equipment equipment:
                    Person.GetModule<IInventoryModule>().Remove(equipment);
                    break;
            }
        }

        [ExcludeFromCodeCoverage]
        private void DoDamageTaken(int value)
        {
            DamageTaken?.Invoke(this, new DamageTakenEventArgs(value));
        }

        [ExcludeFromCodeCoverage]
        private void DoOpenContainer(IStaticObject container, IOpenContainerResult openResult)
        {
            var e = new OpenContainerEventArgs(container, openResult);
            OpenedContainer?.Invoke(this, e);
        }

        [ExcludeFromCodeCoverage]
        private void DoUseAct(IAttackTarget target, ITacticalAct tacticalAct)
        {
            var args = new UsedActEventArgs(target, tacticalAct);
            UsedAct?.Invoke(this, args);
        }

        [ExcludeFromCodeCoverage]
        public override string ToString()
        {
            return $"{Person}";
        }

        /// <summary>
        /// Метод введён специально для повышения уровня интоксикации.
        /// Так как глупо выглядит ResToreStat для повышения интоксикации.
        /// Просто семантически более удобная обёртка.
        /// </summary>
        /// <param name="statType"> Характеристика, повышаемая методом. </param>
        /// <param name="level"> Уровень увеличения. </param>
        private void RiseStat(SurvivalStatType statType, PersonRuleLevel level)
        {
            RestoreStat(statType, level);
        }

        private void RestoreStat(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (statType)
            {
                case SurvivalStatType.Satiety:
                case SurvivalStatType.Hydration:
                    RestoreSurvivalStatInner(statType, level);
                    break;

                case SurvivalStatType.Intoxication:
                    RiseIntoxicationLevel(level);
                    break;

                case SurvivalStatType.Health:
                    RestoreHp(level);
                    break;
            }
        }

        private void RestoreSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,
                        PropMetrics.SurvivalLesserRestoreValue + 1);
                    break;

                case PersonRuleLevel.Normal:
                    Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,
                        PropMetrics.SurvivalNormalRestoreValue + 1);
                    break;

                case PersonRuleLevel.Grand:
                    Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,
                        PropMetrics.SurvivalGrandRestoreValue + 1);
                    break;

                case PersonRuleLevel.None:
                    throw new NotSupportedException();

                case PersonRuleLevel.Absolute:
                    throw new NotSupportedException();

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

        private void RestoreHp(PersonRuleLevel level)
        {
            var survivalModule = Person.GetModuleSafe<ISurvivalModule>();
            if (survivalModule is null)
            {
                return;
            }

            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpLesserRestoreValue);
                    break;

                case PersonRuleLevel.Normal:
                    survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpNormalRestoreValue);
                    break;

                case PersonRuleLevel.Grand:
                    survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpGrandRestoreValue);
                    break;

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

        private void RiseIntoxicationLevel(PersonRuleLevel level)
        {
            var survivalModule = Person.GetModuleSafe<ISurvivalModule>();
            if (survivalModule is null)
            {
                return;
            }

            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    survivalModule.RestoreStat(SurvivalStatType.Intoxication,
                        PropMetrics.INTOXICATION_RISE_LESSER_VALUE + 1);
                    break;

                case PersonRuleLevel.Normal:
                    survivalModule.RestoreStat(SurvivalStatType.Intoxication,
                        PropMetrics.INTOXICATION_RISE_NORMAL_VALUE + 1);
                    break;

                case PersonRuleLevel.Grand:
                    survivalModule.RestoreStat(SurvivalStatType.Intoxication,
                        PropMetrics.INTOXICATION_RISE_GRAND_VALUE + 1);
                    break;

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

        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;
            }
        }

        private void DecreaseSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
        {
            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,
                        PropMetrics.SurvivalLesserRestoreValue - 1);
                    break;

                case PersonRuleLevel.Normal:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,
                        PropMetrics.SurvivalNormalRestoreValue - 1);
                    break;

                case PersonRuleLevel.Grand:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,
                        PropMetrics.SurvivalGrandRestoreValue - 1);
                    break;

                case PersonRuleLevel.None:
                    throw new NotSupportedException();

                case PersonRuleLevel.Absolute:
                    throw new NotSupportedException();

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

        private void DecreaseHp(PersonRuleLevel level)
        {
            switch (level)
            {
                case PersonRuleLevel.Lesser:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,
                        PropMetrics.HpLesserRestoreValue);
                    break;

                case PersonRuleLevel.Normal:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,
                        PropMetrics.HpNormalRestoreValue);
                    break;

                case PersonRuleLevel.Grand:
                    Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,
                        PropMetrics.HpGrandRestoreValue);
                    break;

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

        private void DoMineDeposit(IStaticObject deposit, IMineDepositResult openResult)
        {
            var e = new MineDepositEventArgs(deposit, openResult);
            DepositMined?.Invoke(this, e);
        }
    }
}

1	using System;
2	using System.Diagnostics.CodeAnalysis;
3
4	using JetBrains.Annotations;
5
6	using Zilon.Core.Common;
7	using Zilon.Core.Components;
8	using Zilon.Core.Graphs;
9	using Zilon.Core.PersonModules;
10	using Zilon.Core.Persons;
11	using Zilon.Core.Players;
12	using Zilon.Core.Props;
13	using Zilon.Core.Schemes;
14	using Zilon.Core.StaticObjectModules;
15	using Zilon.Core.Tactics.Behaviour;
16
17	namespace Zilon.Core.Tactics
18	{
19	public sealed class Actor : IActor
20	{
21	private readonly IPerkResolver _perkResolver;
22
23	[ExcludeFromCodeCoverage]
24	public Actor(
25	[NotNull] IPerson person,
26	[NotNull] IActorTaskSource<ISectorTaskSourceContext> taskSource,
27	[NotNull] IGraphNode node)
28	{
29	Person = person ?? throw new ArgumentNullException(nameof(person));
30	TaskSource = taskSource ?? throw new ArgumentNullException(nameof(taskSource));
31	Node = node ?? throw new ArgumentNullException(nameof(node));
32	}
33
34	public Actor(
35	[NotNull] IPerson person,
36	[NotNull] IActorTaskSource<ISectorTaskSourceContext> taskSource,
37	[NotNull] IGraphNode node,
38	[CanBeNull] IPerkResolver perkResolver) : this(person, taskSource, node)	128✔
39	{	64✔
40	_perkResolver = perkResolver;	128✔
41	}	128✔
42
NEW 43	public IPlayer Owner { get; }	×
44
45	/// <inheritdoc/>
46	public event EventHandler Moved;
47
48	/// <inheritdoc/>
49	public event EventHandler<OpenContainerEventArgs> OpenedContainer;
50
51	/// <inheritdoc/>
52	public event EventHandler<MineDepositEventArgs> DepositMined;
53
54	/// <inheritdoc/>
55	public event EventHandler<UsedActEventArgs> UsedAct;
56
57	/// <inheritdoc/>
58	public event EventHandler<DamageTakenEventArgs> DamageTaken;
59
60	/// <inheritdoc/>
61	public event EventHandler<UsedPropEventArgs> UsedProp;
62
63	/// <inheritdoc />
64	/// <summary>
65	/// Песонаж, который лежит в основе актёра.
66	/// </summary>
67	public IPerson Person { get; }	50,678,899✔
68
69	/// <summary>
70	/// Текущий узел карты, в котором находится актёр.
71	/// </summary>
72	public IGraphNode Node { get; private set; }	207,614✔
73
74	public PhysicalSizePattern PhysicalSize => Person.PhysicalSize;	328✔
75
76	public IActorTaskSource<ISectorTaskSourceContext> TaskSource { get; private set; }	56,599✔
77
78	public bool CanExecuteTasks => !Person.CheckIsDead();	33,543,776✔
79
80	public bool CanBeDamaged()
81	{	307✔
82	if (Person.GetModuleSafe<ISurvivalModule>() is null)	592!
83	{
84	return false;	×
85	}
86
87	return !Person.GetModule<ISurvivalModule>().IsDead;	592✔
88	}	307✔
89
90	public void MoveToNode(IGraphNode targetNode)
91	{	1,478✔
92	Node = targetNode;	2,798✔
93	Moved?.Invoke(this, new EventArgs());	2,798✔
94	}	2,789✔
95
96	public void OpenContainer(IStaticObject container, IOpenContainerMethod method)
97	{
98	if (container is null)	×
99	{
100	throw new ArgumentNullException(nameof(container));	×
101	}
102
103	if (method is null)	×
104	{
105	throw new ArgumentNullException(nameof(method));	×
106	}
107
108	var openResult = method?.TryOpen(container.GetModule<IPropContainer>());	×
109
110	DoOpenContainer(container, openResult);	×
111	}	×
112
113	public void UseAct(IAttackTarget target, ITacticalAct tacticalAct)
114	{	79✔
115	DoUseAct(target, tacticalAct);	164✔
116	}	164✔
117
118	public void UseProp(IProp usedProp)
119	{	22✔
120	if (usedProp is null)	41!
121	{
122	throw new ArgumentNullException(nameof(usedProp));	×
123	}
124
125	var useData = usedProp.Scheme.Use;	41✔
126
127	foreach (var rule in useData.CommonRules)	282✔
128	{	48✔
129	switch (rule.Direction)	89✔
130	{
131	// Если направление не указано, то будет считаться положительное значение
132	//TODO При десериализации указывать значение Positive по умолчанию
133	default:
134	case PersonRuleDirection.Positive:
135	ProcessPositiveRule(rule.Type, rule.Level);	78✔
136	break;	78✔
137	case PersonRuleDirection.Negative:
138	ProcessNegativeRule(rule.Type, rule.Level);	11✔
139	break;	6✔
140	}
141	}	48✔
142
143	if (useData.Consumable && (Person.GetModuleSafe<IInventoryModule>() != null))	41✔
144	{	21✔
145	ConsumeResource(usedProp);	39✔
146
147	if (_perkResolver != null)	39✔
148	{	12✔
149	var consumeProgress = new ConsumeProviantJobProgress();	24✔
150	_perkResolver.ApplyProgress(consumeProgress, Person.GetModule<IEvolutionModule>());	24✔
151	}	12✔
152	}	21✔
153
154	UsedProp?.Invoke(this, new UsedPropEventArgs(usedProp));	41!
155	}	22✔
156
157	public void TakeDamage(int value)
158	{	64✔
159	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health, value);	130!
160
161	if ((_perkResolver != null) && (Person.GetModuleSafe<IEvolutionModule>() != null))	130✔
162	{	10✔
163	var takeDamageProgress = new TakeDamageJobProgress(value);	20✔
164	_perkResolver.ApplyProgress(takeDamageProgress, Person.GetModule<IEvolutionModule>());	20✔
165
166	var takeHitProgress = new TakeHitJobProgress();	20✔
167	_perkResolver.ApplyProgress(takeHitProgress, Person.GetModule<IEvolutionModule>());	20✔
168	}	10✔
169
170	DoDamageTaken(value);	130✔
171	}	130✔
172
173	public void MineDeposit(IStaticObject deposit, IMineDepositMethod method)
174	{
NEW 175	if (deposit is null)	×
176	{
NEW 177	throw new ArgumentNullException(nameof(deposit));	×
178	}
179
NEW 180	if (method is null)	×
181	{
NEW 182	throw new ArgumentNullException(nameof(method));	×
183	}
184
NEW 185	var openResult = method?.TryMine(deposit.GetModule<IPropDepositModule>());	×
186
NEW 187	DoMineDeposit(deposit, openResult);	×
NEW 188	}	×
189
190	public void SwitchTaskSource(IActorTaskSource<ISectorTaskSourceContext> actorTaskSource)
191	{
NEW 192	TaskSource = actorTaskSource;	×
NEW 193	}	×
194
195	private void ProcessNegativeRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
196	{	6✔
197	switch (type)	6!
198	{
199	case ConsumeCommonRuleType.Satiety:
200	DecreaseStat(SurvivalStatType.Satiety, ruleLevel);	×
201	break;	×
202
203	case ConsumeCommonRuleType.Thirst:
204	DecreaseStat(SurvivalStatType.Hydration, ruleLevel);	9✔
205	break;	9✔
206
207	case ConsumeCommonRuleType.Health:
208	DecreaseStat(SurvivalStatType.Health, ruleLevel);	×
209	break;	×
210
211	case ConsumeCommonRuleType.Intoxication:
212	DecreaseStat(SurvivalStatType.Intoxication, ruleLevel);	2✔
213	break;	2✔
214
215	case ConsumeCommonRuleType.Undefined:
216	default:
217	throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");	×
218	}
219	}	6✔
220
221	private void ProcessPositiveRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
222	{	42✔
223	switch (type)	42!
224	{
225	case ConsumeCommonRuleType.Satiety:
226	RestoreStat(SurvivalStatType.Satiety, ruleLevel);	10!
227	break;	10✔
228
229	case ConsumeCommonRuleType.Thirst:
230	RestoreStat(SurvivalStatType.Hydration, ruleLevel);	7✔
231	break;	7✔
232
233	case ConsumeCommonRuleType.Health:
234	RestoreStat(SurvivalStatType.Health, ruleLevel);	39✔
235	break;	39✔
236
237	case ConsumeCommonRuleType.Intoxication:
238	RiseStat(SurvivalStatType.Intoxication, ruleLevel);	22✔
239	break;	22✔
240
241	case ConsumeCommonRuleType.Undefined:
242	default:
243	throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");	×
244	}
245	}	42✔
246
247	private void ConsumeResource(IProp usedProp)
248	{	21✔
249	switch (usedProp)	21!
250	{
251	case Resource resource:
252	var removeResource = new Resource(resource.Scheme, 1);	39!
253	Person.GetModule<IInventoryModule>().Remove(removeResource);	39✔
254	break;	39✔
255
256	case Equipment equipment:
257	Person.GetModule<IInventoryModule>().Remove(equipment);	×
258	break;
259	}
260	}	21✔
261
262	[ExcludeFromCodeCoverage]
263	private void DoDamageTaken(int value)
264	{
265	DamageTaken?.Invoke(this, new DamageTakenEventArgs(value));
266	}
267
268	[ExcludeFromCodeCoverage]
269	private void DoOpenContainer(IStaticObject container, IOpenContainerResult openResult)
270	{
271	var e = new OpenContainerEventArgs(container, openResult);
272	OpenedContainer?.Invoke(this, e);
273	}
274
275	[ExcludeFromCodeCoverage]
276	private void DoUseAct(IAttackTarget target, ITacticalAct tacticalAct)
277	{
278	var args = new UsedActEventArgs(target, tacticalAct);
279	UsedAct?.Invoke(this, args);
280	}
281
282	[ExcludeFromCodeCoverage]
283	public override string ToString()
284	{
285	return $"{Person}";
286	}
287
288	/// <summary>
289	/// Метод введён специально для повышения уровня интоксикации.
290	/// Так как глупо выглядит ResToreStat для повышения интоксикации.
291	/// Просто семантически более удобная обёртка.
292	/// </summary>
293	/// <param name="statType"> Характеристика, повышаемая методом. </param>
294	/// <param name="level"> Уровень увеличения. </param>
295	private void RiseStat(SurvivalStatType statType, PersonRuleLevel level)
296	{	11✔
297	RestoreStat(statType, level);	22✔
298	}	22✔
299
300	private void RestoreStat(SurvivalStatType statType, PersonRuleLevel level)
301	{	42✔
302	switch (statType)	42✔
303	{
304	case SurvivalStatType.Satiety:
305	case SurvivalStatType.Hydration:
306	RestoreSurvivalStatInner(statType, level);	17!
307	break;	17✔
308
309	case SurvivalStatType.Intoxication:
310	RiseIntoxicationLevel(level);	22✔
311	break;	22✔
312
313	case SurvivalStatType.Health:
314	RestoreHp(level);	39✔
315	break;	21✔
316	}
317	}	60✔
318
319	private void RestoreSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
320	{	10✔
321	switch (level)	10!
322	{
323	case PersonRuleLevel.Lesser:
324	Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,	1!
325	PropMetrics.SurvivalLesserRestoreValue + 1);	1✔
326	break;	1✔
327
328	case PersonRuleLevel.Normal:
329	Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,	16!
330	PropMetrics.SurvivalNormalRestoreValue + 1);	16✔
331	break;	16✔
332
333	case PersonRuleLevel.Grand:
334	Person.GetModuleSafe<ISurvivalModule>()?.RestoreStat(statType,	×
335	PropMetrics.SurvivalGrandRestoreValue + 1);	×
336	break;	×
337
338	case PersonRuleLevel.None:
339	throw new NotSupportedException();	×
340
341	case PersonRuleLevel.Absolute:
342	throw new NotSupportedException();	×
343
344	default:
345	throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");	×
346	}
347	}	10✔
348
349	private void RestoreHp(PersonRuleLevel level)
350	{	21✔
351	var survivalModule = Person.GetModuleSafe<ISurvivalModule>();	39✔
352	if (survivalModule is null)	39!
353	{
354	return;	×
355	}
356
357	switch (level)	21!
358	{
359	case PersonRuleLevel.Lesser:
360	survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpLesserRestoreValue);	17✔
361	break;	17✔
362
363	case PersonRuleLevel.Normal:
364	survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpNormalRestoreValue);	×
365	break;	×
366
367	case PersonRuleLevel.Grand:
368	survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpGrandRestoreValue);	22✔
369	break;	22✔
370
371	default:
372	throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");	×
373	}
374	}	21✔
375
376	private void RiseIntoxicationLevel(PersonRuleLevel level)
377	{	11✔
378	var survivalModule = Person.GetModuleSafe<ISurvivalModule>();	22✔
379	if (survivalModule is null)	22!
380	{
381	return;	×
382	}
383
384	switch (level)	11!
385	{
386	case PersonRuleLevel.Lesser:
387	survivalModule.RestoreStat(SurvivalStatType.Intoxication,	×
388	PropMetrics.INTOXICATION_RISE_LESSER_VALUE + 1);	×
389	break;	×
390
391	case PersonRuleLevel.Normal:
392	survivalModule.RestoreStat(SurvivalStatType.Intoxication,	22✔
393	PropMetrics.INTOXICATION_RISE_NORMAL_VALUE + 1);	22✔
394	break;	22✔
395
396	case PersonRuleLevel.Grand:
397	survivalModule.RestoreStat(SurvivalStatType.Intoxication,	×
398	PropMetrics.INTOXICATION_RISE_GRAND_VALUE + 1);	×
399	break;	×
400
401	default:
402	throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");	×
403	}
404	}	11✔
405
406	private void DecreaseStat(SurvivalStatType statType, PersonRuleLevel level)
407	{	6✔
408	switch (statType)	6!
409	{
410	case SurvivalStatType.Satiety:
411	case SurvivalStatType.Hydration:
412	case SurvivalStatType.Intoxication:
413	DecreaseSurvivalStatInner(statType, level);	11!
414	break;	11✔
415
416	case SurvivalStatType.Health:
417	DecreaseHp(level);	×
418	break;
419	}
420	}	6✔
421
422	private void DecreaseSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
423	{	6✔
424	switch (level)	6!
425	{
426	case PersonRuleLevel.Lesser:
427	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,	11!
428	PropMetrics.SurvivalLesserRestoreValue - 1);	11✔
429	break;	11✔
430
431	case PersonRuleLevel.Normal:
432	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,	×
433	PropMetrics.SurvivalNormalRestoreValue - 1);	×
434	break;	×
435
436	case PersonRuleLevel.Grand:
437	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(statType,	×
438	PropMetrics.SurvivalGrandRestoreValue - 1);	×
439	break;	×
440
441	case PersonRuleLevel.None:
442	throw new NotSupportedException();	×
443
444	case PersonRuleLevel.Absolute:
445	throw new NotSupportedException();	×
446
447	default:
448	throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");	×
449	}
450	}	6✔
451
452	private void DecreaseHp(PersonRuleLevel level)
453	{
454	switch (level)	×
455	{
456	case PersonRuleLevel.Lesser:
457	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,	×
458	PropMetrics.HpLesserRestoreValue);	×
459	break;	×
460
461	case PersonRuleLevel.Normal:
462	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,	×
463	PropMetrics.HpNormalRestoreValue);	×
464	break;	×
465
466	case PersonRuleLevel.Grand:
467	Person.GetModuleSafe<ISurvivalModule>()?.DecreaseStat(SurvivalStatType.Health,	×
468	PropMetrics.HpGrandRestoreValue);	×
469	break;	×
470
471	default:
472	throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");	×
473	}
474	}
475
476	private void DoMineDeposit(IStaticObject deposit, IMineDepositResult openResult)
477	{
478	var e = new MineDepositEventArgs(deposit, openResult);	×
479	DepositMined?.Invoke(this, e);	×
480	}	×
481	}
482	}

kreghek / Zilon_Roguelike / 364076202

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