932653941

Build Type

github

Committed by GitHub

Commit Message

Merge 3320fca9e into d434c4117

Pull Request Pull Request #1180: Added replacement for two-handed equipment in hands

Run Details

1941 of 3724 branches covered (52.12%)

Branch coverage included in aggregate %.

45 of 46 new or added lines in 3 files covered. (97.83%)

104 existing lines in 5 files now uncovered.

5006 of 7902 relevant lines covered (63.35%)

20791.52 hits per line

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

47.06

/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.MapGenerators;
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 />
        public event EventHandler? PropTransferPerformed;

        /// <inheritdoc />
        public event EventHandler? BeginTransitionToOtherSector;

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

        public void PerformTransfer()
        {
            PropTransferPerformed?.Invoke(this, EventArgs.Empty);
        }

        public void MoveToOtherSector(ISector sector, SectorTransition sectorTransition)
        {
            BeginTransitionToOtherSector?.Invoke(this, EventArgs.Empty);
            sector.UseTransition(this, sectorTransition);
        }
    }
}

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

kreghek / Zilon_Roguelike / 932653941

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