794616559

Build Type

github

Committed by GitHub

Commit Message

Merge 61fe407af into ca396343c

Pull Request Pull Request #1079: Refactor in new client

Run Details

2367 of 3740 branches covered (63.29%)

Branch coverage included in aggregate %.

49 of 89 new or added lines in 16 files covered. (55.06%)

29 existing lines in 14 files now uncovered.

6207 of 8073 relevant lines covered (76.89%)

50564.03 hits per line

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

69.12

/Zilon.Core/Zilon.Core/World/GlobeTransitionHandler.cs

﻿using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

using Zilon.Core.Graphs;
using Zilon.Core.MapGenerators;
using Zilon.Core.Tactics;

namespace Zilon.Core.World
{
    public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
    {
        private const int TransitionPerGlobeIteration = 10;
        private readonly IGlobeExpander _globeExpander;

        private readonly SemaphoreSlim _semaphoreSlim;
        private readonly ITransitionPool _transitionPool;

        public GlobeTransitionHandler(IGlobeExpander globeExpander, ITransitionPool transitionPool)
        {
            _globeExpander = globeExpander ?? throw new ArgumentNullException(nameof(globeExpander));
            _transitionPool = transitionPool ?? throw new ArgumentNullException(nameof(transitionPool));

            //Instantiate a Singleton of the Semaphore with a value of 1. This means that only 1 thread can be granted access at a time.
            _semaphoreSlim = new SemaphoreSlim(1, 1);
        }

        public void Dispose()
        {
            _semaphoreSlim.Dispose();
        }

        private static bool FilterNodeToTransition(IGraphNode textNode, ISector nextSector)
        {
            var nodeIsBusyWithMonster = nextSector.ActorManager.Items.Any(x => x.Node == textNode);
            if (nodeIsBusyWithMonster)
            {
                return false;
            }

            var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);
            if (nodeIsBusyWithStaticObject)
            {
                return false;
            }

            return true;
        }

        private async Task ProcessInnerAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
        {
            var sectorNode = transition.SectorNode;

            //TODO Разобраться с этим кодом.
            // https://blog.cdemi.io/async-waiting-inside-c-sharp-locks/
            //Asynchronously wait to enter the Semaphore. If no-one has been granted access to the Semaphore, code execution will proceed, otherwise this thread waits here until the semaphore is released 
            await _semaphoreSlim.WaitAsync();
            try
            {
                if (sectorNode.State != SectorNodeState.SectorMaterialized)
                {
                    await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
                    globe.AddSectorNode(sectorNode);
                }

                // It was used as fallback later.
                var oldActorNode = actor.Node;

                try
                {
                    sector.ActorManager.Remove(actor);
                }
                catch (InvalidOperationException exception)
                {
                    // Пока ничего не делаем
                    Console.WriteLine(exception);
                    Console.WriteLine(actor);
                }

                var nextSector = sectorNode.Sector;

                if (nextSector is null)
                {
                    throw new InvalidOperationException();
                }

                var transitionItem =
                    new TransitionPoolItem(actor.Person, actor.TaskSource, nextSector, sector, oldActorNode);
                _transitionPool.Push(transitionItem);
            }
            finally
            {
                //When the task is ready, release the semaphore. It is vital to ALWAYS release the semaphore when we are ready, or else we will end up with a Semaphore that is forever locked.
                //This is why it is important to do the Release within a try...finally clause; program execution may crash or take a different path, this way you are guaranteed execution
                _semaphoreSlim.Release();
            }
        }

        private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
        {
            var nextSector = transitionItem.NextSector;

            var nodeForTransition = nextSector.Map.Transitions
                .First(x => x.Value.SectorNode.Sector == transitionItem.OldSector).Key;
            var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);

            var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);
            var allAvailableNodesToTransition = allPotentialNodesToTransition
                .Where(x => FilterNodeToTransition(x, nextSector)).ToArray();

            var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();
            if (availableNodeToTransition is null)
            {
                // I dont know what I can do.
                // I think it was solved when a some transition pool was developed.
                // Now just return person into old sector in old transition node.
                nextSector = transitionItem.OldSector;
                availableNodeToTransition = transitionItem.OldNode;
            }

            var actorInNewSector =
                new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);
            nextSector.ActorManager.Add(actorInNewSector);
        }

        public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
        {
            if (globe is null)
            {
                throw new ArgumentNullException(nameof(globe));
            }

            if (sector is null)
            {
                throw new ArgumentNullException(nameof(sector));
            }

            if (actor is null)
            {
                throw new ArgumentNullException(nameof(actor));
            }

            if (transition is null)
            {
                throw new ArgumentNullException(nameof(transition));
            }

            return ProcessInnerAsync(globe, sector, actor, transition);
        }

        public void UpdateTransitions()
        {
            // The counter is restriction of transition per globe iteration.
            var counter = TransitionPerGlobeIteration;

            // Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
            do
            {
                var transitionItem = _transitionPool.Pop();

                if (transitionItem is null)
                {
                    return;
                }

                TryToTransitPersonToTargetSector(transitionItem);

                counter--;
            } while (counter > 0);
        }
    }
}

