654531746

Build Type

github

Committed by GitHub

Commit Message

Merge c0f35f950 into 54b1be009

Pull Request Pull Request #1056: Fix 967 transition break game

Run Details

2148 of 3426 branches covered (62.7%)

Branch coverage included in aggregate %.

7 of 8 new or added lines in 2 files covered. (87.5%)

5 existing lines in 2 files now uncovered.

5881 of 7658 relevant lines covered (76.8%)

59812.63 hits per line

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

88.89

/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);
                        if (!_taskDict.TryAdd(actor, state))
                        {
                            //// Это происходит, когда игрок пытается присвоить новую команду,
                            //// когда старая еще не закончена и не может быть заменена.
                            //throw new InvalidOperationException(
                            //    "Попытка назначить задачу, когда старая еще не удалена.");
                        }
                    }
                    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;

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

                    if (needCreateTask)
                    {
                        yield return new ActorInSector
                        {
                            Actor = actor,
                            Sector = 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 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)
                {
                    humanTaskSource.DropIntentionWaiting();
                }
            }
        }

        private async void Sector_TrasitionUsed(object sender, TransitionUsedEventArgs e)
        {
            var sector = (ISector)sender;
            await _globeTransitionHandler.InitActorTransitionAsync(this, sector, e.Actor, e.Transition)
                .ConfigureAwait(false);
        }

        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);
            sectorNode.Sector.TrasitionUsed += Sector_TrasitionUsed;
            sectorNode.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)
                {
                    if (sectorNode.State != SectorNodeState.SectorMaterialized)
                    {
                        continue;
                    }

                    sectorNode.Sector.Update();
                }

                _globeTransitionHandler.UpdateTransitions();
            }
        }

        private sealed class ActorInSector
        {
            public IActor Actor { get; set; }
            public ISector Sector { get; set; }
        }
    }
}

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	private int _turnCounter;
24
25	public Globe(IGlobeTransitionHandler globeTransitionHandler)	72✔
26	{
27	_taskDict = new ConcurrentDictionary<IActor, TaskState>();	72✔
28
29	_sectorNodes = new List<ISectorNode>();	72✔
30
31	_globeTransitionHandler =	72!
32	globeTransitionHandler ?? throw new ArgumentNullException(nameof(globeTransitionHandler));	72✔
33	}	72✔
34
35	private void ActorManager_Removed(object sender, ManagerItemsChangedEventArgs<IActor> e)
36	{
37	// Remove all current tasks
38	foreach (var removedActor in e.Items)	296✔
39	{
40	RemoveActorTaskState(removedActor);	74✔
41	}
42	}	74✔
43
44	private static void ClearUpTasks(IDictionary<IActor, TaskState> taskDict)
45	{
46	// удаляем выполненные задачи.
47	var allStateCopyList = taskDict.Values.ToArray();	82,820✔
48	foreach (var state in allStateCopyList)	681,116✔
49	{
50	var actor = state.Actor;	257,738✔
51
52	if (state.TaskComplete)	257,738✔
53	{
54	taskDict.Remove(actor);	51,796✔
55	state.TaskSource.ProcessTaskComplete(state.Task);	51,796✔
56	continue;	51,796✔
57	}
58
59	if (!actor.CanExecuteTasks)	205,942!
60	{
61	// Песонаж может перестать выполнять задачи по следующим причинам:
62	// 1. Персонажи, у которых есть модуль выживания, могут умереть.
63	// Мертвые персонажы не выполняют задач.
64	// Их задачи можно прервать, потому что:
65	// * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
66	// * Экономит ресурсы.
NEW 67	taskDict.Remove(actor);	×
68	}
69	}
70	}	82,820✔
71
72	private async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList,
73	CancellationToken cancelToken)
74	{
75	var actorDataListMaterialized = actorDataList.ToArray();
76
77	var actorGrouppedBySector = actorDataListMaterialized.GroupBy(x => x.Sector).ToArray();
78
79	foreach (var sectorGroup in actorGrouppedBySector)
80	{
81	foreach (var actorDataItem in sectorGroup)
82	{
83	var actor = actorDataItem.Actor;
84	var sector = actorDataItem.Sector;
85
86	var taskSource = actor.TaskSource;
87
88	var context = new SectorTaskSourceContext(sector, cancelToken);
89
90	try
91	{
92	if (taskSource is IHumanActorTaskSource<SectorTaskSourceContext> humanTaskSource)
93	{
94	// Drop intention for human controlled task source.
95	cancelToken.Register(() => { humanTaskSource.DropIntentionWaiting(); });
96	}
97
98	var actorTask = await taskSource.GetActorTaskAsync(actor, context).ConfigureAwait(false);
99
100	var state = new TaskState(actor, sector, actorTask, taskSource);
101	if (!_taskDict.TryAdd(actor, state))
102	{
103	//// Это происходит, когда игрок пытается присвоить новую команду,
104	//// когда старая еще не закончена и не может быть заменена.
105	//throw new InvalidOperationException(
106	// "Попытка назначить задачу, когда старая еще не удалена.");
107	}
108	}
109	catch (TaskCanceledException)
110	{
111	// Do nothing for his actor. His task was cancelled.
112	_taskDict.TryRemove(actor, out var _);
113	}
114	}
115	}
116	}
117
118	private IEnumerable<ActorInSector> GetActorsWithoutTasks()
119	{
120	return GetActorsWithoutTasksEnumerator().ToArray();	82,820✔
121	}
122
123	private IEnumerable<ActorInSector> GetActorsWithoutTasksEnumerator()
124	{
125	// _sectorNodes фиксируем в отдельный массив.
126	// потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
127	// Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
128	var sectorNodes = _sectorNodes.ToArray();
129	foreach (var sectorNode in sectorNodes)
130	{
131	if (sectorNode.State != SectorNodeState.SectorMaterialized)
132	{
133	continue;
134	}
135
136	var sector = sectorNode.Sector;
137
138	var actors = sector.ActorManager.Items.ToArray();
139	foreach (var actor in actors)
140	{
141	var needCreateTask = IsActorNeedsInTask(sector, actor);
142
143	if (needCreateTask)
144	{
145	yield return new ActorInSector
146	{
147	Actor = actor,
148	Sector = sector
149	};
150	}
151	}
152	}
153	}
154
155	private static List<TaskState[]> GroupTaskStates(ICollection<TaskState> states)
156	{
157	var statesGroupedBySector = states.GroupBy(x => x.Sector).ToArray();	82,820✔
158	var materializedSectorList = MaterializeSectorStates(statesGroupedBySector);	82,820✔
159	return materializedSectorList;	82,820✔
160	}
161
162	private bool IsActorNeedsInTask(ISector sector, IActor actor)
163	{
164	if (!sector.ActorManager.Items.Contains(actor))	257,790!
165	{
166	// Это может произойти, когда в процессе исполнения задач,
167	// актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.
168
169	RemoveActorTaskState(actor);	×
170
171	return false;	×
172	}
173
174	if (_taskDict.TryGetValue(actor, out _))	257,790✔
175	{
176	// Actor has task yet.
177
178	return false;	205,838✔
179	}
180
181	return true;	51,952✔
182	}
183
184	private static List<TaskState[]> MaterializeSectorStates(IGrouping<ISector, TaskState>[] statesGroupedBySector)
185	{
186	var materializedSectorList = new List<TaskState[]>();	82,820✔
187	foreach (var sectorStates in statesGroupedBySector)	330,508✔
188	{
189	materializedSectorList.Add(sectorStates.ToArray());	82,434✔
190	}
191
192	return materializedSectorList;	82,820✔
193	}
194
195	private static void ProcessActorStates(IEnumerable<TaskState> states)
196	{
197	foreach (var state in states)	680,476✔
198	{
199	if (!state.Actor.CanExecuteTasks)	257,804✔
200	{
201	// По сути, возможность выполнять задачи - это основая роль этого объекта.
202	// песонаж может перестать выполнять задачи по следующим причинам:
203	// 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
204	// Мертвые персонажы не выполняют задач.
205	// Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
206	// что противоречит логике задач.
207	continue;
208	}
209
210	state.UpdateCounter();	257,774✔
211
212	if (state.TaskIsExecuting)	257,774✔
213	{
214	state.Task.Execute();	51,878✔
215
216	state.TaskSource.ProcessTaskExecuted(state.Task);	51,878✔
217	}
218	}
219	}	82,434✔
220
221	private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
222	{
223	var states = taskDict.Values;	82,820✔
224	var materializedSectorList = GroupTaskStates(states);	82,820✔
225
226	foreach (var sectorStates in materializedSectorList)	330,508✔
227	{
228	var orderedStates = SortActorStates(sectorStates);	82,434✔
229	ProcessActorStates(orderedStates);	82,434✔
230	}
231
232	ClearUpTasks(taskDict);	82,820✔
233	}	82,820✔
234
235	private void RemoveActorTaskState(IActor actor)
236	{
237	if (_taskDict.TryRemove(actor, out var taskState))	74✔
238	{
239	taskState.TaskSource.CancelTask(taskState.Task);	67✔
240	}
241	else
242	{
243	if (actor.TaskSource is IHumanActorTaskSource<ISectorTaskSourceContext> humanTaskSource)	7!
244	{
245	humanTaskSource.DropIntentionWaiting();	×
246	}
247	}
248	}	7✔
249
250	private async void Sector_TrasitionUsed(object sender, TransitionUsedEventArgs e)
251	{
252	var sector = (ISector)sender;
253	await _globeTransitionHandler.InitActorTransitionAsync(this, sector, e.Actor, e.Transition)
254	.ConfigureAwait(false);
255	}
256
257	private static TaskState[] SortActorStates(IEnumerable<TaskState> sectorStates)
258	{
259	// Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
260	// Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
261	// В этом случае порядок элементов, полученных из states, не фиксирован.
262	// В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
263	// Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
264	// Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.
265
266	return sectorStates.OrderBy(x => x.Actor.Person.Id).ToArray();	82,434✔
267	}
268
269	public IEnumerable<ISectorNode> SectorNodes => _sectorNodes;	43,741✔
270
271	public void AddSectorNode(ISectorNode sectorNode)
272	{
273	if (sectorNode is null)	80!
274	{
275	throw new ArgumentNullException(nameof(sectorNode));	×
276	}
277
278	_sectorNodes.Add(sectorNode);	80✔
279	sectorNode.Sector.TrasitionUsed += Sector_TrasitionUsed;	80✔
280	sectorNode.Sector.ActorManager.Removed += ActorManager_Removed;	80✔
281	}	80✔
282
283	public async Task UpdateAsync(CancellationToken cancelToken)
284	{
285	var actorsWithoutTasks = GetActorsWithoutTasks();
286
287	await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks, cancelToken).ConfigureAwait(false);
288
289	ProcessTasks(_taskDict);
290
291	_turnCounter++;
292
293	if (_turnCounter >= GlobeMetrics.OneIterationLength)
294	{
295	_turnCounter = GlobeMetrics.OneIterationLength - _turnCounter;
296
297	foreach (var sectorNode in _sectorNodes)
298	{
299	if (sectorNode.State != SectorNodeState.SectorMaterialized)
300	{
301	continue;
302	}
303
304	sectorNode.Sector.Update();
305	}
306
307	_globeTransitionHandler.UpdateTransitions();
308	}
309	}
310
311	private sealed class ActorInSector
312	{
313	public IActor Actor { get; set; }
314	public ISector Sector { get; set; }
315	}
316	}
317	}

kreghek / Zilon_Roguelike / 654531746

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