904978311

Build Type

github

Committed by GitHub

Commit Message

Merge 645963723 into df45d3ffc

Pull Request Pull Request #1168: Feature hit and death sounds

Run Details

2280 of 3704 branches covered (61.56%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 3 files covered. (100.0%)

64 existing lines in 11 files now uncovered.

6102 of 8074 relevant lines covered (75.58%)

35590.62 hits per line

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

90.83

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

kreghek / Zilon_Roguelike / 904978311

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