992192048

Build # 992192048

Build Type

github

Committed by GitHub

Commit Message

Merge f06a9f07a into 259bc4863

Pull Request Pull Request #1217: Feature 1121 score screen

Run Details

1976 of 3786 branches covered (52.19%)

Branch coverage included in aggregate %.

9 of 23 new or added lines in 1 file covered. (39.13%)

4 existing lines in 1 file now uncovered.

5091 of 8027 relevant lines covered (63.42%)

36739.11 hits per line

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

57.33

/Zilon.Core/Zilon.Core/Client/Sector/CommandLoopUpdater.cs

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

using Zilon.Core.Commands;

namespace Zilon.Core.Client.Sector
{
    public sealed class CommandLoopUpdater : ICommandLoopUpdater, IDisposable
    {
        private const int WAIT_FOR_CHANGES_MILLISECONDS = 100;
        private readonly ICommandLoopContext _commandLoopContext;
        private readonly ICommandPool _commandPool;

        private readonly SemaphoreSlim _semaphoreSlim;
        private CancellationTokenSource _cancellationTokebSourceInner;

        private bool _hasPendingCommand;

        private CancellationTokenSource _linkedCts;

        [ExcludeFromCodeCoverage]
        public CommandLoopUpdater(ICommandLoopContext commandLoopContext, ICommandPool commandPool)
        {
            _commandLoopContext = commandLoopContext;
            _commandPool = commandPool;

            _semaphoreSlim = new SemaphoreSlim(1, 1);
        }

        private void DoErrorOccured(ICommand? commandWithError, InvalidOperationException exception)
        {
            if (commandWithError != null)
            {
                ErrorOccured?.Invoke(this, new CommandErrorOccuredEventArgs(commandWithError, exception));
            }
            else
            {
                ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));
            }
        }

        private async Task HandleRepeatableAsync(ICommand? command, CancellationToken cancellationToken)
        {
            if (command is IRepeatableCommand repeatableCommand)
            {
                // It is necesary because CanRepeate and CanExecute can perform early that globe updates its state.
                await WaitGlobeIterationPerformedAsync().ConfigureAwait(false);

                cancellationToken.ThrowIfCancellationRequested();

                if (_commandLoopContext.HasNextIteration && repeatableCommand.CanRepeat() &&
                    repeatableCommand.CanExecute().IsSuccess)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    repeatableCommand.IncreaceIteration();
                    _commandPool.Push(repeatableCommand);
                    CommandAutoExecuted?.Invoke(this, EventArgs.Empty);
                }
                else
                {
                    await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);

                    CommandProcessed?.Invoke(this, EventArgs.Empty);
                }
            }
            else
            {
                await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);

                CommandProcessed?.Invoke(this, EventArgs.Empty);
            }
        }

        private async Task SetHasPendingCommandsAsync(bool value, CancellationToken cancellationToken)
        {
            await _semaphoreSlim.WaitAsync(cancellationToken).ConfigureAwait(false);
            try
            {
                _hasPendingCommand = value;
            }
            finally
            {
                _semaphoreSlim.Release();
            }
        }

        private async Task<ICommand?> TryExecuteCommandAsync(ICommand? lastCommand, CancellationToken cancellationToken)
        {
            ICommand? commandWithError = null;
            ICommand? newLastCommand = null;

            var errorOccured = false;

            var command = _commandPool.Pop();

            try
            {
                if (command != null)
                {
                    await SetHasPendingCommandsAsync(true, cancellationToken).ConfigureAwait(false);

                    try
                    {
                        command.Execute();
                    }
                    catch (InvalidOperationException)
                    {
                        commandWithError = command;
                        throw;
                    }

                    await HandleRepeatableAsync(command, cancellationToken).ConfigureAwait(false);

                    newLastCommand = command;
                }
                else
                {
                    await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);

                    if (lastCommand != null)
                    {
                        CommandProcessed?.Invoke(this, EventArgs.Empty);
                        newLastCommand = null;
                    }
                }
            }
            catch (InvalidOperationException exception)
            {
                errorOccured = true;
                DoErrorOccured(commandWithError, exception);

                newLastCommand = null;
            }
            finally
            {
                if (errorOccured)
                {
                    await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);

                    CommandProcessed?.Invoke(this, EventArgs.Empty);
                    newLastCommand = null;
                }
            }

            return newLastCommand;
        }

        private async Task WaitGlobeIterationPerformedAsync()
        {
            var fuseCounter = 100;
            while (fuseCounter > 0)
            {
                await Task.Yield();
                await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);

                if (_commandLoopContext.CanPlayerGiveCommand)
                {
                    break;
                }

                fuseCounter--;
            }
        }

        public event EventHandler<ErrorOccuredEventArgs>? ErrorOccured;
        public event EventHandler? CommandAutoExecuted;
        public event EventHandler? CommandProcessed;

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _cancellationTokebSourceInner = new CancellationTokenSource();
            var internalToken = _cancellationTokebSourceInner.Token;

            _linkedCts = CancellationTokenSource.CreateLinkedTokenSource(internalToken, cancellationToken);

            var linkedCancellationToken = _linkedCts.Token;

            IsStarted = true;
            return Task.Run(async () =>
            {
                ICommand? lastCommand = null;

                while (_commandLoopContext.HasNextIteration)
                {
                    linkedCancellationToken.ThrowIfCancellationRequested();

                    if (!_commandLoopContext.CanPlayerGiveCommand)
                    {
                        // If player can't gives command right now the loop sleep some time (100ms).
                        // Because this can wait a little to start new attempt of command execution.
                        await Task.Yield();
                        await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);
                        continue;
                    }

                    try
                    {
                        lastCommand = await TryExecuteCommandAsync(lastCommand, linkedCancellationToken)
                            .ConfigureAwait(false);
                    }
                    catch (Exception exception)
                    {
                        ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));
                    }

                    await Task.Yield();
                    await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);
                }
            }, linkedCancellationToken);
        }

        public bool IsStarted { get; private set; }

        public bool HasPendingCommands()
        {
            _semaphoreSlim.WaitAsync().Wait();
            try
            {
                return _hasPendingCommand;
            }
            finally
            {
                _semaphoreSlim.Release();
            }
        }

        public Task StopAsync()
        {
            if (_cancellationTokebSourceInner is not null)
            {
                _cancellationTokebSourceInner.Cancel();
                _cancellationTokebSourceInner.Dispose();
            }

            if (_linkedCts is not null)
            {
                _linkedCts.Dispose();
            }

            if (_semaphoreSlim.CurrentCount == 0)
            {
                _semaphoreSlim.Release();
            }

            IsStarted = false;

            return Task.CompletedTask;
        }

        public void Dispose()
        {
            if (_cancellationTokebSourceInner is not null)
            {
                _cancellationTokebSourceInner.Dispose();
            }

            if (_linkedCts is not null)
            {
                _linkedCts.Dispose();
            }
        }
    }
}