1	using System;
2	using System.Linq;
3	using System.Threading;
4	using System.Threading.Tasks;
5
6	using Zilon.Core.Graphs;
7	using Zilon.Core.MapGenerators;
8	using Zilon.Core.Tactics;
9
10	namespace Zilon.Core.World
11	{
12	public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
13	{
14	private const int TransitionPerGlobeIteration = 10;
15	private readonly IGlobeExpander _globeExpander;
16
17	private readonly SemaphoreSlim _semaphoreSlim;
18	private readonly ITransitionPool _transitionPool;
19
20	public GlobeTransitionHandler(IGlobeExpander globeExpander, ITransitionPool transitionPool)	72✔
21	{
22	_globeExpander = globeExpander ?? throw new ArgumentNullException(nameof(globeExpander));	72!
23	_transitionPool = transitionPool ?? throw new ArgumentNullException(nameof(transitionPool));	72!
24
25	//Instantiate a Singleton of the Semaphore with a value of 1. This means that only 1 thread can be granted access at a time.
26	_semaphoreSlim = new SemaphoreSlim(1, 1);	72✔
27	}	72✔
28
29	public void Dispose()
30	{
31	_semaphoreSlim.Dispose();	×
32	}	×
33
34	private static bool FilterNodeToTransition(IGraphNode textNode, ISector nextSector)
35	{
36	var nodeIsBusyWithMonster = nextSector.ActorManager.Items.Any(x => x.Node == textNode);	8,382✔
37	if (nodeIsBusyWithMonster)	8,382!
38	{
UNCOV 39	return false;	×
40	}
41
42	var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);	8,382✔
43	if (nodeIsBusyWithStaticObject)	8,382!
44	{
45	return false;	×
46	}
47
48	return true;	8,382✔
49	}
50
51	private async Task ProcessInnerAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
52	{
53	var sectorNode = transition.SectorNode;
54
55	//TODO Разобраться с этим кодом.
56	// https://blog.cdemi.io/async-waiting-inside-c-sharp-locks/
57	//Asynchronously wait to enter the Semaphore. If no-one has been granted access to the Semaphore, code execution will proceed, otherwise this thread waits here until the semaphore is released
58	await _semaphoreSlim.WaitAsync();
59	try
60	{
61	if (sectorNode.State != SectorNodeState.SectorMaterialized)
62	{
63	await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
64	globe.AddSectorNode(sectorNode);
65	}
66
67	// It was used as fallback later.
68	var oldActorNode = actor.Node;
69
70	try
71	{
72	sector.ActorManager.Remove(actor);
73	}
74	catch (InvalidOperationException exception)
75	{
76	// Пока ничего не делаем
77	Console.WriteLine(exception);
78	Console.WriteLine(actor);
79	}
80
81	var nextSector = sectorNode.Sector;
82
83	if (nextSector is null)
84	{
85	throw new InvalidOperationException();
86	}
87
88	var transitionItem =
89	new TransitionPoolItem(actor.Person, actor.TaskSource, nextSector, sector, oldActorNode);
90	_transitionPool.Push(transitionItem);
91	}
92	finally
93	{
94	//When the task is ready, release the semaphore. It is vital to ALWAYS release the semaphore when we are ready, or else we will end up with a Semaphore that is forever locked.
95	//This is why it is important to do the Release within a try...finally clause; program execution may crash or take a different path, this way you are guaranteed execution
96	_semaphoreSlim.Release();
97	}
98	}
99
100	private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
101	{
102	var nextSector = transitionItem.NextSector;	1,198✔
103
104	var nodeForTransition = nextSector.Map.Transitions	1,198✔
105	.First(x => x.Value.SectorNode.Sector == transitionItem.OldSector).Key;	1,198✔
106	var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);	1,198✔
107
108	var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);	1,198✔
109	var allAvailableNodesToTransition = allPotentialNodesToTransition	1,198✔
110	.Where(x => FilterNodeToTransition(x, nextSector)).ToArray();	1,198✔
111
112	var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();	1,198✔
113	if (availableNodeToTransition is null)	1,198!
114	{
115	// I dont know what I can do.
116	// I think it was solved when a some transition pool was developed.
117	// Now just return person into old sector in old transition node.
118	nextSector = transitionItem.OldSector;	×
119	availableNodeToTransition = transitionItem.OldNode;	×
120	}
121
122	var actorInNewSector =	1,198✔
123	new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);	1,198✔
124	nextSector.ActorManager.Add(actorInNewSector);	1,198✔
125	}	1,198✔
126
127	public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
128	{
129	if (globe is null)	1,198!
130	{
131	throw new ArgumentNullException(nameof(globe));	×
132	}
133
134	if (sector is null)	1,198!
135	{
136	throw new ArgumentNullException(nameof(sector));	×
137	}
138
139	if (actor is null)	1,198!
140	{
141	throw new ArgumentNullException(nameof(actor));	×
142	}
143
144	if (transition is null)	1,198!
145	{
146	throw new ArgumentNullException(nameof(transition));	×
147	}
148
149	return ProcessInnerAsync(globe, sector, actor, transition);	1,198✔
150	}
151
152	public void UpdateTransitions()
153	{
154	// The counter is restriction of transition per globe iteration.
155	var counter = TransitionPerGlobeIteration;	11,501✔
156
157	// Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
158	do
159	{
160	var transitionItem = _transitionPool.Pop();	12,699✔
161
162	if (transitionItem is null)	12,699✔
163	{
164	return;	11,501✔
165	}
166
167	TryToTransitPersonToTargetSector(transitionItem);	1,198✔
168
169	counter--;	1,198✔
170	} while (counter > 0);	1,198!
171	}	×
172	}
173	}

kreghek / Zilon_Roguelike / 794616559

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