479643688

Build Type

github

Committed by GitHub

Commit Message

Merge 7a7446f02 into 022a51f71

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

Run Details

2317 of 3650 branches covered (63.48%)

Branch coverage included in aggregate %.

2 of 3 new or added lines in 2 files covered. (66.67%)

8 existing lines in 4 files now uncovered.

8475 of 12430 relevant lines covered (68.18%)

418270.79 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	{	11,346✔
78	var actor = (IActor)sender;	11,346✔
79	UpdateFowData(actor);	11,346✔
80	}	11,346✔
81
82	private void ActorManager_Added(object sender, ManagerItemsChangedEventArgs<IActor> e)
83	{	181✔
84	foreach (var actor in e.Items)	905✔
85	{	181✔
86	HoldNodes(actor.Node, actor, Map);	181✔
87
88	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	181✔
89	{	181✔
90	actor.Person.GetModule<ISurvivalModule>().Dead += ActorState_Dead;	181✔
91	}	181✔
92
93	actor.Moved += Actor_Moved;	181✔
94	UpdateFowData(actor);	181✔
95	}	181✔
96	}	181✔
97
98	private void ActorManager_Remove(object sender, ManagerItemsChangedEventArgs<IActor> e)
99	{	39✔
100	// Когда актёры удалены из сектора, мы перестаём мониторить события на них.
101	foreach (var actor in e.Items)	195✔
102	{	39✔
103	ReleaseNodes(actor, Map);	39✔
104
105	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	39✔
106	{	39✔
107	actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;	39✔
108	}	39✔
109
110	actor.Moved -= Actor_Moved;	39✔
111	}	39✔
112	}	39✔
113
114	private void ActorState_Dead(object sender, EventArgs e)
115	{	34✔
116	var actor = ActorManager.Items.Single(x =>	×
117	ReferenceEquals(x.Person.GetModuleSafe<ISurvivalModule>(), sender));	279✔
118	ActorManager.Remove(actor);	34✔
119
120	if (actor.Person.GetModuleSafe<ISurvivalModule>() != null)	34✔
121	{	34✔
122	actor.Person.GetModule<ISurvivalModule>().Dead -= ActorState_Dead;	34✔
123	}	34✔
124
125	ProcessMonsterDeath(actor);	34✔
126	}	34✔
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	{	220✔
139	yield return baseNode;	220✔
140
141	if (physicalSize == PhysicalSizePattern.Size7)	220!
142	{	×
143	var neighbors = map.GetNext(baseNode);	×
144	foreach (var neighbor in neighbors)	×
145	{	×
146	yield return neighbor;	×
147	}	×
148	}	×
149	}	220✔
150
151	private IDropTableScheme[] GetMonsterDropTables(IMonsterScheme monsterScheme)
152	{	28✔
153	if (monsterScheme.DropTableSids == null)	28!
154	{	×
155	return Array.Empty<IDropTableScheme>();	×
156	}
157
158	var dropTableCount = monsterScheme.DropTableSids.Length;	28✔
159	var schemes = new IDropTableScheme[dropTableCount];	28✔
160	for (var i = 0; i < dropTableCount; i++)	230✔
161	{	87✔
162	var sid = monsterScheme.DropTableSids[i];	87✔
163	schemes[i] = _schemeService.GetScheme<IDropTableScheme>(sid);	87✔
164	}	87✔
165
166	return schemes;	28✔
167	}	28✔
168
169	private static void HoldNodes(IGraphNode nextNode, IActor actor, IMap map)
170	{	181✔
171	var actorNodes = GetActorNodes(actor.Person.PhysicalSize, nextNode, map);	181✔
172
173	foreach (var node in actorNodes)	905✔
174	{	181✔
175	map.HoldNode(node, actor);	181✔
176	}	181✔
177	}	181✔
178
179	private void LootContainer_ItemsRemoved(object sender, PropStoreEventArgs e)
180	{	6✔
181	var container = (IPropContainer)sender;	6✔
182	if (!container.Content.CalcActualItems().Any())	6✔
183	{	3✔
184	var staticObject =	×
185	StaticObjectManager.Items.Single(x =>	×
186	ReferenceEquals(x.GetModuleSafe<IPropContainer>(), container));	244✔
187	StaticObjectManager.Remove(staticObject);	3✔
188	}	3✔
189	}	6✔
190
191	private void ProcessMonsterDeath(IActor actor)
192	{	34✔
193	if (actor is null)	34!
194	{	×
195	throw new ArgumentNullException(nameof(actor));	×
196	}
197
198	if (!(actor.Person is MonsterPerson monsterPerson))	34✔
199	{	6✔
200	return;	6✔
201	}
202
203	var monsterScheme = monsterPerson.Scheme;	28✔
204
205	var dropSchemes = GetMonsterDropTables(monsterScheme);	28✔
206
207	var loot = new DropTableLoot(dropSchemes, _dropResolver);	28✔
208
209	var staticObject = new StaticObject(actor.Node, loot.Purpose, default);	28✔
210	staticObject.AddModule<IPropContainer>(loot);	28✔
211
212	if (loot.Content.CalcActualItems().Any())	28✔
213	{	5✔
214	StaticObjectManager.Add(staticObject);	5✔
215	}	5✔
216
217	if (ScoreManager != null)	28✔
218	{	25✔
219	ScoreManager.CountMonsterDefeat(monsterPerson);	25✔
220	}	25✔
221	}	34✔
222
223	private static void ReleaseNodes(IActor actor, IMap map)
224	{	39✔
225	var actorNodes = GetActorNodes(actor.Person.PhysicalSize, actor.Node, map);	39✔
226
227	foreach (var node in actorNodes)	195✔
228	{	39✔
229	map.ReleaseNode(node, actor);	39✔
230	}	39✔
231	}	39✔
232
233	private void StaticObjectManager_Added(object sender, ManagerItemsChangedEventArgs<IStaticObject> e)
234	{	680✔
235	foreach (var container in e.Items)	3,400✔
236	{	680✔
237	if (container.IsMapBlock)	680✔
238	{	675✔
239	Map.HoldNode(container.Node, container);	675✔
240	}	675✔
241
242	if (container.GetModuleSafe<IPropContainer>() is ILootContainer lootContainer)	680✔
243	{	5✔
244	lootContainer.ItemsRemoved += LootContainer_ItemsRemoved;	5✔
245	}	5✔
246	}	680✔
247	}	680✔
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	{	14,412✔
267	foreach (var actor in ActorManager.Items.ToArray())	249,910✔
268	{	103,337✔
269	var combatActModule = actor.Person?.GetModuleSafe<ICombatActModule>();	103,337!
270	if (combatActModule is null)	103,337✔
271	{	2✔
272	continue;	2✔
273	}
274
275	var combatActs = combatActModule.CalcCombatActs();	103,335✔
276
277	foreach (var act in combatActs)	520,765✔
278	{	105,380✔
279	act.UpdateCooldown();	105,380✔
280	}	105,380✔
281	}	103,335✔
282	}	14,412✔
283
284	private void UpdateActorEffects()
285	{	14,412✔
286	foreach (var actor in ActorManager.Items.ToArray())	249,914✔
287	{	103,339✔
288	var effects = actor.Person.GetModuleSafe<IEffectsModule>();	103,339✔
289
290	if (effects is null)	103,339✔
291	{	93,769✔
292	continue;	93,769✔
293	}
294
295	//TODO Выяснить, нужен ли ToArray() в effects.Items
296	// Было добавлено, потому что в результате запуска одного из тестов для ботов
297	// здесь выпало исключение, то коллекция изменилась.
298	// Но раньше никогда этой ошибки не было ни в тестах, ни на клиенте.
299	// Чтобы решить этот TODO, необходимо подобрать набор тестов, в результате которых
300	// Items изменяется. Они должны падать, если убрать ToArray и выполняться, если его вернуть.
301	foreach (var effect in effects.Items.ToArray())	43,310✔
302	{	7,300✔
303	if (effect is ISurvivalStatEffect actorEffect &&	×
304	actor.Person.GetModuleSafe<ISurvivalModule>() != null)	×
305	{	7,300✔
306	actorEffect.Apply(actor.Person.GetModule<ISurvivalModule>());	7,300✔
307	}	7,300✔
308	}	7,300✔
309	}	9,570✔
310	}	14,412✔
311
312	private void UpdateDiseases()
313	{	14,412✔
314	foreach (var actor in ActorManager.Items.ToArray())	249,910✔
315	{	103,337✔
316	var deseaseModule = actor.Person.GetModuleSafe<IDiseaseModule>();	103,337✔
317	if (deseaseModule is null)	103,337✔
318	{	2✔
319	continue;	2✔
320	}
321
322	deseaseModule.Update();	103,335✔
323	}	103,335✔
324	}	14,412✔
325
326	private void UpdateEquipments()
327	{	14,412✔
328	var actors = ActorManager.Items.ToArray();	14,412✔
329	foreach (var actor in actors)	249,910✔
330	{	103,337✔
331	var equipmentCarrier = actor.Person.GetModuleSafe<IEquipmentModule>();	103,337✔
332	if (equipmentCarrier is null)	103,337✔
333	{	93,769✔
334	continue;	93,769✔
335	}
336
337	foreach (var equipment in equipmentCarrier)	162,656✔
338	{	66,976✔
339	if (equipment == null)	66,976✔
340	{	62,356✔
341	// пустой слот.
342	continue;	62,356✔
343	}
344
345	_equipmentDurableService.UpdateByTurn(equipment, actor.Person);	4,620✔
346	}	4,620✔
347	}	9,568✔
348	}	14,412✔
349
350	private void UpdateFowData(IActor actor)
351	{	11,527✔
352	var fowModule = actor.Person.GetModuleSafe<IFowData>();	11,527✔
353	if (fowModule != null)	11,527✔
354	{	634✔
355	var fowData = fowModule.GetSectorFowData(this);	634✔
356	const int DISTANCE_OF_SIGN = 5;
357	var fowContext = new FowContext(Map, StaticObjectManager);	634✔
358	FowHelper.UpdateFowData(fowData, fowContext, actor.Node, DISTANCE_OF_SIGN);	634✔
359	}	634✔
360	}	11,527✔
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	{	14,412✔
369	if (NationalUnityEventService is null)	14,412!
370	{	14,412✔
371	return;	14,412✔
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	}	14,412✔
385
386	private void UpdateScores()
387	{	14,412✔
388	if (ScoreManager != null)	14,412✔
389	{	7,692✔
390	ScoreManager.CountTurn(Scheme);	7,692✔
391	}	7,692✔
392	}	14,412✔
393
394	private void UpdateSurvivals()
395	{	14,412✔
396	var actors = ActorManager.Items.ToArray();	14,412✔
397	foreach (var actor in actors)	249,914✔
398	{	103,339✔
399	var survival = actor.Person.GetModuleSafe<ISurvivalModule>();	103,339✔
400	if (survival == null)	103,339!
401	{	×
402	continue;	×
403	}
404
405	survival.Update();	103,339✔
406	}	103,339✔
407	}	14,412✔
408
409	/// <summary>
410	/// Событие выстреливает, когда группа актёров игрока покинула сектор.
411	/// </summary>
412	public event EventHandler<TransitionUsedEventArgs> TrasitionUsed;
413
414	/// <summary>
415	/// Карта в основе сектора.
416	/// </summary>
417	public ISectorMap Map { get; }	32,027✔
418
419	/// <summary>
420	/// Менеджер работы с очками.
421	/// </summary>
422	public IScoreManager ScoreManager { get; set; }	22,165✔
423
424	public ILocationScheme Scheme { get; set; }	7,700✔
425	public IActorManager ActorManager { get; }	1,318,903✔
426	public IStaticObjectManager StaticObjectManager { get; }	3,176✔
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	{	14,412✔
444	UpdateScores();	14,412✔
445
446	UpdateSurvivals();	14,412✔
447
448	UpdateActorEffects();	14,412✔
449
450	UpdateDiseases();	14,412✔
451
452	UpdateEquipments();	14,412✔
453
454	UpdateActorCombatActs();	14,412✔
455
456	UpdateNationalUnityEvent();	14,412✔
457	}	14,412✔
458
459	public void UseTransition(IActor actor, SectorTransition transition)
460	{	5✔
461	DoActorExit(actor, transition);	5✔
462	}	5✔
463	}
464	}

kreghek / Zilon_Roguelike / 479643688

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