362744635

Build Type

github

Committed by GitHub

Commit Message

Merge 3b82624b4 into a9df08b55

Pull Request Pull Request #891: Fix specs

Run Details

4326 of 7108 branches covered (60.86%)

Branch coverage included in aggregate %.

44 of 68 new or added lines in 9 files covered. (64.71%)

1 existing line in 1 file now uncovered.

6333 of 8469 relevant lines covered (74.78%)

852668.14 hits per line

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

47.17

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

        /// <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 IPlayer Owner { get; }
        public PhysicalSize PhysicalSize { get => Person.PhysicalSize; }
        public IActorTaskSource<ISectorTaskSourceContext> TaskSource { get; private set; }
        public bool CanExecuteTasks { get => !Person.CheckIsDead(); }

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

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

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

        [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}.");
            }
        }

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

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

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

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

kreghek / Zilon_Roguelike / 362744635

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