Build has been canceled!

422271857

Build Type

github

Committed by GitHub

Commit Message

Merge 09997c25d into 4d358de9f

Pull Request Pull Request #938: Fix the text game restart after the main player person dead

Run Details

4042 of 7170 branches covered (56.37%)

Branch coverage included in aggregate %.

29 of 39 new or added lines in 4 files covered. (74.36%)

1 existing line in 1 file now uncovered.

6171 of 8776 relevant lines covered (70.32%)

865798.18 hits per line

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

44.62

/Zilon.Core/Zilon.Core/Tactics/Behaviour/HumanActorTaskSource.cs

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

using Zilon.Core.Common;
using Zilon.Core.PersonModules;

namespace Zilon.Core.Tactics.Behaviour
{
    /// <summary>
    /// Base implementation of user actor task source.
    /// </summary>
    /// <typeparam name="TContext"></typeparam>
    public sealed class HumanActorTaskSource<TContext> : IDisposable, IHumanActorTaskSource<TContext>
        where TContext : ISectorTaskSourceContext
    {
        private readonly IReceiver<IActorTask> _actorTaskReceiver;
        private readonly ISender<IActorTask> _actorTaskSender;
        private readonly SpscChannel<IActorTask> _spscChannel;
        private CancellationTokenSource _cancellationTokenSource;
        private IActor _currentActorIntention;
        private bool _intentionWait;

        public HumanActorTaskSource()
        {
            _spscChannel = new SpscChannel<IActorTask>();
            _actorTaskSender = _spscChannel;
            _actorTaskReceiver = _spscChannel;
            _cancellationTokenSource = new CancellationTokenSource();
        }

        /// <inheritdoc/>
        public void Dispose()
        {
            _spscChannel.Dispose();
            _cancellationTokenSource.Dispose();
        }

        private bool CurrentActorSetAndIsDead()
        {
            return (_currentActorIntention?.Person?.GetModuleSafe<ISurvivalModule>()?.IsDead).GetValueOrDefault();
        }

        /// <inheritdoc/>
        public async Task IntentAsync(IIntention intention, IActor activeActor)
        {
            if (_intentionWait)
            {
                // Это может происходить, если в клиентском коде предварительно не выполнили проверку CanIntent().
                // Проверка нужна, чтобы не допустить получение очереди задач.
                // Текущая реализация не допускает переопределение задач.
                // Поэтому каждое новое намерение будет складывать по новой задаче в очередь, пока выполняется текущая задача
                // Текущая задача выполняется в основном игровом цикле, который накручивает счётчик итераций, чтобы выполнить предусловия задачи.
                throw new InvalidOperationException(
                    "Попытка задать новое намерение, пока не выполнена текущая задача.");
            }

            var currentIntention = intention ?? throw new ArgumentNullException(nameof(intention));

            var actorTask = currentIntention.CreateActorTask(activeActor);

            _intentionWait = true;
            _currentActorIntention = activeActor;

            await _actorTaskSender.SendAsync(actorTask, _cancellationTokenSource.Token).ConfigureAwait(false);
        }

        /// <inheritdoc/>
        public async Task<IActorTask> GetActorTaskAsync(IActor actor, TContext context)
        {
            // Тезисы:
            // Этот источник команд ждёт, пока игрок не укажет задачу.
            // Задача генерируется из намерения. Это значит, что ждать нужно, пока не будет задано намерение.

            return await _actorTaskReceiver.ReceiveAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
        }

        /// <inheritdoc/>
        //TODO Избавиться от синхронного варианта.
        // Сейчас он оставлен прото из-за тестов. Сложностей с удалением нет, кроме рутины.
        [Obsolete("Использовать асинк-вариант вместо этого")]
        public void Intent(IIntention intention, IActor activeActor)
        {
            IntentAsync(intention, activeActor).Wait();
        }

        /// <inheritdoc/>
        public bool CanIntent()
        {
            return !_intentionWait && !CurrentActorSetAndIsDead();
        }

        /// <inheritdoc/>
        public void ProcessTaskExecuted(IActorTask actorTask)
        {
            // Пока ничего не делаем.
            // Это задел для парного оружия.
            // Парное оружие будет позволять выполнять удар вторым оружием,
            // когда задача выполнена, но не закончена.
        }

        /// <inheritdoc/>
        public void ProcessTaskComplete(IActorTask actorTask)
        {
            _intentionWait = false;
            _currentActorIntention = null;
        }

        /// <inheritdoc/>
        public void CancelTask(IActorTask cancelledActorTask)
        {
            _intentionWait = false;
            _currentActorIntention = null;
            DropIntentionWaiting();
        }

        /// <inheritdoc/>
        public void DropIntentionWaiting()
        {
            _intentionWait = false;
            _currentActorIntention = null;

            _cancellationTokenSource.Cancel();

            _cancellationTokenSource = new CancellationTokenSource();

            try
            {
                _spscChannel.CancelReceiving();
            }
            catch (TaskCanceledException)
            {
                // This is expected cancellation behaviour.
                // Just ensure that exception is corrent and continue execution.
            }
        }
    }
}

