923900393

Build Type

github

Committed by GitHub

Commit Message

Merge fa02bc013 into 3567602cd

Pull Request Pull Request #1182: Feature loot

Run Details

1931 of 3698 branches covered (52.22%)

Branch coverage included in aggregate %.

28 of 37 new or added lines in 4 files covered. (75.68%)

1 existing line in 1 file now uncovered.

4969 of 7846 relevant lines covered (63.33%)

20929.22 hits per line

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

80.17

/Zilon.Core/Zilon.Core/Tactics/Sector.cs

﻿using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

using Zilon.Core.Diseases;
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.Scoring;
using Zilon.Core.StaticObjectModules;
using Zilon.Core.Tactics.Behaviour;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.Tactics
{
    /// <summary>
    /// Базовая реализация сектора.
    /// </summary>
    /// <seealso cref="ISector" />
    public class Sector : ISector
    {
        private const int NATIONALUNITYCOUNTERSTARTVALUE = 1000;

        private readonly List<IDisease> _diseases;
        private readonly IDropResolver _dropResolver;
        private readonly IEquipmentDurableService _equipmentDurableService;
        private readonly ISchemeService _schemeService;
        private int _nationalUnityCounter = NATIONALUNITYCOUNTERSTARTVALUE;

        [ExcludeFromCodeCoverage]
        public Sector(ISectorMap map,
            IActorManager actorManager,
            IStaticObjectManager staticObjectManager,
            IDropResolver dropResolver,
            ISchemeService schemeService,
            IEquipmentDurableService equipmentDurableService)
        {
            ActorManager = actorManager ?? throw new ArgumentNullException(nameof(actorManager));
            StaticObjectManager = staticObjectManager ?? throw new ArgumentNullException(nameof(staticObjectManager));
            _dropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
            _schemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
            _equipmentDurableService = equipmentDurableService ??
                                       throw new ArgumentNullException(nameof(equipmentDurableService));

            _diseases = new List<IDisease>();

            ActorManager.Added += ActorManager_Added;
            ActorManager.Removed += ActorManager_Remove;
            StaticObjectManager.Added += StaticObjectManager_Added;
            StaticObjectManager.Removed += StaticObjectManager_Remove;

            Map = map ?? throw new ArgumentException("Не передана карта сектора.", nameof(map));
        }

        [ExcludeFromCodeCoverage]
        public NationalUnityEventService? NationalUnityEventService { get; set; }

        private void Actor_Moved(object? sender, EventArgs e)
        {
            if (sender is null)
            {
                throw new InvalidOperationException("The handler can work only for instance. Sender can't be null.");
            }

            var actor = (IActor)sender;
            UpdateFowData(actor);
        }

        private void ActorManager_Added(object? sender, ManagerItemsChangedEventArgs<IActor> e)
        {
            foreach (var actor in e.Items)
            {
                HoldNodes(actor.Node, actor, Map);

                if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)
                {
                    actor.Person.GetModule<ISurvivalModule>().Dead += ActorState_Dead;
                }

                actor.Moved += Actor_Moved;
                UpdateFowData(actor);
            }
        }

        private void ActorManager_Remove(object? sender, ManagerItemsChangedEventArgs<IActor> e)
        {
            // Когда актёры удалены из сектора, мы перестаём мониторить события на них.
            foreach (var actor in e.Items)
            {
                ReleaseNodes(actor, Map);

                if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)
                {
                    actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;
                }

                actor.Moved -= Actor_Moved;
            }
        }

        private void ActorState_Dead(object? sender, EventArgs e)
        {
            var actor = ActorManager.Items.Single(x =>
                ReferenceEquals(x.Person.GetModuleSafe<ISurvivalModule>(), sender));
            ActorManager.Remove(actor);

            if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)
            {
                actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;
            }

            ProcessMonsterDeath(actor);
        }

        private void DoActorExit([NotNull] IActor actor, [NotNull] SectorTransition roomTransition)
        {
            var e = new TransitionUsedEventArgs(actor, roomTransition);
            TrasitionUsed?.Invoke(this, e);
        }

        private static IEnumerable<IGraphNode> GetActorNodes(
            PhysicalSizePattern physicalSize,
            IGraphNode baseNode,
            IMap map)
        {
            yield return baseNode;

            if (physicalSize == PhysicalSizePattern.Size7)
            {
                var neighbors = map.GetNext(baseNode);
                foreach (var neighbor in neighbors)
                {
                    yield return neighbor;
                }
            }
        }

        private IDropTableScheme[] GetMonsterDropTables(IMonsterScheme monsterScheme)
        {
            if (monsterScheme.DropTableSids == null)
            {
                return Array.Empty<IDropTableScheme>();
            }

            var dropTableCount = monsterScheme.DropTableSids.Length;
            var schemes = new IDropTableScheme[dropTableCount];
            for (var i = 0; i < dropTableCount; i++)
            {
                var sid = monsterScheme.DropTableSids[i];
                if (sid is null)
                {
                    throw new InvalidOperationException();
                }

                schemes[i] = _schemeService.GetScheme<IDropTableScheme>(sid);
            }

            return schemes;
        }

        private static void HoldNodes(IGraphNode nextNode, IActor actor, IMap map)
        {
            var actorNodes = GetActorNodes(actor.Person.PhysicalSize, nextNode, map);

            foreach (var node in actorNodes)
            {
                map.HoldNode(node, actor);
            }
        }

        private void LootContainer_ItemsRemoved(object? sender, PropStoreEventArgs e)
        {
            if (sender is null)
            {
                throw new InvalidOperationException("The handler can work only for instance. Sender can't be null.");
            }

            var container = (IPropContainer)sender;

            if (!container.Content.CalcActualItems().Any())
            {
                var staticObject =
                    StaticObjectManager.Items.Single(x =>
                        ReferenceEquals(x.GetModuleSafe<IPropContainer>(), container));
                StaticObjectManager.Remove(staticObject);
            }
        }

        private void ProcessMonsterDeath(IActor actor)
        {
            if (actor is null)
            {
                throw new ArgumentNullException(nameof(actor));
            }

            if (actor.Person is not MonsterPerson monsterPerson)
            {
                return;
            }

            var monsterScheme = monsterPerson.Scheme;

            var dropSchemes = GetMonsterDropTables(monsterScheme);

            var loot = new DropTableLoot(dropSchemes, _dropResolver);

            var staticObject = new StaticObject(actor.Node, loot.Purpose, default);
            staticObject.AddModule<IPropContainer>(loot);

            if (loot.Content.CalcActualItems().Any())
            {
                StaticObjectManager.Add(staticObject);
            }

            if (ScoreManager != null)
            {
                ScoreManager.CountMonsterDefeat(monsterPerson);
            }
        }

        private static void ReleaseNodes(IActor actor, IMap map)
        {
            var actorNodes = GetActorNodes(actor.Person.PhysicalSize, actor.Node, map);

            foreach (var node in actorNodes)
            {
                map.ReleaseNode(node, actor);
            }
        }

        private void StaticObjectManager_Added(object? sender, ManagerItemsChangedEventArgs<IStaticObject> e)
        {
            foreach (var container in e.Items)
            {
                if (container.IsMapBlock)
                {
                    Map.HoldNode(container.Node, container);
                }

                if (container.GetModuleSafe<IPropContainer>() is ILootContainer lootContainer)
                {
                    lootContainer.ItemsRemoved += LootContainer_ItemsRemoved;
                }
            }
        }

        private void StaticObjectManager_Remove(object? sender, ManagerItemsChangedEventArgs<IStaticObject> e)
        {
            foreach (var container in e.Items)
            {
                if (container.IsMapBlock)
                {
                    Map.ReleaseNode(container.Node, container);
                }

                if (container.GetModule<IPropContainer>() is ILootContainer lootContainer)
                {
                    lootContainer.ItemsRemoved -= LootContainer_ItemsRemoved;
                }
            }
        }

        private void UpdateActorCombatActs()
        {
            foreach (var actor in ActorManager.Items.ToArray())
            {
                var combatActModule = actor.Person?.GetModuleSafe<ICombatActModule>();
                if (combatActModule is null)
                {
                    continue;
                }

                var combatActs = combatActModule.CalcCombatActs();

                foreach (var act in combatActs)
                {
                    act.UpdateCooldown();
                }
            }
        }

        private void UpdateActorEffects()
        {
            foreach (var actor in ActorManager.Items.ToArray())
            {
                var сonditions = actor.Person.GetModuleSafe<IConditionsModule>();

                if (сonditions is null)
                {
                    continue;
                }

                //TODO Выяснить, нужен ли ToArray() в effects.Items
                // Было добавлено, потому что в результате запуска одного из тестов для ботов
                // здесь выпало исключение, то коллекция изменилась.
                // Но раньше никогда этой ошибки не было ни в тестах, ни на клиенте.
                // Чтобы решить этот TODO, необходимо подобрать набор тестов, в результате которых
                // Items изменяется. Они должны падать, если убрать ToArray и выполняться, если его вернуть.
                foreach (var сondition in сonditions.Items.ToArray())
                {
                    if (сondition is ISurvivalStatCondition actorEffect &&
                        actor.Person.GetModuleSafe<ISurvivalModule>() != null)
                    {
                        actorEffect.Apply(actor.Person.GetModule<ISurvivalModule>());
                    }
                }
            }
        }

        private void UpdateDiseases()
        {
            foreach (var actor in ActorManager.Items.ToArray())
            {
                var deseaseModule = actor.Person.GetModuleSafe<IDiseaseModule>();
                if (deseaseModule is null)
                {
                    continue;
                }

                deseaseModule.Update();
            }
        }

        private void UpdateEquipments()
        {
            var actors = ActorManager.Items.ToArray();
            foreach (var actor in actors)
            {
                var equipmentCarrier = actor.Person.GetModuleSafe<IEquipmentModule>();
                if (equipmentCarrier is null)
                {
                    continue;
                }

                foreach (var equipment in equipmentCarrier)
                {
                    if (equipment == null)
                    {
                        // пустой слот.
                        continue;
                    }

                    _equipmentDurableService.UpdateByTurn(equipment, actor.Person);
                }
            }
        }

        private void UpdateFowData(IActor actor)
        {
            var fowModule = actor.Person.GetModuleSafe<IFowData>();
            if (fowModule != null)
            {
                var fowData = fowModule.GetSectorFowData(this);
                const int DISTANCE_OF_SIGN = 15;
                var fowContext = new FowContext(Map, StaticObjectManager);
                FowHelper.UpdateFowData(fowData, fowContext, actor.Node, DISTANCE_OF_SIGN);
            }
        }

        /// <summary>
        /// Processing special event:
        /// 1. There is counter.
        /// 2. When counter is out the special service create group of interventionists or militia.
        /// </summary>
        private void UpdateNationalUnityEvent()
        {
            if (NationalUnityEventService is null)
            {
                return;
            }

            _nationalUnityCounter--;
            if (_nationalUnityCounter <= 0)
            {
                if (NationalUnityEventService.RollEventIsRaised())
                {
                    NationalUnityEventService.RollAndCreateUnityGroupIntoSector(this);
                }

                _nationalUnityCounter = NATIONALUNITYCOUNTERSTARTVALUE;
            }
        }

        private void UpdateScores()
        {
            if (ScoreManager != null)
            {
                ScoreManager.CountTurn(Scheme);
            }
        }

        private void UpdateSurvivals()
        {
            var actors = ActorManager.Items.ToArray();
            foreach (var actor in actors)
            {
                var survival = actor.Person.GetModuleSafe<ISurvivalModule>();
                if (survival == null)
                {
                    continue;
                }

                survival.Update();
            }
        }

        /// <summary>
        /// Событие выстреливает, когда группа актёров игрока покинула сектор.
        /// </summary>
        public event EventHandler<TransitionUsedEventArgs>? TrasitionUsed;

        /// <summary>
        /// Карта в основе сектора.
        /// </summary>
        public ISectorMap Map { get; }

        /// <summary>
        /// Менеджер работы с очками.
        /// </summary>
        public IScoreManager? ScoreManager { get; set; }

        public ILocationScheme? Scheme { get; set; }
        public IActorManager ActorManager { get; }
        public IStaticObjectManager StaticObjectManager { get; }
        public IEnumerable<IDisease> Diseases => _diseases;

        public void AddDisease(IDisease disease)
        {
            _diseases.Add(disease);
        }

        /// <summary>
        /// Обновление состояния сектора.
        /// </summary>
        /// <remarks>
        /// Выполняет ход игрового сектора.
        /// Собирает текущие задачи для всех актёров в секторе.
        /// Выполняет все задачи для каждого актёра.
        /// </remarks>
        public void Update()
        {
            UpdateScores();

            UpdateSurvivals();

            UpdateActorEffects();

            UpdateDiseases();

            UpdateEquipments();

            UpdateActorCombatActs();

            UpdateNationalUnityEvent();
        }

        public void UseTransition(IActor actor, SectorTransition transition)
        {
            DoActorExit(actor, transition);
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5
6	using Zilon.Core.Diseases;
7	using Zilon.Core.Graphs;
8	using Zilon.Core.MapGenerators;
9	using Zilon.Core.PersonModules;
10	using Zilon.Core.Persons;
11	using Zilon.Core.Props;
12	using Zilon.Core.Schemes;
13	using Zilon.Core.Scoring;
14	using Zilon.Core.StaticObjectModules;
15	using Zilon.Core.Tactics.Behaviour;
16	using Zilon.Core.Tactics.Spatial;
17
18	namespace Zilon.Core.Tactics
19	{
20	/// <summary>
21	/// Базовая реализация сектора.
22	/// </summary>
23	/// <seealso cref="ISector" />
24	public class Sector : ISector
25	{
26	private const int NATIONALUNITYCOUNTERSTARTVALUE = 1000;
27
28	private readonly List<IDisease> _diseases;
29	private readonly IDropResolver _dropResolver;
30	private readonly IEquipmentDurableService _equipmentDurableService;
31	private readonly ISchemeService _schemeService;
32	private int _nationalUnityCounter = NATIONALUNITYCOUNTERSTARTVALUE;
33
34	[ExcludeFromCodeCoverage]
35	public Sector(ISectorMap map,
36	IActorManager actorManager,
37	IStaticObjectManager staticObjectManager,
38	IDropResolver dropResolver,
39	ISchemeService schemeService,
40	IEquipmentDurableService equipmentDurableService)
41	{
42	ActorManager = actorManager ?? throw new ArgumentNullException(nameof(actorManager));
43	StaticObjectManager = staticObjectManager ?? throw new ArgumentNullException(nameof(staticObjectManager));
44	_dropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
45	_schemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
46	_equipmentDurableService = equipmentDurableService ??
47	throw new ArgumentNullException(nameof(equipmentDurableService));
48
49	_diseases = new List<IDisease>();
50
51	ActorManager.Added += ActorManager_Added;
52	ActorManager.Removed += ActorManager_Remove;
53	StaticObjectManager.Added += StaticObjectManager_Added;
54	StaticObjectManager.Removed += StaticObjectManager_Remove;
55
56	Map = map ?? throw new ArgumentException("Не передана карта сектора.", nameof(map));
57	}
58
59	[ExcludeFromCodeCoverage]
60	public NationalUnityEventService? NationalUnityEventService { get; set; }
61
62	private void Actor_Moved(object? sender, EventArgs e)
63	{
64	if (sender is null)	32!
65	{
NEW 66	throw new InvalidOperationException("The handler can work only for instance. Sender can't be null.");	×
67	}
68
69	var actor = (IActor)sender;	32✔
70	UpdateFowData(actor);	32✔
71	}	32✔
72
73	private void ActorManager_Added(object? sender, ManagerItemsChangedEventArgs<IActor> e)
74	{
75	foreach (var actor in e.Items)	356✔
76	{
77	HoldNodes(actor.Node, actor, Map);	89✔
78
79	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	89✔
80	{
81	actor.Person.GetModule<ISurvivalModule>().Dead += ActorState_Dead;	89✔
82	}
83
84	actor.Moved += Actor_Moved;	89✔
85	UpdateFowData(actor);	89✔
86	}
87	}	89✔
88
89	private void ActorManager_Remove(object? sender, ManagerItemsChangedEventArgs<IActor> e)
90	{
91	// Когда актёры удалены из сектора, мы перестаём мониторить события на них.
92	foreach (var actor in e.Items)	24✔
93	{
94	ReleaseNodes(actor, Map);	6✔
95
96	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	6✔
97	{
98	actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;	6✔
99	}
100
101	actor.Moved -= Actor_Moved;	6✔
102	}
103	}	6✔
104
105	private void ActorState_Dead(object? sender, EventArgs e)
106	{
107	var actor = ActorManager.Items.Single(x =>	5✔
108	ReferenceEquals(x.Person.GetModuleSafe<ISurvivalModule>(), sender));	5✔
109	ActorManager.Remove(actor);	5✔
110
111	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	5✔
112	{
113	actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;	5✔
114	}
115
116	ProcessMonsterDeath(actor);	5✔
117	}	5✔
118
119	private void DoActorExit([NotNull] IActor actor, [NotNull] SectorTransition roomTransition)
120	{
121	var e = new TransitionUsedEventArgs(actor, roomTransition);	1✔
122	TrasitionUsed?.Invoke(this, e);	1!
123	}	1✔
124
125	private static IEnumerable<IGraphNode> GetActorNodes(
126	PhysicalSizePattern physicalSize,
127	IGraphNode baseNode,
128	IMap map)
129	{
130	yield return baseNode;
131
132	if (physicalSize == PhysicalSizePattern.Size7)
133	{
134	var neighbors = map.GetNext(baseNode);
135	foreach (var neighbor in neighbors)
136	{
137	yield return neighbor;
138	}
139	}
140	}
141
142	private IDropTableScheme[] GetMonsterDropTables(IMonsterScheme monsterScheme)
143	{
144	if (monsterScheme.DropTableSids == null)	3!
145	{
146	return Array.Empty<IDropTableScheme>();	×
147	}
148
149	var dropTableCount = monsterScheme.DropTableSids.Length;	3✔
150	var schemes = new IDropTableScheme[dropTableCount];	3✔
151	for (var i = 0; i < dropTableCount; i++)	24✔
152	{
153	var sid = monsterScheme.DropTableSids[i];	9✔
154	if (sid is null)	9!
155	{
156	throw new InvalidOperationException();	×
157	}
158
159	schemes[i] = _schemeService.GetScheme<IDropTableScheme>(sid);	9✔
160	}
161
162	return schemes;	3✔
163	}
164
165	private static void HoldNodes(IGraphNode nextNode, IActor actor, IMap map)
166	{
167	var actorNodes = GetActorNodes(actor.Person.PhysicalSize, nextNode, map);	89✔
168
169	foreach (var node in actorNodes)	356✔
170	{
171	map.HoldNode(node, actor);	89✔
172	}
173	}	89✔
174
175	private void LootContainer_ItemsRemoved(object? sender, PropStoreEventArgs e)
176	{
NEW 177	if (sender is null)	×
178	{
NEW 179	throw new InvalidOperationException("The handler can work only for instance. Sender can't be null.");	×
180	}
181
182	var container = (IPropContainer)sender;	×
183
UNCOV 184	if (!container.Content.CalcActualItems().Any())	×
185	{
186	var staticObject =	×
187	StaticObjectManager.Items.Single(x =>	×
188	ReferenceEquals(x.GetModuleSafe<IPropContainer>(), container));	×
189	StaticObjectManager.Remove(staticObject);	×
190	}
191	}	×
192
193	private void ProcessMonsterDeath(IActor actor)
194	{
195	if (actor is null)	5!
196	{
197	throw new ArgumentNullException(nameof(actor));	×
198	}
199
200	if (actor.Person is not MonsterPerson monsterPerson)	5✔
201	{
202	return;	2✔
203	}
204
205	var monsterScheme = monsterPerson.Scheme;	3✔
206
207	var dropSchemes = GetMonsterDropTables(monsterScheme);	3✔
208
209	var loot = new DropTableLoot(dropSchemes, _dropResolver);	3✔
210
211	var staticObject = new StaticObject(actor.Node, loot.Purpose, default);	3✔
212	staticObject.AddModule<IPropContainer>(loot);	3✔
213
214	if (loot.Content.CalcActualItems().Any())	3✔
215	{
216	StaticObjectManager.Add(staticObject);	3✔
217	}
218
219	if (ScoreManager != null)	3!
220	{
221	ScoreManager.CountMonsterDefeat(monsterPerson);	×
222	}
223	}	3✔
224
225	private static void ReleaseNodes(IActor actor, IMap map)
226	{
227	var actorNodes = GetActorNodes(actor.Person.PhysicalSize, actor.Node, map);	6✔
228
229	foreach (var node in actorNodes)	24✔
230	{
231	map.ReleaseNode(node, actor);	6✔
232	}
233	}	6✔
234
235	private void StaticObjectManager_Added(object? sender, ManagerItemsChangedEventArgs<IStaticObject> e)
236	{
237	foreach (var container in e.Items)	36✔
238	{
239	if (container.IsMapBlock)	9✔
240	{
241	Map.HoldNode(container.Node, container);	6✔
242	}
243
244	if (container.GetModuleSafe<IPropContainer>() is ILootContainer lootContainer)	9✔
245	{
246	lootContainer.ItemsRemoved += LootContainer_ItemsRemoved;	3✔
247	}
248	}
249	}	9✔
250
251	private void StaticObjectManager_Remove(object? sender, ManagerItemsChangedEventArgs<IStaticObject> e)
252	{
253	foreach (var container in e.Items)	8✔
254	{
255	if (container.IsMapBlock)	2✔
256	{
257	Map.ReleaseNode(container.Node, container);	2✔
258	}
259
260	if (container.GetModule<IPropContainer>() is ILootContainer lootContainer)	2!
261	{
262	lootContainer.ItemsRemoved -= LootContainer_ItemsRemoved;	×
263	}
264	}
265	}	2✔
266
267	private void UpdateActorCombatActs()
268	{
269	foreach (var actor in ActorManager.Items.ToArray())	26,786✔
270	{
271	var combatActModule = actor.Person?.GetModuleSafe<ICombatActModule>();	6,673!
272	if (combatActModule is null)	6,673✔
273	{
274	continue;
275	}
276
277	var combatActs = combatActModule.CalcCombatActs();	6,671✔
278
279	foreach (var act in combatActs)	26,760✔
280	{
281	act.UpdateCooldown();	6,709✔
282	}
283	}
284	}	6,720✔
285
286	private void UpdateActorEffects()
287	{
288	foreach (var actor in ActorManager.Items.ToArray())	26,788✔
289	{
290	var сonditions = actor.Person.GetModuleSafe<IConditionsModule>();	6,674✔
291
292	if (сonditions is null)	6,674✔
293	{
294	continue;
295	}
296
297	//TODO Выяснить, нужен ли ToArray() в effects.Items
298	// Было добавлено, потому что в результате запуска одного из тестов для ботов
299	// здесь выпало исключение, то коллекция изменилась.
300	// Но раньше никогда этой ошибки не было ни в тестах, ни на клиенте.
301	// Чтобы решить этот TODO, необходимо подобрать набор тестов, в результате которых
302	// Items изменяется. Они должны падать, если убрать ToArray и выполняться, если его вернуть.
303	foreach (var сondition in сonditions.Items.ToArray())	23,172✔
304	{
305	if (сondition is ISurvivalStatCondition actorEffect &&	4,958✔
306	actor.Person.GetModuleSafe<ISurvivalModule>() != null)	4,958✔
307	{
308	actorEffect.Apply(actor.Person.GetModule<ISurvivalModule>());	4,958✔
309	}
310	}
311	}
312	}	6,720✔
313
314	private void UpdateDiseases()
315	{
316	foreach (var actor in ActorManager.Items.ToArray())	26,786✔
317	{
318	var deseaseModule = actor.Person.GetModuleSafe<IDiseaseModule>();	6,673✔
319	if (deseaseModule is null)	6,673✔
320	{
321	continue;
322	}
323
324	deseaseModule.Update();	6,671✔
325	}
326	}	6,720✔
327
328	private void UpdateEquipments()
329	{
330	var actors = ActorManager.Items.ToArray();	6,720✔
331	foreach (var actor in actors)	26,786✔
332	{
333	var equipmentCarrier = actor.Person.GetModuleSafe<IEquipmentModule>();	6,673✔
334	if (equipmentCarrier is null)	6,673✔
335	{
336	continue;
337	}
338
339	foreach (var equipment in equipmentCarrier)	106,032✔
340	{
341	if (equipment == null)	46,389✔
342	{
343	// пустой слот.
344	continue;
345	}
346
347	_equipmentDurableService.UpdateByTurn(equipment, actor.Person);	50✔
348	}
349	}
350	}	6,720✔
351
352	private void UpdateFowData(IActor actor)
353	{
354	var fowModule = actor.Person.GetModuleSafe<IFowData>();	121✔
355	if (fowModule != null)	121!
356	{
357	var fowData = fowModule.GetSectorFowData(this);	×
358	const int DISTANCE_OF_SIGN = 15;
359	var fowContext = new FowContext(Map, StaticObjectManager);	×
360	FowHelper.UpdateFowData(fowData, fowContext, actor.Node, DISTANCE_OF_SIGN);	×
361	}
362	}	121✔
363
364	/// <summary>
365	/// Processing special event:
366	/// 1. There is counter.
367	/// 2. When counter is out the special service create group of interventionists or militia.
368	/// </summary>
369	private void UpdateNationalUnityEvent()
370	{
371	if (NationalUnityEventService is null)	6,720!
372	{
373	return;	6,720✔
374	}
375
376	_nationalUnityCounter--;	×
377	if (_nationalUnityCounter <= 0)	×
378	{
379	if (NationalUnityEventService.RollEventIsRaised())	×
380	{
381	NationalUnityEventService.RollAndCreateUnityGroupIntoSector(this);	×
382	}
383
384	_nationalUnityCounter = NATIONALUNITYCOUNTERSTARTVALUE;	×
385	}
386	}	×
387
388	private void UpdateScores()
389	{
390	if (ScoreManager != null)	6,720!
391	{
392	ScoreManager.CountTurn(Scheme);	×
393	}
394	}	6,720✔
395
396	private void UpdateSurvivals()
397	{
398	var actors = ActorManager.Items.ToArray();	6,720✔
399	foreach (var actor in actors)	26,788✔
400	{
401	var survival = actor.Person.GetModuleSafe<ISurvivalModule>();	6,674✔
402	if (survival == null)	6,674✔
403	{
404	continue;
405	}
406
407	survival.Update();	6,674✔
408	}
409	}	6,720✔
410
411	/// <summary>
412	/// Событие выстреливает, когда группа актёров игрока покинула сектор.
413	/// </summary>
414	public event EventHandler<TransitionUsedEventArgs>? TrasitionUsed;
415
416	/// <summary>
417	/// Карта в основе сектора.
418	/// </summary>
419	public ISectorMap Map { get; }
420
421	/// <summary>
422	/// Менеджер работы с очками.
423	/// </summary>
424	public IScoreManager? ScoreManager { get; set; }
425
426	public ILocationScheme? Scheme { get; set; }
427	public IActorManager ActorManager { get; }
428	public IStaticObjectManager StaticObjectManager { get; }
429	public IEnumerable<IDisease> Diseases => _diseases;	×
430
431	public void AddDisease(IDisease disease)
432	{
433	_diseases.Add(disease);	×
434	}	×
435
436	/// <summary>
437	/// Обновление состояния сектора.
438	/// </summary>
439	/// <remarks>
440	/// Выполняет ход игрового сектора.
441	/// Собирает текущие задачи для всех актёров в секторе.
442	/// Выполняет все задачи для каждого актёра.
443	/// </remarks>
444	public void Update()
445	{
446	UpdateScores();	6,720✔
447
448	UpdateSurvivals();	6,720✔
449
450	UpdateActorEffects();	6,720✔
451
452	UpdateDiseases();	6,720✔
453
454	UpdateEquipments();	6,720✔
455
456	UpdateActorCombatActs();	6,720✔
457
458	UpdateNationalUnityEvent();	6,720✔
459	}	6,720✔
460
461	public void UseTransition(IActor actor, SectorTransition transition)
462	{
463	DoActorExit(actor, transition);	1✔
464	}	1✔
465	}
466	}

kreghek / Zilon_Roguelike / 923900393

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