927568006

Build Type

github

Committed by GitHub

Commit Message

Merge 7cc025928 into 3567602cd

Pull Request Pull Request #1182: Feature loot

Run Details

1932 of 3700 branches covered (52.22%)

Branch coverage included in aggregate %.

36 of 45 new or added lines in 7 files covered. (80.0%)

10 existing lines in 2 files now uncovered.

4974 of 7851 relevant lines covered (63.35%)

20916.11 hits per line

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

66.67

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

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

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

namespace Zilon.Core.World
{
    public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
    {
        private const int TRANSITION_PER_GLOBE_ITERATION = 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));

            _semaphoreSlim = new SemaphoreSlim(1, 1);
        }

        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 sourceSector, IActor actor,
            SectorTransition transition)
        {
            // To diagnistic #1094
            var survivalmodule = actor.Person.GetModuleSafe<ISurvivalModule>();
            if (survivalmodule != null)
            {
                if (survivalmodule.IsDead)
                {
                    Debug.Fail("Dead actors can't to leave sector.");
                }
            }

            var sectorNode = transition.SectorNode;

            await _semaphoreSlim.WaitAsync().ConfigureAwait(false);
            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;

                sourceSector.ActorManager.Remove(actor);

                var targetSector = sectorNode.Sector;

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

                var transitionItem = new TransitionPoolItem(
                    actor.Person,
                    actor.TaskSource,
                    targetSector,
                    sourceSector,
                    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 transitionKeyPairsInNextSector = nextSector.Map.Transitions
                .Where(x => x.Value.SectorNode.Sector == transitionItem.OldSector);

            IGraphNode? nodeForTransition;
            if (transitionKeyPairsInNextSector.Any())
            {
                var transitionKeyPairInNextSector = transitionKeyPairsInNextSector.First();

                nodeForTransition = transitionKeyPairInNextSector.Key;
            }
            else
            {
                Debug.Fail("In target sector must be transition to source sector.");
                nodeForTransition = nextSector.Map.Nodes.FirstOrDefault();

                if (nodeForTransition is null)
                {
                    nodeForTransition = transitionItem.OldNode;
                }
            }

            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 void Dispose()
        {
            _semaphoreSlim.Dispose();
        }

        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 = TRANSITION_PER_GLOBE_ITERATION;

            // 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.Diagnostics;
3	using System.Linq;
4	using System.Threading;
5	using System.Threading.Tasks;
6
7	using Zilon.Core.Graphs;
8	using Zilon.Core.MapGenerators;
9	using Zilon.Core.PersonModules;
10	using Zilon.Core.Tactics;
11
12	namespace Zilon.Core.World
13	{
14	public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
15	{
16	private const int TRANSITION_PER_GLOBE_ITERATION = 10;
17	private readonly IGlobeExpander _globeExpander;
18
19	private readonly SemaphoreSlim _semaphoreSlim;
20	private readonly ITransitionPool _transitionPool;
21
22	public GlobeTransitionHandler(IGlobeExpander globeExpander, ITransitionPool transitionPool)	68✔
23	{
24	_globeExpander = globeExpander ?? throw new ArgumentNullException(nameof(globeExpander));	68!
25	_transitionPool = transitionPool ?? throw new ArgumentNullException(nameof(transitionPool));	68!
26
27	_semaphoreSlim = new SemaphoreSlim(1, 1);	68✔
28	}	68✔
29
30	private static bool FilterNodeToTransition(IGraphNode textNode, ISector nextSector)
31	{
32	var nodeIsBusyWithMonster = nextSector.ActorManager.Items.Any(x => x.Node == textNode);	3✔
33	if (nodeIsBusyWithMonster)	3!
34	{
35	return false;	×
36	}
37
38	var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);	3✔
39	if (nodeIsBusyWithStaticObject)	3!
40	{
41	return false;	×
42	}
43
44	return true;	3✔
45	}
46
47	private async Task ProcessInnerAsync(IGlobe globe, ISector sourceSector, IActor actor,
48	SectorTransition transition)
49	{
50	// To diagnistic #1094
51	var survivalmodule = actor.Person.GetModuleSafe<ISurvivalModule>();
52	if (survivalmodule != null)
53	{
54	if (survivalmodule.IsDead)
55	{
56	Debug.Fail("Dead actors can't to leave sector.");
57	}
58	}
59
60	var sectorNode = transition.SectorNode;
61
62	await _semaphoreSlim.WaitAsync().ConfigureAwait(false);
63	try
64	{
65	if (sectorNode.State != SectorNodeState.SectorMaterialized)
66	{
67	await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
68	globe.AddSectorNode(sectorNode);
69	}
70
71	// It was used as fallback later.
72	var oldActorNode = actor.Node;
73
74	sourceSector.ActorManager.Remove(actor);
75
76	var targetSector = sectorNode.Sector;
77
78	if (targetSector is null)
79	{
80	throw new InvalidOperationException();
81	}
82
83	var transitionItem = new TransitionPoolItem(
84	actor.Person,
85	actor.TaskSource,
86	targetSector,
87	sourceSector,
88	oldActorNode);
89	_transitionPool.Push(transitionItem);
90	}
91	finally
92	{
93	//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.
94	//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
95	_semaphoreSlim.Release();
96	}
97	}
98
99	private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
100	{
101	var nextSector = transitionItem.NextSector;	1✔
102
103	var transitionKeyPairsInNextSector = nextSector.Map.Transitions	1✔
104	.Where(x => x.Value.SectorNode.Sector == transitionItem.OldSector);	1✔
105
106	IGraphNode? nodeForTransition;
107	if (transitionKeyPairsInNextSector.Any())	1!
108	{
109	var transitionKeyPairInNextSector = transitionKeyPairsInNextSector.First();	1✔
110
111	nodeForTransition = transitionKeyPairInNextSector.Key;	1✔
112	}
113	else
114	{
115	Debug.Fail("In target sector must be transition to source sector.");
UNCOV 116	nodeForTransition = nextSector.Map.Nodes.FirstOrDefault();	×
117
UNCOV 118	if (nodeForTransition is null)	×
119	{
UNCOV 120	nodeForTransition = transitionItem.OldNode;	×
121	}
122	}
123
124	var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);	1✔
125
126	var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);	1✔
127	var allAvailableNodesToTransition = allPotentialNodesToTransition	1✔
128	.Where(x => FilterNodeToTransition(x, nextSector)).ToArray();	1✔
129
130	var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();	1✔
131	if (availableNodeToTransition is null)	1!
132	{
133	// I dont know what I can do.
134	// I think it was solved when a some transition pool was developed.
135	// Now just return person into old sector in old transition node.
UNCOV 136	nextSector = transitionItem.OldSector;	×
137	availableNodeToTransition = transitionItem.OldNode;	×
138	}
139
140	var actorInNewSector =	1✔
141	new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);	1✔
142	nextSector.ActorManager.Add(actorInNewSector);	1✔
143	}	1✔
144
145	public void Dispose()
146	{
UNCOV 147	_semaphoreSlim.Dispose();	×
UNCOV 148	}	×
149
150	public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
151	{
152	if (globe is null)	1!
153	{
154	throw new ArgumentNullException(nameof(globe));	×
155	}
156
157	if (sector is null)	1!
158	{
159	throw new ArgumentNullException(nameof(sector));	×
160	}
161
162	if (actor is null)	1!
163	{
UNCOV 164	throw new ArgumentNullException(nameof(actor));	×
165	}
166
167	if (transition is null)	1!
168	{
UNCOV 169	throw new ArgumentNullException(nameof(transition));	×
170	}
171
172	return ProcessInnerAsync(globe, sector, actor, transition);	1✔
173	}
174
175	public void UpdateTransitions()
176	{
177	// The counter is restriction of transition per globe iteration.
178	var counter = TRANSITION_PER_GLOBE_ITERATION;	6,716✔
179
180	// Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
181	do
182	{
183	var transitionItem = _transitionPool.Pop();	6,717✔
184
185	if (transitionItem is null)	6,717✔
186	{
187	return;	6,716✔
188	}
189
190	TryToTransitPersonToTargetSector(transitionItem);	1✔
191
192	counter--;	1✔
193	} while (counter > 0);	1!
UNCOV 194	}	×
195	}
196	}

kreghek / Zilon_Roguelike / 927568006

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