956889049

Build Type

github

Committed by GitHub

Commit Message

Merge ce292dcb1 into 1fcec6eb0

Pull Request Pull Request #1196: Feature 1115 huge sectors

Run Details

1954 of 3759 branches covered (51.98%)

Branch coverage included in aggregate %.

72 of 125 new or added lines in 11 files covered. (57.6%)

3 existing lines in 2 files now uncovered.

5028 of 7956 relevant lines covered (63.2%)

37043.0 hits per line

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

76.52

/Zilon.Core/Zilon.Core/World/Globe.cs

﻿using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Behaviour;

namespace Zilon.Core.World
{
    /// <summary>
    /// Globe base implementation.
    /// </summary>
    public sealed class Globe : IGlobe
    {
        private readonly IGlobeTransitionHandler _globeTransitionHandler;

        private readonly IList<ISectorNode> _sectorNodes;

        private readonly ConcurrentDictionary<IActor, TaskState> _taskDict;

        private int _turnCounter;

        public Globe(IGlobeTransitionHandler globeTransitionHandler)
        {
            _taskDict = new ConcurrentDictionary<IActor, TaskState>();

            _sectorNodes = new List<ISectorNode>();

            _globeTransitionHandler =
                globeTransitionHandler ?? throw new ArgumentNullException(nameof(globeTransitionHandler));
        }

        private void ActorManager_Removed(object? sender, ManagerItemsChangedEventArgs<IActor> e)
        {
            // Remove all current tasks
            foreach (var removedActor in e.Items)
            {
                RemoveActorTaskState(removedActor);
            }
        }

        private static void ClearUpTasks(IDictionary<IActor, TaskState> taskDict)
        {
            // удаляем выполненные задачи.
            var allStateCopyList = taskDict.Values.ToArray();
            foreach (var state in allStateCopyList)
            {
                var actor = state.Actor;

                if (state.TaskComplete)
                {
                    taskDict.Remove(actor);
                    state.TaskSource.ProcessTaskComplete(state.Task);
                    continue;
                }

                if (!actor.CanExecuteTasks)
                {
                    // Песонаж может перестать выполнять задачи по следующим причинам:
                    // 1. Персонажи, у которых есть модуль выживания, могут умереть.
                    // Мертвые персонажы не выполняют задач.
                    // Их задачи можно прервать, потому что:
                    //   * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
                    //   * Экономит ресурсы.
                    taskDict.Remove(actor);
                }
            }
        }

        private async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList,
            CancellationToken cancelToken)
        {
            var actorDataListMaterialized = actorDataList.ToArray();

            var actorGrouppedBySector = actorDataListMaterialized.GroupBy(x => x.Sector).ToArray();

            foreach (var sectorGroup in actorGrouppedBySector)
            {
                foreach (var actorDataItem in sectorGroup)
                {
                    var actor = actorDataItem.Actor;
                    var sector = actorDataItem.Sector;

                    var taskSource = actor.TaskSource;

                    var context = new SectorTaskSourceContext(sector, cancelToken);

                    try
                    {
                        if (taskSource is IHumanActorTaskSource<SectorTaskSourceContext> humanTaskSource)
                        {
                            // Drop intention for human controlled task source.
                            cancelToken.Register(() => { humanTaskSource.DropIntentionWaiting(); });
                        }

                        var actorTask = await taskSource.GetActorTaskAsync(actor, context).ConfigureAwait(false);

                        var state = new TaskState(actor, sector, actorTask, taskSource);

                        _taskDict.AddOrUpdate(actor, state, (a, t) => state);
                    }
                    catch (TaskCanceledException)
                    {
                        // Do nothing for his actor. His task was cancelled.
                        _taskDict.TryRemove(actor, out var _);
                    }
                }
            }
        }

        private IEnumerable<ActorInSector> GetActorsWithoutTasks()
        {
            return GetActorsWithoutTasksEnumerator().ToArray();
        }

