862928347

Build Type

github

Committed by GitHub

Commit Message

Merge 7bd9dc82b into 8ba8f6511

Pull Request Pull Request #1108: Monogame client

Run Details

2259 of 3684 branches covered (61.32%)

Branch coverage included in aggregate %.

49 of 179 new or added lines in 78 files covered. (27.37%)

93 existing lines in 21 files now uncovered.

6092 of 8018 relevant lines covered (75.98%)

37816.93 hits per line

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

46.43

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

﻿using System;
using System.Diagnostics.CodeAnalysis;

using Zilon.Core.Common;
using Zilon.Core.Components;
using Zilon.Core.Graphs;
using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
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;
            TaskSource = taskSource;
            Node = node;
        }

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

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

            if (useData?.CommonRules is null)
            {
                throw new InvalidOperationException();
            }

            foreach (var rule in useData.CommonRules)
            {
                if (rule is null)
                {
                    continue;
                }

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

kreghek / Zilon_Roguelike / 862928347

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