1	using System;
2	using System.Diagnostics.CodeAnalysis;
3	using System.Threading;
4	using System.Threading.Tasks;
5
6	using Zilon.Core.Commands;
7
8	namespace Zilon.Core.Client.Sector
9	{
10	public sealed class CommandLoopUpdater : ICommandLoopUpdater, IDisposable
11	{
12	private const int WAIT_FOR_CHANGES_MILLISECONDS = 100;
13	private readonly ICommandLoopContext _commandLoopContext;
14	private readonly ICommandPool _commandPool;
15
16	private readonly SemaphoreSlim _semaphoreSlim;
17	private CancellationTokenSource _cancellationTokebSourceInner;
18
19	private bool _hasPendingCommand;
20
21	private CancellationTokenSource _linkedCts;
22
23	[ExcludeFromCodeCoverage]
24	public CommandLoopUpdater(ICommandLoopContext commandLoopContext, ICommandPool commandPool)
25	{
26	_commandLoopContext = commandLoopContext;
27	_commandPool = commandPool;
28
29	_semaphoreSlim = new SemaphoreSlim(1, 1);
30	}
31
32	private void DoErrorOccured(ICommand? commandWithError, InvalidOperationException exception)
33	{
34	if (commandWithError != null)	12✔
35	{
36	ErrorOccured?.Invoke(this, new CommandErrorOccuredEventArgs(commandWithError, exception));	1!
37	}
38	else
39	{
40	ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));	11!
41	}
42	}	×
43
44	private async Task HandleRepeatableAsync(ICommand? command, CancellationToken cancellationToken)
45	{
46	if (command is IRepeatableCommand repeatableCommand)
47	{
48	// It is necesary because CanRepeate and CanExecute can perform early that globe updates its state.
49	await WaitGlobeIterationPerformedAsync().ConfigureAwait(false);
50
51	cancellationToken.ThrowIfCancellationRequested();
52
53	if (_commandLoopContext.HasNextIteration && repeatableCommand.CanRepeat() &&
54	repeatableCommand.CanExecute().IsSuccess)
55	{
56	cancellationToken.ThrowIfCancellationRequested();
57
58	repeatableCommand.IncreaceIteration();
59	_commandPool.Push(repeatableCommand);
60	CommandAutoExecuted?.Invoke(this, EventArgs.Empty);
61	}
62	else
63	{
64	await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);
65
66	CommandProcessed?.Invoke(this, EventArgs.Empty);
67	}
68	}
69	else
70	{
71	await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);
72
73	CommandProcessed?.Invoke(this, EventArgs.Empty);
74	}
75	}
76
77	private async Task SetHasPendingCommandsAsync(bool value, CancellationToken cancellationToken)
78	{
79	await _semaphoreSlim.WaitAsync(cancellationToken).ConfigureAwait(false);
80	try
81	{
82	_hasPendingCommand = value;
83	}
84	finally
85	{
86	_semaphoreSlim.Release();
87	}
88	}
89
90	private async Task<ICommand?> TryExecuteCommandAsync(ICommand? lastCommand, CancellationToken cancellationToken)
91	{
92	ICommand? commandWithError = null;
93	ICommand? newLastCommand = null;
94
95	var errorOccured = false;
96
97	var command = _commandPool.Pop();
98
99	try
100	{
101	if (command != null)
102	{
103	await SetHasPendingCommandsAsync(true, cancellationToken).ConfigureAwait(false);
104
105	try
106	{
107	command.Execute();
108	}
109	catch (InvalidOperationException)
110	{
111	commandWithError = command;
112	throw;
113	}
114
115	await HandleRepeatableAsync(command, cancellationToken).ConfigureAwait(false);
116
117	newLastCommand = command;
118	}
119	else
120	{
121	await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);
122
123	if (lastCommand != null)
124	{
125	CommandProcessed?.Invoke(this, EventArgs.Empty);
126	newLastCommand = null;
127	}
128	}
129	}
130	catch (InvalidOperationException exception)
131	{
132	errorOccured = true;
133	DoErrorOccured(commandWithError, exception);
134
135	newLastCommand = null;
136	}
137	finally
138	{
139	if (errorOccured)
140	{
141	await SetHasPendingCommandsAsync(false, cancellationToken).ConfigureAwait(false);
142
143	CommandProcessed?.Invoke(this, EventArgs.Empty);
144	newLastCommand = null;
145	}
146	}
147
148	return newLastCommand;
149	}
150
151	private async Task WaitGlobeIterationPerformedAsync()
152	{
153	var fuseCounter = 100;
154	while (fuseCounter > 0)
155	{
156	await Task.Yield();
157	await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);
158
159	if (_commandLoopContext.CanPlayerGiveCommand)
160	{
161	break;
162	}
163
164	fuseCounter--;
165	}
166	}
167
168	public event EventHandler<ErrorOccuredEventArgs>? ErrorOccured;
169	public event EventHandler? CommandAutoExecuted;
170	public event EventHandler? CommandProcessed;
171
172	public Task StartAsync(CancellationToken cancellationToken)
173	{
174	_cancellationTokebSourceInner = new CancellationTokenSource();	5✔
175	var internalToken = _cancellationTokebSourceInner.Token;	5✔
176
177	_linkedCts = CancellationTokenSource.CreateLinkedTokenSource(internalToken, cancellationToken);	5✔
178
179	var linkedCancellationToken = _linkedCts.Token;	5✔
180
181	IsStarted = true;	5✔
182	return Task.Run(async () =>	5✔
183	{	5✔
184	ICommand? lastCommand = null;	5✔
185		5✔
186	while (_commandLoopContext.HasNextIteration)	5✔
187	{	5✔
188	linkedCancellationToken.ThrowIfCancellationRequested();	5✔
189		5✔
190	if (!_commandLoopContext.CanPlayerGiveCommand)	5✔
191	{	5✔
192	// If player can't gives command right now the loop sleep some time (100ms).	5✔
193	// Because this can wait a little to start new attempt of command execution.	5✔
194	await Task.Yield();	5✔
195	await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);	5✔
196	continue;	5✔
197	}	5✔
198		5✔
199	try	5✔
200	{	5✔
201	lastCommand = await TryExecuteCommandAsync(lastCommand, linkedCancellationToken)	5✔
202	.ConfigureAwait(false);	5✔
203	}	5✔
204	catch (Exception exception)	5✔
205	{	5✔
206	ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));	5✔
207	}	5✔
208		5✔
209	await Task.Yield();	5✔
210	await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);	5✔
211	}	5✔
212	}, linkedCancellationToken);	5✔
213	}
214
215	public bool IsStarted { get; private set; }
216
217	public bool HasPendingCommands()
218	{
219	_semaphoreSlim.WaitAsync().Wait();	×
220	try
221	{
UNCOV 222	return _hasPendingCommand;	×
223	}
224	finally
225	{
UNCOV 226	_semaphoreSlim.Release();	×
227	}	×
UNCOV 228	}	×
229
230	public Task StopAsync()
231	{
NEW UNCOV 232	if (_cancellationTokebSourceInner is not null)	×
233	{
NEW 234	_cancellationTokebSourceInner.Cancel();	×
NEW 235	_cancellationTokebSourceInner.Dispose();	×
236	}
237
NEW 238	if (_linkedCts is not null)	×
239	{
NEW 240	_linkedCts.Dispose();	×
241	}
242
NEW 243	if (_semaphoreSlim.CurrentCount == 0)	×
244	{
NEW 245	_semaphoreSlim.Release();	×
246	}
247
NEW 248	IsStarted = false;	×
249
NEW 250	return Task.CompletedTask;	×
251	}
252
253	public void Dispose()
254	{
NEW 255	if (_cancellationTokebSourceInner is not null)	×
256	{
NEW 257	_cancellationTokebSourceInner.Dispose();	×
258	}
259
NEW 260	if (_linkedCts is not null)	×
261	{
NEW 262	_linkedCts.Dispose();	×
263	}
NEW 264	}	×
265	}
266	}

kreghek / Zilon_Roguelike / 992192048

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