422275834

Build Type

github

Committed by GitHub

Commit Message

Merge 96841c77f into 4d358de9f

Pull Request Pull Request #938: Fix the text game restart after the main player person dead

Run Details

4432 of 7170 branches covered (61.81%)

Branch coverage included in aggregate %.

34 of 39 new or added lines in 4 files covered. (87.18%)

1 existing line in 1 file now uncovered.

6557 of 8776 relevant lines covered (74.72%)

780660.06 hits per line

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

88.39

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

﻿using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
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 async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList)
        {
            var actorDataListMaterialized = actorDataList.ToArray();
            foreach (var actorDataItem in actorDataListMaterialized)
            {
                var actor = actorDataItem.Actor;
                var sector = actorDataItem.Sector;

                var taskSource = actor.TaskSource;

                var context = new SectorTaskSourceContext(sector);

                //TODO Это можно делать параллельно. Одновременно должны думать сразу все актёры.
                // Делается легко, через Parallel.ForEach, но из-за этого часто заваливаются тесты и даже не видно причины отказа.
                var actorTaskTask = taskSource.GetActorTaskAsync(actor, context);

                try
                {
                    var actorTask = await actorTaskTask.ConfigureAwait(false);
                    var state = new TaskState(actor, 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()
        {
            // _sectorNodes фиксируем в отдельный массив.
            // потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
            // Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
            foreach (var sectorNode in _sectorNodes.ToArray())
            {
                var sector = sectorNode.Sector;
                foreach (var actor in sector.ActorManager.Items.ToArray())
                {
                    if (!sector.ActorManager.Items.Contains(actor))
                    {
                        // Это может произойти, когда в процессе исполнения задач,
                        // актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.

                        RemoveActorTaskState(actor);

                        continue;
                    }

                    if (_taskDict.TryGetValue(actor, out _))
                    {
                        continue;
                    }

                    yield return new ActorInSector { Actor = actor, Sector = sector };
                }
            }
        }

        private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
        {
            var states = taskDict.Values;
            // Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
            // Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
            // В этом случае порядок элементов, полученных из states, не фиксирован.
            // В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
            // Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
            // Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.
            var orderedStates = states.OrderBy(x => x.Actor.Person.Id);
            foreach (var state in orderedStates)
            {
                if (!state.Actor.CanExecuteTasks)
                {
                    // По сути, возможность выполнять задачи - это основая роль этого объекта.
                    // песонаж может перестать выполнять задачи по следующим причинам:
                    // 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
                    // Мертвые персонажы не выполняют задач.
                    // Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
                    // что противоречит логике задач.
                    continue;
                }

                state.UpdateCounter();

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

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

            // удаляем выполненные задачи.
            foreach (var taskStatePair in taskDict.ToArray())
            {
                var state = taskStatePair.Value;
                if (state.TaskComplete)
                {
                    taskDict.Remove(taskStatePair.Key);
                    state.TaskSource.ProcessTaskComplete(state.Task);
                }

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

        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.ProcessAsync(this, sector, e.Actor, e.Transition).ConfigureAwait(false);
        }

        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()
        {
            var actorsWithoutTasks = GetActorsWithoutTasks();

            await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks).ConfigureAwait(false);

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

                foreach (var sectorNode in _sectorNodes)
                {
                    sectorNode.Sector.Update();
                }
            }
        }

        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.Tasks;
6
7	using Zilon.Core.Tactics;
8	using Zilon.Core.Tactics.Behaviour;
9
10	namespace Zilon.Core.World
11	{
12	/// <summary>
13	/// Globe base implementation.
14	/// </summary>
15	public sealed class Globe : IGlobe
16	{
17	private readonly IGlobeTransitionHandler _globeTransitionHandler;
18
19	private readonly IList<ISectorNode> _sectorNodes;
20
21	private readonly ConcurrentDictionary<IActor, TaskState> _taskDict;
22	private int _turnCounter;
23
24	public Globe(IGlobeTransitionHandler globeTransitionHandler)	144✔
25	{	72✔
26	_taskDict = new ConcurrentDictionary<IActor, TaskState>();	144✔
27
28	_sectorNodes = new List<ISectorNode>();	144✔
29
30	_globeTransitionHandler =	144!
31	globeTransitionHandler ?? throw new ArgumentNullException(nameof(globeTransitionHandler));	144✔
32	}	144✔
33
34	private void ActorManager_Removed(object sender, ManagerItemsChangedEventArgs<IActor> e)
35	{	18✔
36	// Remove all current tasks
37	foreach (var removedActor in e.Items)	182✔
38	{	18✔
39	RemoveActorTaskState(removedActor);	41✔
40	}	18✔
41	}	41✔
42
43	private async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList)
44	{	7,533,115✔
45	var actorDataListMaterialized = actorDataList.ToArray();	15,398,731✔
46	foreach (var actorDataItem in actorDataListMaterialized)	38,395,807✔
47	{	15,261✔
48	var actor = actorDataItem.Actor;	32,615✔
49	var sector = actorDataItem.Sector;	32,615✔
50
51	var taskSource = actor.TaskSource;	32,615✔
52
53	var context = new SectorTaskSourceContext(sector);	32,615✔
54
55	//TODO Это можно делать параллельно. Одновременно должны думать сразу все актёры.
56	// Делается легко, через Parallel.ForEach, но из-за этого часто заваливаются тесты и даже не видно причины отказа.
57	var actorTaskTask = taskSource.GetActorTaskAsync(actor, context);	32,615✔
58
59	try
60	{	15,261✔
61	var actorTask = await actorTaskTask.ConfigureAwait(false);	32,615✔
62	var state = new TaskState(actor, actorTask, taskSource);	32,615✔
63	if (!_taskDict.TryAdd(actor, state))	32,615!
64	{
65	// Это происходит, когда игрок пытается присвоить новую команду,
66	// когда старая еще не закончена и не может быть заменена.
NEW 67	throw new InvalidOperationException("Попытка назначить задачу, когда старая еще не удалена.");	×
68	}
69	}	32,615✔
NEW 70	catch (TaskCanceledException)	×
71	{
72	// Do nothing for his actor. His task was cancelled.
NEW 73	_taskDict.TryRemove(actor, out var _);	×
74	}	×
75	}	32,615✔
76	}	15,398,731✔
77
78	private IEnumerable<ActorInSector> GetActorsWithoutTasks()
79	{	7,533,115✔
80	// _sectorNodes фиксируем в отдельный массив.
81	// потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
82	// Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
83	foreach (var sectorNode in _sectorNodes.ToArray())	69,776,039✔
84	{	7,593,615✔
85	var sector = sectorNode.Sector;	15,722,731✔
86	foreach (var actor in sector.ActorManager.Items.ToArray())	75,988,339✔
87	{	8,425,815✔
88	if (!sector.ActorManager.Items.Contains(actor))	18,474,631!
89	{
90	// Это может произойти, когда в процессе исполнения задач,
91	// актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.
92
93	RemoveActorTaskState(actor);	×
94
95	continue;	×
96	}
97
98	if (_taskDict.TryGetValue(actor, out _))	18,474,631✔
99	{	8,410,554✔
100	continue;	8,410,554✔
101	}
102
103	yield return new ActorInSector { Actor = actor, Sector = sector };	32,615✔
104	}	15,261✔
105	}	15,722,731✔
106	}	15,398,731✔
107
108	private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
109	{	7,533,115✔
110	var states = taskDict.Values;	15,398,731✔
111	// Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
112	// Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
113	// В этом случае порядок элементов, полученных из states, не фиксирован.
114	// В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
115	// Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
116	// Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.
117	var orderedStates = states.OrderBy(x => x.Actor.Person.Id);	33,876,855✔
118	foreach (var state in orderedStates)	75,286,825✔
119	{	8,427,312✔
120	if (!state.Actor.CanExecuteTasks)	18,478,124✔
121	{	5✔
122	// По сути, возможность выполнять задачи - это основая роль этого объекта.
123	// песонаж может перестать выполнять задачи по следующим причинам:
124	// 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
125	// Мертвые персонажы не выполняют задач.
126	// Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
127	// что противоречит логике задач.
128	continue;	5✔
129	}
130
131	state.UpdateCounter();	18,478,106✔
132
133	if (state.TaskIsExecuting)	18,478,106✔
134	{	15,253✔
135	state.Task.Execute();	32,595✔
136
137	state.TaskSource.ProcessTaskExecuted(state.Task);	32,595✔
138	}	15,253✔
139	}	8,427,307✔
140
141	// удаляем выполненные задачи.
142	foreach (var taskStatePair in taskDict.ToArray())	75,286,761✔
143	{	8,427,298✔
144	var state = taskStatePair.Value;	18,478,092✔
145	if (state.TaskComplete)	18,478,092✔
146	{	15,211✔
147	taskDict.Remove(taskStatePair.Key);	32,526✔
148	state.TaskSource.ProcessTaskComplete(state.Task);	32,526✔
149	}	15,211✔
150
151	var actor = taskStatePair.Key;	18,478,092✔
152	if (!actor.CanExecuteTasks)	18,478,092!
153	{
154	// Песонаж может перестать выполнять задачи по следующим причинам:
155	// 1. Персонажи, у которых есть модуль выживания, могут умереть.
156	// Мертвые персонажы не выполняют задач.
157	// Их задачи можно прервать, потому что:
158	// * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
159	// * Экономит ресурсы.
160	taskDict.Remove(taskStatePair.Key);	×
161	}
162	}	8,427,298✔
163	}	15,398,731✔
164
165	private void RemoveActorTaskState(IActor actor)
166	{	18✔
167	if (_taskDict.TryRemove(actor, out var taskState))	41✔
168	{	14✔
169	taskState.TaskSource.CancelTask(taskState.Task);	32✔
170	}	14✔
171	else
172	{	4✔
173	if (actor.TaskSource is IHumanActorTaskSource<ISectorTaskSourceContext> humanTaskSource)	9✔
174	{	1✔
175	humanTaskSource.DropIntentionWaiting();	2✔
176	}	1✔
177	}	4✔
178	}	23✔
179
180	private async void Sector_TrasitionUsed(object sender, TransitionUsedEventArgs e)
181	{	3✔
182	var sector = (ISector)sender;	7✔
183	await _globeTransitionHandler.ProcessAsync(this, sector, e.Actor, e.Transition).ConfigureAwait(false);	7✔
184	}	7✔
185
186	public IEnumerable<ISectorNode> SectorNodes => _sectorNodes;	27,348✔
187
188	public void AddSectorNode(ISectorNode sectorNode)
189	{	75✔
190	if (sectorNode is null)	151!
191	{
192	throw new ArgumentNullException(nameof(sectorNode));	×
193	}
194
195	_sectorNodes.Add(sectorNode);	151✔
196	sectorNode.Sector.TrasitionUsed += Sector_TrasitionUsed;	151✔
197	sectorNode.Sector.ActorManager.Removed += ActorManager_Removed;	151✔
198	}	151✔
199
200	public async Task UpdateAsync()
201	{	7,533,115✔
202	var actorsWithoutTasks = GetActorsWithoutTasks();	15,398,731✔
203
204	await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks).ConfigureAwait(false);	15,398,731✔
205
206	ProcessTasks(_taskDict);	15,398,731✔
207	_turnCounter++;	15,398,731✔
208	if (_turnCounter >= GlobeMetrics.OneIterationLength)	15,398,731✔
209	{	7,531✔
210	_turnCounter = GlobeMetrics.OneIterationLength - _turnCounter;	15,396✔
211
212	foreach (var sectorNode in _sectorNodes)	69,765✔
213	{	7,591✔
214	sectorNode.Sector.Update();	15,721✔
215	}	7,591✔
216	}	7,531✔
217	}	15,398,731✔
218
219	private sealed class ActorInSector
220	{
221	public IActor Actor { get; set; }	65,230✔
222	public ISector Sector { get; set; }	65,230✔
223	}
224	}
225	}

kreghek / Zilon_Roguelike / 422275834

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