1000974815

Build Type

github

Committed by GitHub

Commit Message

Merge 7fefd091a into 259bc4863

Pull Request Pull Request #1217: Feature 1121 score screen

Run Details

1981 of 3786 branches covered (52.32%)

Branch coverage included in aggregate %.

20 of 26 new or added lines in 1 file covered. (76.92%)

3 existing lines in 1 file now uncovered.

5102 of 8030 relevant lines covered (63.54%)

36725.49 hits per line

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

75.64

/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 bool _hasPendingCommand;
        private CancellationTokenSource? _internalCancellationTokenSource;

        private CancellationTokenSource? _linkedCancellationTokenSource;

        [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)
        {
            _internalCancellationTokenSource = new CancellationTokenSource();
            var internalToken = _internalCancellationTokenSource.Token;

            _linkedCancellationTokenSource =
                CancellationTokenSource.CreateLinkedTokenSource(internalToken, cancellationToken);

            var linkedCancellationToken = _linkedCancellationTokenSource.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 (_internalCancellationTokenSource is not null)
            {
                _internalCancellationTokenSource.Cancel();
                _internalCancellationTokenSource.Dispose();
                _internalCancellationTokenSource = null;
            }

            if (_linkedCancellationTokenSource is not null)
            {
                _linkedCancellationTokenSource.Dispose();
                _linkedCancellationTokenSource = null;
            }

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

            IsStarted = false;

            return Task.CompletedTask;
        }

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

            if (_linkedCancellationTokenSource is not null)
            {
                _linkedCancellationTokenSource.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
18	private bool _hasPendingCommand;
19	private CancellationTokenSource? _internalCancellationTokenSource;
20
21	private CancellationTokenSource? _linkedCancellationTokenSource;
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)	34✔
35	{
36	ErrorOccured?.Invoke(this, new CommandErrorOccuredEventArgs(commandWithError, exception));	1!
37	}
38	else
39	{
40	ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));	33!
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	_internalCancellationTokenSource = new CancellationTokenSource();	6✔
175	var internalToken = _internalCancellationTokenSource.Token;	6✔
176
177	_linkedCancellationTokenSource =	6✔
178	CancellationTokenSource.CreateLinkedTokenSource(internalToken, cancellationToken);	6✔
179
180	var linkedCancellationToken = _linkedCancellationTokenSource.Token;	6✔
181
182	IsStarted = true;	6✔
183	return Task.Run(async () =>	6✔
184	{	6✔
185	ICommand? lastCommand = null;	6✔
186		6✔
187	while (_commandLoopContext.HasNextIteration)	6✔
188	{	6✔
189	linkedCancellationToken.ThrowIfCancellationRequested();	6✔
190		6✔
191	if (!_commandLoopContext.CanPlayerGiveCommand)	6✔
192	{	6✔
193	// If player can't gives command right now the loop sleep some time (100ms).	6✔
194	// Because this can wait a little to start new attempt of command execution.	6✔
195	await Task.Yield();	6✔
196	await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);	6✔
197	continue;	6✔
198	}	6✔
199		6✔
200	try	6✔
201	{	6✔
202	lastCommand = await TryExecuteCommandAsync(lastCommand, linkedCancellationToken)	6✔
203	.ConfigureAwait(false);	6✔
204	}	6✔
205	catch (Exception exception)	6✔
206	{	6✔
207	ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(exception));	6✔
208	}	6✔
209		6✔
210	await Task.Yield();	6✔
211	await Task.Delay(WAIT_FOR_CHANGES_MILLISECONDS).ConfigureAwait(false);	6✔
212	}	6✔
213	}, linkedCancellationToken);	6✔
214	}
215
216	public bool IsStarted { get; private set; }
217
218	public bool HasPendingCommands()
219	{
220	_semaphoreSlim.WaitAsync().Wait();	×
221	try
222	{
UNCOV 223	return _hasPendingCommand;	×
224	}
225	finally
226	{
227	_semaphoreSlim.Release();	×
UNCOV 228	}	×
UNCOV 229	}	×
230
231	public Task StopAsync()
232	{
233	if (_internalCancellationTokenSource is not null)	1✔
234	{
235	_internalCancellationTokenSource.Cancel();	1✔
236	_internalCancellationTokenSource.Dispose();	1✔
237	_internalCancellationTokenSource = null;	1✔
238	}
239
240	if (_linkedCancellationTokenSource is not null)	1✔
241	{
242	_linkedCancellationTokenSource.Dispose();	1✔
243	_linkedCancellationTokenSource = null;	1✔
244	}
245
246	if (_semaphoreSlim.CurrentCount == 0)	1!
247	{
NEW 248	_semaphoreSlim.Release();	×
249	}
250
251	IsStarted = false;	1✔
252
253	return Task.CompletedTask;	1✔
254	}
255
256	public void Dispose()
257	{
NEW 258	if (_internalCancellationTokenSource is not null)	×
259	{
NEW 260	_internalCancellationTokenSource.Dispose();	×
261	}
262
NEW 263	if (_linkedCancellationTokenSource is not null)	×
264	{
NEW 265	_linkedCancellationTokenSource.Dispose();	×
266	}
NEW 267	}	×
268	}
269	}

kreghek / Zilon_Roguelike / 1000974815

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