422250780

Build Type

github

Committed by GitHub

Commit Message

Merge 50e3c9196 into 4d358de9f

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

Run Details

3973 of 7170 branches covered (55.41%)

Branch coverage included in aggregate %.

30 of 35 new or added lines in 4 files covered. (85.71%)

1 existing line in 1 file now uncovered.

6499 of 8776 relevant lines covered (74.05%)

705506.6 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.DropIntention();
                }
            }
        }

        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)	140✔
25	{	72✔
26	_taskDict = new ConcurrentDictionary<IActor, TaskState>();	140✔
27
28	_sectorNodes = new List<ISectorNode>();	140✔
29
30	_globeTransitionHandler =	140!
31	globeTransitionHandler ?? throw new ArgumentNullException(nameof(globeTransitionHandler));	140✔
32	}	140✔
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)	110✔
38	{	18✔
39	RemoveActorTaskState(removedActor);	23✔
40	}	18✔
41	}	23✔
42
43	private async Task GenerateActorTasksAndPutInDictAsync(IEnumerable<ActorInSector> actorDataList)
44	{	7,515,615✔
45	var actorDataListMaterialized = actorDataList.ToArray();	14,219,227✔
46	foreach (var actorDataItem in actorDataListMaterialized)	36,009,027✔
47	{	14,394✔
48	var actor = actorDataItem.Actor;	27,479✔
49	var sector = actorDataItem.Sector;	27,479✔
50
51	var taskSource = actor.TaskSource;	27,479✔
52
53	var context = new SectorTaskSourceContext(sector);	27,479✔
54
55	//TODO Это можно делать параллельно. Одновременно должны думать сразу все актёры.
56	// Делается легко, через Parallel.ForEach, но из-за этого часто заваливаются тесты и даже не видно причины отказа.
57	var actorTaskTask = taskSource.GetActorTaskAsync(actor, context);	27,479✔
58
59	try
60	{	14,394✔
61	var actorTask = await actorTaskTask.ConfigureAwait(false);	27,479✔
62	var state = new TaskState(actor, actorTask, taskSource);	27,479✔
63	if (!_taskDict.TryAdd(actor, state))	27,479!
64	{
65	// Это происходит, когда игрок пытается присвоить новую команду,
66	// когда старая еще не закончена и не может быть заменена.
NEW 67	throw new InvalidOperationException("Попытка назначить задачу, когда старая еще не удалена.");	×
68	}
69	}	27,479✔
NEW 70	catch (TaskCanceledException)	×
71	{
72	// Do nothing for his actor. His task was cancelled.
NEW 73	_taskDict.TryRemove(actor, out var _);	×
74	}	×
75	}	27,479✔
76	}	14,219,227✔
77
78	private IEnumerable<ActorInSector> GetActorsWithoutTasks()
79	{	7,515,615✔
80	// _sectorNodes фиксируем в отдельный массив.
81	// потому что по мере выполнения задач актёров, может быть переход в новый узел мира.
82	// Мир при том расширится и список поменяется. А это приведёт к ошибке, что коллекция в foreach изменяется.
83	foreach (var sectorNode in _sectorNodes.ToArray())	64,423,523✔
84	{	7,531,115✔
85	var sector = sectorNode.Sector;	14,234,727✔
86	foreach (var actor in sector.ActorManager.Items.ToArray())	64,776,823✔
87	{	7,745,315✔
88	if (!sector.ActorManager.Items.Contains(actor))	14,388,127!
89	{
90	// Это может произойти, когда в процессе исполнения задач,
91	// актёр вышел из сектора. Соответственно, его уже нет в списке актёров сектора.
92
93	RemoveActorTaskState(actor);	×
94
95	continue;	×
96	}
97
98	if (_taskDict.TryGetValue(actor, out _))	14,388,127✔
99	{	7,730,921✔
100	continue;	7,730,921✔
101	}
102
103	yield return new ActorInSector { Actor = actor, Sector = sector };	27,479✔
104	}	14,394✔
105	}	14,234,727✔
106	}	14,219,227✔
107
108	private static void ProcessTasks(IDictionary<IActor, TaskState> taskDict)
109	{	7,515,615✔
110	var states = taskDict.Values;	14,219,227✔
111	// Все актёры еще раз сортируются, чтобы зафиксировать поведение для тестов.
112	// Может быть ситуация, когда найдено одновременно два актёра без задач (в самом начале теста, например).
113	// В этом случае порядок элементов, полученных из states, не фиксирован.
114	// В тестах мжет быть важно, в каком порядке ходят актёры, чтобы корректно обрабатывать коллизии.
115	// Поэтому тут выполняется еще одна сортировка, от которой, по-хорошему нужно избавиться.
116	// Лучше сразу иметь список states с сортировкой по приоритету при добавлении элемента.
117	var orderedStates = states.OrderBy(x => x.Actor.Person.Id);	28,608,851✔
118	foreach (var state in orderedStates)	64,733,317✔
119	{	7,746,812✔
120	if (!state.Actor.CanExecuteTasks)	14,389,624✔
121	{	9✔
122	// По сути, возможность выполнять задачи - это основая роль этого объекта.
123	// песонаж может перестать выполнять задачи по следующим причинам:
124	// 1. Персонажи, у которых есть модуль выживания, могут умереть, пока выполняют текущую задачу (выполняются предусловия).
125	// Мертвые персонажы не выполняют задач.
126	// Их задачи игнорируем, т.к. задачи могут выполниться после смерти персонажа,
127	// что противоречит логике задач.
128	continue;	9✔
129	}
130
131	state.UpdateCounter();	14,389,612✔
132
133	if (state.TaskIsExecuting)	14,389,612✔
134	{	14,381✔
135	state.Task.Execute();	27,459✔
136
137	state.TaskSource.ProcessTaskExecuted(state.Task);	27,459✔
138	}	14,381✔
139	}	7,746,803✔
140
141	// удаляем выполненные задачи.
142	foreach (var taskStatePair in taskDict.ToArray())	64,733,281✔
143	{	7,746,798✔
144	var state = taskStatePair.Value;	14,389,606✔
145	if (state.TaskComplete)	14,389,606✔
146	{	14,335✔
147	taskDict.Remove(taskStatePair.Key);	27,411✔
148	state.TaskSource.ProcessTaskComplete(state.Task);	27,411✔
149	}	14,335✔
150
151	var actor = taskStatePair.Key;	14,389,606✔
152	if (!actor.CanExecuteTasks)	14,389,606!
153	{
154	// Песонаж может перестать выполнять задачи по следующим причинам:
155	// 1. Персонажи, у которых есть модуль выживания, могут умереть.
156	// Мертвые персонажы не выполняют задач.
157	// Их задачи можно прервать, потому что:
158	// * Возможна ситуация, когда мертвый персонаж все еще выполнить действие.
159	// * Экономит ресурсы.
160	taskDict.Remove(taskStatePair.Key);	×
161	}
162	}	7,746,798✔
163	}	14,219,227✔
164
165	private void RemoveActorTaskState(IActor actor)
166	{	18✔
167	if (_taskDict.TryRemove(actor, out var taskState))	23✔
168	{	14✔
169	taskState.TaskSource.CancelTask(taskState.Task);	18✔
170	}	14✔
171	else
172	{	4✔
173	if (actor.TaskSource is IHumanActorTaskSource<ISectorTaskSourceContext> humanTaskSource)	5✔
174	{	1✔
175	humanTaskSource.DropIntention();	2✔
176	}	1✔
177	}	4✔
178	}	19✔
179
180	private async void Sector_TrasitionUsed(object sender, TransitionUsedEventArgs e)
181	{	3✔
182	var sector = (ISector)sender;	3✔
183	await _globeTransitionHandler.ProcessAsync(this, sector, e.Actor, e.Transition).ConfigureAwait(false);	3✔
184	}	3✔
185
186	public IEnumerable<ISectorNode> SectorNodes => _sectorNodes;	27,348✔
187
188	public void AddSectorNode(ISectorNode sectorNode)
189	{	75✔
190	if (sectorNode is null)	143!
191	{
192	throw new ArgumentNullException(nameof(sectorNode));	×
193	}
194
195	_sectorNodes.Add(sectorNode);	143✔
196	sectorNode.Sector.TrasitionUsed += Sector_TrasitionUsed;	143✔
197	sectorNode.Sector.ActorManager.Removed += ActorManager_Removed;	143✔
198	}	143✔
199
200	public async Task UpdateAsync()
201	{	7,515,615✔
202	var actorsWithoutTasks = GetActorsWithoutTasks();	14,219,227✔
203
204	await GenerateActorTasksAndPutInDictAsync(actorsWithoutTasks).ConfigureAwait(false);	14,219,227✔
205
206	ProcessTasks(_taskDict);	14,219,227✔
207	_turnCounter++;	14,219,227✔
208	if (_turnCounter >= GlobeMetrics.OneIterationLength)	14,219,227✔
209	{	7,514✔
210	_turnCounter = GlobeMetrics.OneIterationLength - _turnCounter;	14,217✔
211
212	foreach (var sectorNode in _sectorNodes)	64,414✔
213	{	7,530✔
214	sectorNode.Sector.Update();	14,233✔
215	}	7,530✔
216	}	7,514✔
217	}	14,219,227✔
218
219	private sealed class ActorInSector
220	{
221	public IActor Actor { get; set; }	54,958✔
222	public ISector Sector { get; set; }	54,958✔
223	}
224	}
225	}

kreghek / Zilon_Roguelike / 422250780

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