        private IEnumerable<ActorInSector> GetActorsWithoutTasksEnumerator()
        {
            // _sectorNodes фиксируем в отдельный массив.
            // потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
            // Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
            var sectorNodes = _sectorNodes.ToArray();
            foreach (var sectorNode in sectorNodes)
            {
                if (sectorNode.State != SectorNodeState.SectorMaterialized)
                {
                    continue;
                }

                var sector = sectorNode.Sector;
                if (sector is null)
                {
                    if (sectorNode.State == SectorNodeState.SectorMaterialized)
                    {
                        throw new InvalidOperationException();
                    }

                    continue;
                }

                var actors = sector.ActorManager.Items.ToArray();
                foreach (var actor in actors)
                {
                    var needCreateTask = IsActorNeedsInTask(sector, actor);

                    if (needCreateTask)
                    {
                        yield return new ActorInSector(actor, sector);
                    }
                }
            }
        }

        private static List<TaskState[]> GroupTaskStates(ICollection<TaskState> states)
        {
            var statesGroupedBySector = states.GroupBy(x => x.Sector).ToArray();
            var materializedSectorList = MaterializeSectorStates(statesGroupedBySector);
            return materializedSectorList;
        }

        private bool IsActorNeedsInTask(ISector sector, IActor actor)
        {
            if (!sector.ActorManager.Items.Contains(actor))
            {
                // Это может произойти, когда в процессе исполнения задач,
                // актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.

                RemoveActorTaskState(actor);

                return false;
            }

            if (_taskDict.TryGetValue(actor, out _))
            {
                // Actor has task yet.

                return false;
            }

            return true;
        }

        private static bool IsPlayerActorControlledByHuman(IActorTaskSource<ISectorTaskSourceContext> taskSource)
        {
            if (taskSource is IActorTaskControlSwitcher controlSwitcher)
            {
                return controlSwitcher.CurrentControl == ActorTaskSourceControl.Human;
            }

            return true;
        }

        private static List<TaskState[]> MaterializeSectorStates(IGrouping<ISector, TaskState>[] statesGroupedBySector)
        {
            var materializedSectorList = new List<TaskState[]>();
            foreach (var sectorStates in statesGroupedBySector)
            {
                materializedSectorList.Add(sectorStates.ToArray());
            }

            return materializedSectorList;
        }

        private static void ProcessActorStates(IEnumerable<TaskState> states)
        {
            foreach (var state in states)
            {
                if (!state.Actor.CanExecuteTasks)
                {
                    // По сути, возможность выполнять задачи - это основая роль этого объекта.
                    // песонаж может перестать выполнять задачи по следующим причинам:
                    // 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
                    // Мертвые персонажы не выполняют задач.
                    // Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
                    // что противоречит логике задач.
                    continue;
                }

                state.UpdateCounter();

                if (state.TaskIsExecuting)
                {
                    state.Task.Execute();

                    state.TaskSource.ProcessTaskExecuted(state.Task);
                }
            }
        }

        private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
        {
            var states = taskDict.Values;
            var materializedSectorList = GroupTaskStates(states);

            foreach (var sectorStates in materializedSectorList)
            {
                var orderedStates = SortActorStates(sectorStates);
                ProcessActorStates(orderedStates);
            }

            ClearUpTasks(taskDict);
        }

        private void RemoveActorTaskState(IActor actor)
        {
            if (_taskDict.TryRemove(actor, out var taskState))
            {
                taskState.TaskSource.CancelTask(taskState.Task);
            }
            else
            {
                if (actor.TaskSource is IHumanActorTaskSource<ISectorTaskSourceContext> humanTaskSource)
                {
                    var isPlayerActorControlledByHuman = IsPlayerActorControlledByHuman(actor.TaskSource);
                    if (isPlayerActorControlledByHuman)
                    {
                        humanTaskSource.DropIntentionWaiting();
                    }
                }
            }
        }

        private void Sector_TrasitionUsed(object? sender, TransitionUsedEventArgs e)
        {
            if (sender is null)
            {
                throw new InvalidOperationException("Invalid event sender. It must be not null.");
            }

            var sector = (ISector)sender;

            _globeTransitionHandler.InitActorTransitionAsync(this, sector, e.Actor, e.Transition).Wait(10_000);
        }

        private static TaskState[] SortActorStates(IEnumerable<TaskState> sectorStates)
        {
            // Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
            // Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
            // В этом случае порядок элементов, полученных из states, не фиксирован.
            // В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
            // Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
            // Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.

            return sectorStates.OrderBy(x => x.Actor.Person.Id).ToArray();
        }

        public IEnumerable<ISectorNode> SectorNodes => _sectorNodes;