1	using System;
2	using System.Threading;
3	using System.Threading.Tasks;
4
5	using Zilon.Core.Common;
6	using Zilon.Core.PersonModules;
7
8	namespace Zilon.Core.Tactics.Behaviour
9	{
10	/// <summary>
11	/// Base implementation of user actor task source.
12	/// </summary>
13	/// <typeparam name="TContext"></typeparam>
14	public sealed class HumanActorTaskSource<TContext> : IDisposable, IHumanActorTaskSource<TContext>
15	where TContext : ISectorTaskSourceContext
16	{
17	private readonly IReceiver<IActorTask> _actorTaskReceiver;
18	private readonly ISender<IActorTask> _actorTaskSender;
19	private readonly SpscChannel<IActorTask> _spscChannel;
20	private CancellationTokenSource _cancellationTokenSource;
21	private IActor _currentActorIntention;
22	private bool _intentionWait;
23
24	public HumanActorTaskSource()	9✔
25	{	3✔
26	_spscChannel = new SpscChannel<IActorTask>();	9✔
27	_actorTaskSender = _spscChannel;	9✔
28	_actorTaskReceiver = _spscChannel;	9✔
29	_cancellationTokenSource = new CancellationTokenSource();	9✔
30	}	9✔
31
32	/// <inheritdoc/>
33	public void Dispose()
34	{	3✔
35	_spscChannel.Dispose();	9✔
36	_cancellationTokenSource.Dispose();	9✔
37	}	9✔
38
39	private bool CurrentActorSetAndIsDead()
40	{
41	return (_currentActorIntention?.Person?.GetModuleSafe<ISurvivalModule>()?.IsDead).GetValueOrDefault();	×
42	}
43
44	/// <inheritdoc/>
45	public async Task IntentAsync(IIntention intention, IActor activeActor)
46	{	2✔
47	if (_intentionWait)	6!
48	{
49	// Это может происходить, если в клиентском коде предварительно не выполнили проверку CanIntent().
50	// Проверка нужна, чтобы не допустить получение очереди задач.
51	// Текущая реализация не допускает переопределение задач.
52	// Поэтому каждое новое намерение будет складывать по новой задаче в очередь, пока выполняется текущая задача
53	// Текущая задача выполняется в основном игровом цикле, который накручивает счётчик итераций, чтобы выполнить предусловия задачи.
54	throw new InvalidOperationException(	×
55	"Попытка задать новое намерение, пока не выполнена текущая задача.");	×
56	}
57
58	var currentIntention = intention ?? throw new ArgumentNullException(nameof(intention));	6!
59
60	var actorTask = currentIntention.CreateActorTask(activeActor);	6✔
61
62	_intentionWait = true;	6✔
63	_currentActorIntention = activeActor;	6✔
64
65	await _actorTaskSender.SendAsync(actorTask, _cancellationTokenSource.Token).ConfigureAwait(false);	6✔
66	}	6✔
67
68	/// <inheritdoc/>
69	public async Task<IActorTask> GetActorTaskAsync(IActor actor, TContext context)
70	{	3✔
71	// Тезисы:
72	// Этот источник команд ждёт, пока игрок не укажет задачу.
73	// Задача генерируется из намерения. Это значит, что ждать нужно, пока не будет задано намерение.
74
75	return await _actorTaskReceiver.ReceiveAsync(_cancellationTokenSource.Token).ConfigureAwait(false);	9✔
76	}	6✔
77
78	/// <inheritdoc/>
79	//TODO Избавиться от синхронного варианта.
80	// Сейчас он оставлен прото из-за тестов. Сложностей с удалением нет, кроме рутины.
81	[Obsolete("Использовать асинк-вариант вместо этого")]
82	public void Intent(IIntention intention, IActor activeActor)
83	{
84	IntentAsync(intention, activeActor).Wait();	×
85	}	×
86
87	/// <inheritdoc/>
88	public bool CanIntent()
89	{
90	return !_intentionWait && !CurrentActorSetAndIsDead();	×
91	}
92
93	/// <inheritdoc/>
94	public void ProcessTaskExecuted(IActorTask actorTask)
95	{
96	// Пока ничего не делаем.
97	// Это задел для парного оружия.
98	// Парное оружие будет позволять выполнять удар вторым оружием,
99	// когда задача выполнена, но не закончена.
100	}	×
101
102	/// <inheritdoc/>
103	public void ProcessTaskComplete(IActorTask actorTask)
104	{
105	_intentionWait = false;	×
106	_currentActorIntention = null;	×
107	}	×
108
109	/// <inheritdoc/>
110	public void CancelTask(IActorTask cancelledActorTask)
111	{
NEW 112	_intentionWait = false;	×
NEW 113	_currentActorIntention = null;	×
NEW 114	DropIntentionWaiting();	×
NEW 115	}	×
116
117	/// <inheritdoc/>
118	public void DropIntentionWaiting()
119	{	1✔
120	_intentionWait = false;	3✔
121	_currentActorIntention = null;	3✔
122
123	_cancellationTokenSource.Cancel();	3✔
124
125	_cancellationTokenSource = new CancellationTokenSource();	3✔
126
127	try
128	{	1✔
129	_spscChannel.CancelReceiving();	3✔
130	}	3✔
NEW 131	catch (TaskCanceledException)	×
132	{
133	// This is expected cancellation behaviour.
134	// Just ensure that exception is corrent and continue execution.
NEW 135	}	×
136	}	3✔
137	}
138	}

kreghek / Zilon_Roguelike / 422271857

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