496299199

Build Type

github

Committed by GitHub

Commit Message

Merge aa0019d3a into 1348daebd

Pull Request Pull Request #1013: Prop usage rules

Run Details

2175 of 3412 branches covered (63.75%)

Branch coverage included in aggregate %.

31 of 67 new or added lines in 9 files covered. (46.27%)

16 existing lines in 8 files now uncovered.

5919 of 7652 relevant lines covered (77.35%)

162269.76 hits per line

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

69.57

/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 
#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
            await _semaphoreSlim.WaitAsync();
#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
            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(sector.GetHashCode());
                    Console.WriteLine(actor);
                }

                var nextSector = sectorNode.Sector;

                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;
            TransitionPoolItem transitionItem = null;

            // Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
            do
            {
                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,304✔
37	if (nodeIsBusyWithMonster)	8,304!
38	{
UNCOV 39	return false;	×
40	}
41
42	var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);	8,304✔
43	if (nodeIsBusyWithStaticObject)	8,304!
44	{
45	return false;	×
46	}
47
48	return true;	8,304✔
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	#pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
59	await _semaphoreSlim.WaitAsync();
60	#pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
61	try
62	{
63	if (sectorNode.State != SectorNodeState.SectorMaterialized)
64	{
65	await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
66	globe.AddSectorNode(sectorNode);
67	}
68
69	// It was used as fallback later.
70	var oldActorNode = actor.Node;
71
72	try
73	{
74	sector.ActorManager.Remove(actor);
75	}
76	catch (InvalidOperationException exception)
77	{
78	// Пока ничего не делаем
79	Console.WriteLine(exception);
80	Console.WriteLine(sector.GetHashCode());
81	Console.WriteLine(actor);
82	}
83
84	var nextSector = sectorNode.Sector;
85
86	var transitionItem =
87	new TransitionPoolItem(actor.Person, actor.TaskSource, nextSector, sector, oldActorNode);
88	_transitionPool.Push(transitionItem);
89	}
90	finally
91	{
92	//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.
93	//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
94	_semaphoreSlim.Release();
95	}
96	}
97
98	private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
99	{
100	var nextSector = transitionItem.NextSector;	1,187✔
101
102	var nodeForTransition = nextSector.Map.Transitions	1,187✔
103	.First(x => x.Value.SectorNode.Sector == transitionItem.OldSector).Key;	1,187✔
104	var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);	1,187✔
105
106	var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);	1,187✔
107	var allAvailableNodesToTransition = allPotentialNodesToTransition	1,187✔
108	.Where(x => FilterNodeToTransition(x, nextSector)).ToArray();	1,187✔
109
110	var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();	1,187✔
111	if (availableNodeToTransition is null)	1,187!
112	{
113	// I dont know what I can do.
114	// I think it was solved when a some transition pool was developed.
115	// Now just return person into old sector in old transition node.
116	nextSector = transitionItem.OldSector;	×
117	availableNodeToTransition = transitionItem.OldNode;	×
118	}
119
120	var actorInNewSector =	1,187✔
121	new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);	1,187✔
122	nextSector.ActorManager.Add(actorInNewSector);	1,187✔
123	}	1,187✔
124
125	public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
126	{
127	if (globe is null)	1,187!
128	{
129	throw new ArgumentNullException(nameof(globe));	×
130	}
131
132	if (sector is null)	1,187!
133	{
134	throw new ArgumentNullException(nameof(sector));	×
135	}
136
137	if (actor is null)	1,187!
138	{
139	throw new ArgumentNullException(nameof(actor));	×
140	}
141
142	if (transition is null)	1,187!
143	{
144	throw new ArgumentNullException(nameof(transition));	×
145	}
146
147	return ProcessInnerAsync(globe, sector, actor, transition);	1,187✔
148	}
149
150	public void UpdateTransitions()
151	{
152	// The counter is restriction of transition per globe iteration.
153	var counter = TransitionPerGlobeIteration;	11,773✔
154	TransitionPoolItem transitionItem = null;	11,773✔
155
156	// Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
157	do
158	{
159	transitionItem = _transitionPool.Pop();	12,960✔
160
161	if (transitionItem is null)	12,960✔
162	{
163	return;	11,773✔
164	}
165
166	TryToTransitPersonToTargetSector(transitionItem);	1,187✔
167
168	counter--;	1,187✔
169	} while (counter > 0);	1,187!
170	}	×
171	}
172	}

kreghek / Zilon_Roguelike / 496299199

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