        public void AddSectorNode(ISectorNode sectorNode)
        {
            if (sectorNode is null)
            {
                throw new ArgumentNullException(nameof(sectorNode));
            }

            _sectorNodes.Add(sectorNode);
            var sector = sectorNode.Sector;
            if (sector is null)
            {
                throw new InvalidOperationException();
            }

            sector.TrasitionUsed += Sector_TrasitionUsed;
            sector.ActorManager.Removed += ActorManager_Removed;
        }

        public async Task UpdateAsync(CancellationToken cancelToken)
        {
            var actorsWithoutTasks = GetActorsWithoutTasks();

            await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks, cancelToken).ConfigureAwait(false);

            ProcessTasks(_taskDict);

            _turnCounter++;

            if (_turnCounter >= GlobeMetrics.OneIterationLength)
            {
                _turnCounter = GlobeMetrics.OneIterationLength - _turnCounter;

                foreach (var sectorNode in _sectorNodes)
                {
                    var sector = sectorNode.Sector;
                    if (sector is null)
                    {
                        if (sectorNode.State == SectorNodeState.SectorMaterialized)
                        {
                            throw new InvalidOperationException();
                        }

                        continue;
                    }

                    sector.Update();
                }

                _globeTransitionHandler.UpdateTransitions();
            }
        }

        private sealed class ActorInSector
        {
            public ActorInSector(IActor actor, ISector sector)
            {
                Actor = actor;
                Sector = sector;
            }

            public IActor Actor { get; }
            public ISector Sector { get; }
        }
    }
}

