609141041

Build Type

github

Committed by GitHub

Commit Message

Merge c1bcad253 into cb145aa3f

Pull Request Pull Request #1048: Handle precisely argument exceptions in tests

Run Details

2133 of 3426 branches covered (62.26%)

Branch coverage included in aggregate %.

9 of 11 new or added lines in 1 file covered. (81.82%)

41 existing lines in 12 files now uncovered.

5862 of 7657 relevant lines covered (76.56%)

39396.12 hits per line

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

45.76

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

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

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

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

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

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


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

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

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

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

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

        /// <inheritdoc />
        public int Id => Person.Id;

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

        /// <inheritdoc />
        public void UseAct(IGraphNode targetNode, ITacticalAct tacticalAct)
        {
            DoUseAct(targetNode, 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;
        }
    }
}

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

kreghek / Zilon_Roguelike / 609141041

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