927607223

Build Type

github

Committed by GitHub

Commit Message

Merge 35f81b183 into 3567602cd

Pull Request Pull Request #1182: Feature loot

Run Details

1933 of 3700 branches covered (52.24%)

Branch coverage included in aggregate %.

36 of 45 new or added lines in 7 files covered. (80.0%)

1 existing line in 1 file now uncovered.

4975 of 7851 relevant lines covered (63.37%)

20916.09 hits per line

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

80.25

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

﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
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);

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

kreghek / Zilon_Roguelike / 927607223

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