1	using System;
2	using System.Collections.Concurrent;
3	using System.Collections.Generic;
4	using System.Linq;
5	using System.Threading;
6	using System.Threading.Tasks;
7
8	using Zilon.Core.Tactics;
9	using Zilon.Core.Tactics.Behaviour;
10
11	namespace Zilon.Core.World
12	{
13	/// <summary>
14	/// Globe base implementation.
15	/// </summary>
16	public sealed class Globe : IGlobe
17	{
18	private readonly IGlobeTransitionHandler _globeTransitionHandler;
19
20	private readonly IList<ISectorNode> _sectorNodes;
21
22	private readonly ConcurrentDictionary<IActor, TaskState> _taskDict;
23
24	private int _turnCounter;
25
26	public Globe(IGlobeTransitionHandler globeTransitionHandler)	68✔
27	{
28	_taskDict = new ConcurrentDictionary<IActor, TaskState>();	68✔
29
30	_sectorNodes = new List<ISectorNode>();	68✔
31
32	_globeTransitionHandler =	68!
33	globeTransitionHandler ?? throw new ArgumentNullException(nameof(globeTransitionHandler));	68✔
34	}	68✔
35
36	private void ActorManager_Removed(object? sender, ManagerItemsChangedEventArgs<IActor> e)
37	{
38	// Remove all current tasks
39	foreach (var removedActor in e.Items)	24✔
40	{
41	RemoveActorTaskState(removedActor);	6✔
42	}
43	}	6✔
44
45	private static void ClearUpTasks(IDictionary<IActor, TaskState> taskDict)
46	{
47	// удаляем выполненные задачи.
48	var allStateCopyList = taskDict.Values.ToArray();	67,160✔
49	foreach (var state in allStateCopyList)	267,800✔
50	{
51	var actor = state.Actor;	66,740✔
52
53	if (state.TaskComplete)	66,740✔
54	{
55	taskDict.Remove(actor);	21,700✔
56	state.TaskSource.ProcessTaskComplete(state.Task);	21,700✔
57	continue;	21,700✔
58	}
59
60	if (!actor.CanExecuteTasks)	45,040!
61	{
62	// Песонаж может перестать выполнять задачи по следующим причинам:
63	// 1. Персонажи, у которых есть модуль выживания, могут умереть.
64	// Мертвые персонажы не выполняют задач.
65	// Их задачи можно прервать, потому что:
66	// * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
67	// * Экономит ресурсы.
68	taskDict.Remove(actor);	×
69	}
70	}
71	}	67,160✔
72
73	private async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList,
74	CancellationToken cancelToken)
75	{
76	var actorDataListMaterialized = actorDataList.ToArray();
77
78	var actorGrouppedBySector = actorDataListMaterialized.GroupBy(x => x.Sector).ToArray();
79
80	foreach (var sectorGroup in actorGrouppedBySector)
81	{
82	foreach (var actorDataItem in sectorGroup)
83	{
84	var actor = actorDataItem.Actor;
85	var sector = actorDataItem.Sector;
86
87	var taskSource = actor.TaskSource;
88
89	var context = new SectorTaskSourceContext(sector, cancelToken);
90
91	try
92	{
93	if (taskSource is IHumanActorTaskSource<SectorTaskSourceContext> humanTaskSource)
94	{
95	// Drop intention for human controlled task source.
96	cancelToken.Register(() => { humanTaskSource.DropIntentionWaiting(); });
97	}
98
99	var actorTask = await taskSource.GetActorTaskAsync(actor, context).ConfigureAwait(false);
100
101	var state = new TaskState(actor, sector, actorTask, taskSource);
102
103	_taskDict.AddOrUpdate(actor, state, (a, t) => state);
104	}
105	catch (TaskCanceledException)
106	{
107	// Do nothing for his actor. His task was cancelled.
108	_taskDict.TryRemove(actor, out var _);
109	}
110	}
111	}
112	}
113
114	private IEnumerable<ActorInSector> GetActorsWithoutTasks()
115	{
116	return GetActorsWithoutTasksEnumerator().ToArray();	67,160✔
117	}
118
119	private IEnumerable<ActorInSector> GetActorsWithoutTasksEnumerator()
120	{
121	// _sectorNodes фиксируем в отдельный массив.
122	// потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
123	// Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
124	var sectorNodes = _sectorNodes.ToArray();
125	foreach (var sectorNode in sectorNodes)
126	{
127	if (sectorNode.State != SectorNodeState.SectorMaterialized)
128	{
129	continue;
130	}
131
132	var sector = sectorNode.Sector;
133	if (sector is null)
134	{
135	if (sectorNode.State == SectorNodeState.SectorMaterialized)
136	{
137	throw new InvalidOperationException();
138	}
139
140	continue;
141	}
142
143	var actors = sector.ActorManager.Items.ToArray();
144	foreach (var actor in actors)
145	{
146	var needCreateTask = IsActorNeedsInTask(sector, actor);
147
148	if (needCreateTask)
149	{
150	yield return new ActorInSector(actor, sector);
151	}
152	}
153	}
154	}
155
156	private static List<TaskState[]> GroupTaskStates(ICollection<TaskState> states)
157	{
158	var statesGroupedBySector = states.GroupBy(x => x.Sector).ToArray();	67,160✔
159	var materializedSectorList = MaterializeSectorStates(statesGroupedBySector);	67,160✔
160	return materializedSectorList;	67,160✔
161	}
162
163	private bool IsActorNeedsInTask(ISector sector, IActor actor)
164	{
165	if (!sector.ActorManager.Items.Contains(actor))	66,745!
166	{
167	// Это может произойти, когда в процессе исполнения задач,
168	// актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.
169
170	RemoveActorTaskState(actor);	×
171
172	return false;	×
173	}
174
175	if (_taskDict.TryGetValue(actor, out _))	66,745✔
176	{
177	// Actor has task yet.
178
179	return false;	45,030✔
180	}
181
182	return true;	21,715✔
183	}
184
185	private static bool IsPlayerActorControlledByHuman(IActorTaskSource<ISectorTaskSourceContext> taskSource)
186	{
187	if (taskSource is IActorTaskControlSwitcher controlSwitcher)	×
188	{
189	return controlSwitcher.CurrentControl == ActorTaskSourceControl.Human;	×
190	}
191
192	return true;	×
193	}
194
195	private static List<TaskState[]> MaterializeSectorStates(IGrouping<ISector, TaskState>[] statesGroupedBySector)
196	{
197	var materializedSectorList = new List<TaskState[]>();	67,160✔
198	foreach (var sectorStates in statesGroupedBySector)	267,110✔
199	{
200	materializedSectorList.Add(sectorStates.ToArray());	66,395✔
201	}
202
203	return materializedSectorList;	67,160✔
204	}
205
206	private static void ProcessActorStates(IEnumerable<TaskState> states)
207	{
208	foreach (var state in states)	266,280✔
209	{
210	if (!state.Actor.CanExecuteTasks)	66,745✔
211	{
212	// По сути, возможность выполнять задачи - это основая роль этого объекта.
213	// песонаж может перестать выполнять задачи по следующим причинам:
214	// 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
215	// Мертвые персонажы не выполняют задач.
216	// Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
217	// что противоречит логике задач.
218	continue;
219	}
220
221	state.UpdateCounter();	66,742✔
222
223	if (state.TaskIsExecuting)	66,742✔
224	{
225	state.Task.Execute();	21,706✔
226
227	state.TaskSource.ProcessTaskExecuted(state.Task);	21,706✔
228	}
229	}
230	}	66,395✔
231
232	private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
233	{
234	var states = taskDict.Values;	67,160✔
235	var materializedSectorList = GroupTaskStates(states);	67,160✔
236
237	foreach (var sectorStates in materializedSectorList)	267,110✔
238	{
239	var orderedStates = SortActorStates(sectorStates);	66,395✔
240	ProcessActorStates(orderedStates);	66,395✔
241	}
242
243	ClearUpTasks(taskDict);	67,160✔
244	}	67,160✔
245
246	private void RemoveActorTaskState(IActor actor)
247	{
248	if (_taskDict.TryRemove(actor, out var taskState))	6!
249	{
250	taskState.TaskSource.CancelTask(taskState.Task);	6✔
251	}
252	else
253	{
254	if (actor.TaskSource is IHumanActorTaskSource<ISectorTaskSourceContext> humanTaskSource)	×
255	{
256	var isPlayerActorControlledByHuman = IsPlayerActorControlledByHuman(actor.TaskSource);	×
257	if (isPlayerActorControlledByHuman)	×
258	{
259	humanTaskSource.DropIntentionWaiting();	×
260	}
261	}
262	}
263	}	×
264
265	private void Sector_TrasitionUsed(object? sender, TransitionUsedEventArgs e)
266	{
267	if (sender is null)	1!
268	{
UNCOV 269	throw new InvalidOperationException("Invalid event sender. It must be not null.");	×
270	}
271
272	var sector = (ISector)sender;	1✔
273
274	_globeTransitionHandler.InitActorTransitionAsync(this, sector, e.Actor, e.Transition).Wait(10_000);	1✔
275	}	1✔
276
277	private static TaskState[] SortActorStates(IEnumerable<TaskState> sectorStates)
278	{
279	// Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
280	// Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
281	// В этом случае порядок элементов, полученных из states, не фиксирован.
282	// В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
283	// Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
284	// Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.
285
286	return sectorStates.OrderBy(x => x.Actor.Person.Id).ToArray();	66,395✔
287	}
288
289	public IEnumerable<ISectorNode> SectorNodes => _sectorNodes;	43,591✔
290
291	public void AddSectorNode(ISectorNode sectorNode)
292	{
293	if (sectorNode is null)	69!
294	{
295	throw new ArgumentNullException(nameof(sectorNode));	×
296	}
297
298	_sectorNodes.Add(sectorNode);	69✔
299	var sector = sectorNode.Sector;	69✔
300	if (sector is null)	69!
301	{
302	throw new InvalidOperationException();	×
303	}
304
305	sector.TrasitionUsed += Sector_TrasitionUsed;	69✔
306	sector.ActorManager.Removed += ActorManager_Removed;	69✔
307	}	69✔
308
309	public async Task UpdateAsync(CancellationToken cancelToken)
310	{
311	var actorsWithoutTasks = GetActorsWithoutTasks();
312
313	await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks, cancelToken).ConfigureAwait(false);
314
315	ProcessTasks(_taskDict);
316
317	_turnCounter++;
318
319	if (_turnCounter >= GlobeMetrics.OneIterationLength)
320	{
321	_turnCounter = GlobeMetrics.OneIterationLength - _turnCounter;
322
323	foreach (var sectorNode in _sectorNodes)
324	{
325	var sector = sectorNode.Sector;
326	if (sector is null)
327	{
328	if (sectorNode.State == SectorNodeState.SectorMaterialized)
329	{
330	throw new InvalidOperationException();
331	}
332
333	continue;
334	}
335
336	sector.Update();
337	}
338
339	_globeTransitionHandler.UpdateTransitions();
340	}
341	}
342
343	private sealed class ActorInSector
344	{
345	public ActorInSector(IActor actor, ISector sector)	21,715✔
346	{
347	Actor = actor;	21,715✔
348	Sector = sector;	21,715✔
349	}	21,715✔
350
351	public IActor Actor { get; }
352	public ISector Sector { get; }
353	}
354	}
355	}

kreghek / Zilon_Roguelike / 956889049

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