479229218

Build Type

github

Committed by GitHub

Commit Message

Merge 06bb87e5e into 022a51f71

Pull Request Pull Request #1003: Fix 986 restore code coverage gate passing unit

Run Details

2276 of 3720 branches covered (61.18%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

4 existing lines in 2 files now uncovered.

8455 of 12775 relevant lines covered (66.18%)

335290.44 hits per line

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

87.93

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

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

using JetBrains.Annotations;

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.Behaviour.Bots;
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));
        }

        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        public NationalUnityEventService NationalUnityEventService { get; set; }

        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        public string Sid { get; set; }

        /// <summary>
        /// Стартовые узлы.
        /// Набор узлов, где могут располагаться актёры игрока
        /// на начало прохождения сектора.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        public IGraphNode[] StartNodes { 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];
                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 effects = actor.Person.GetModuleSafe<IEffectsModule>();

                if (effects is null)
                {
                    continue;
                }

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

kreghek / Zilon_Roguelike / 479229218

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