Build has been set to done!

480635047

Build Type

github

Committed by GitHub

Commit Message

Merge 362997fa7 into 022a51f71

Pull Request Pull Request #1003: Fix 986 restore code coverage gate passing unit

Run Details

2079 of 3398 branches covered (61.18%)

Branch coverage included in aggregate %.

19 of 43 new or added lines in 4 files covered. (44.19%)

103 existing lines in 40 files now uncovered.

7441 of 11276 relevant lines covered (65.99%)

65066.14 hits per line

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

67.59

/Zilon.Core/Zilon.Core/Tactics/TacticalActUsageService.cs

﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

using Zilon.Core.Components;
using Zilon.Core.Graphs;
using Zilon.Core.PersonModules;
using Zilon.Core.Persons;
using Zilon.Core.Props;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.Tactics
{
    /// <summary>
    /// Базовая реализация сервиса для работы с действиями персонажа.
    /// </summary>
    /// <seealso cref="ITacticalActUsageService" />
    public sealed class TacticalActUsageService : ITacticalActUsageService
    {
        private readonly IActUsageHandlerSelector _actUsageHandlerSelector;
        private readonly ITacticalActUsageRandomSource _actUsageRandomSource;

        /// <summary>
        /// Конструирует экземпляр службы <see cref="TacticalActUsageService" />.
        /// </summary>
        /// <param name="actUsageRandomSource">Источник рандома для выполнения действий.</param>
        /// <param name="perkResolver">Сервис для работы с прогрессом перков.</param>
        /// <exception cref="System.ArgumentNullException">
        /// actUsageRandomSource
        /// or
        /// perkResolver
        /// or
        /// sectorManager
        /// </exception>
        public TacticalActUsageService(
            ITacticalActUsageRandomSource actUsageRandomSource,
            IActUsageHandlerSelector actUsageHandlerSelector)
        {
            _actUsageRandomSource =
                actUsageRandomSource ?? throw new ArgumentNullException(nameof(actUsageRandomSource));
            _actUsageHandlerSelector = actUsageHandlerSelector ??
                                       throw new ArgumentNullException(nameof(actUsageHandlerSelector));
        }

        public TacticalActUsageService(
            ITacticalActUsageRandomSource actUsageRandomSource,
            IActUsageHandlerSelector actUsageHandlerSelector,
            IEquipmentDurableService equipmentDurableService) : this(actUsageRandomSource, actUsageHandlerSelector)
        {
            EquipmentDurableService = equipmentDurableService ??
                                      throw new ArgumentNullException(nameof(equipmentDurableService));
        }

        /// <summary>Сервис для работы с прочностью экипировки.</summary>
        public IEquipmentDurableService EquipmentDurableService { get; set; }

        /// <summary>
        /// Возвращает случайное значение эффективность действия.
        /// </summary>
        /// <param name="act"> Соверщённое действие. </param>
        /// <returns> Возвращает выпавшее значение эффективности. </returns>
        private TacticalActRoll GetActEfficient(ITacticalAct act)
        {
            var rolledEfficient = _actUsageRandomSource.RollEfficient(act.Efficient);

            var roll = new TacticalActRoll(act, rolledEfficient);

            return roll;
        }

        private static IEnumerable<IGraphNode> GetActorNodes(
            PhysicalSizePattern physicalSize,
            IGraphNode baseNode,
            IMap map)
        {
            yield return baseNode;

            if (physicalSize == PhysicalSizePattern.Size7)
            {
                var neighbors = map.GetNext(baseNode);
                foreach (var neighbor in neighbors)
                {
                    yield return neighbor;
                }
            }
        }

        private int GetUseFactRoll()
        {
            var roll = _actUsageRandomSource.RollUseSecondaryAct();
            return roll;
        }

        private static int GetUseSuccessRoll()
        {
            // В будущем успех использования вторичных дейсвий будет зависить от действия, экипировки, перков.
            return 5;
        }

        private static bool IsInDistance(IActor actor, IGraphNode targetNode, ITacticalAct act, ISectorMap map)
        {
            var actorNodes = GetActorNodes(actor.PhysicalSize, actor.Node, map);

            foreach (var node in actorNodes)
            {
                var isInDistanceInNode = act.CheckDistance(node, targetNode, map);
                if (isInDistanceInNode)
                {
                    return true;
                }
            }

            return false;
        }

        private static void RemovePropResource(IActor actor, ITacticalAct act)
        {
            var propResources = from prop in actor.Person.GetModule<IInventoryModule>().CalcActualItems()
                                where prop is Resource
                                where prop.Scheme.Bullet?.Caliber == act.Constrains.PropResourceType
                                select prop;

            if (propResources.FirstOrDefault() is Resource propResource)
            {
                if (propResource.Count >= act.Constrains.PropResourceCount)
                {
                    var usedResource = new Resource(propResource.Scheme, act.Constrains.PropResourceCount.Value);
                    actor.Person.GetModule<IInventoryModule>().Remove(usedResource);
                }
                else
                {
                    throw new InvalidOperationException(
                        $"Не хватает ресурса {propResource} для использования действия {act}.");
                }
            }
            else
            {
                throw new InvalidOperationException(
                    $"Не хватает ресурса {act.Constrains?.PropResourceType} для использования действия {act}.");
            }
        }

        private static bool SectorHasAttackedActor(ISector sector, IAttackTarget target)
        {
            if (sector.ActorManager is null)
            {
                // In test environment not all sector mocks has actor manager
                return true;
            }

            return sector.ActorManager.Items.Any(x => ReferenceEquals(x, target));
        }

        private static bool SectorHasAttackedStaticObject(ISector sector, IAttackTarget target)
        {
            if (sector.StaticObjectManager is null)
            {
                // In test environment not all sector mocks has actor manager
                return true;
            }

            return sector.StaticObjectManager.Items.Any(x => ReferenceEquals(x, target));
        }

        private static bool SectorHasAttackTarget(ISector sector, IAttackTarget target)
        {
            switch (target)
            {
                case IActor actor:
                    return SectorHasAttackedActor(sector, actor);

                case IStaticObject staticObject:
                    return SectorHasAttackedStaticObject(sector, staticObject);

                default:
                    throw new InvalidOperationException($"Unknown attack target type {target.GetType().FullName}.");
            }
        }

        private static bool SectorHasCurrentActor(ISector sector, IActor actor)
        {
            if (sector.ActorManager is null)
            {
                // In test environment not all sector mocks has actor manager
                return true;
            }

            return sector.ActorManager.Items.Any(x => x == actor);
        }

        private void UseAct(IActor actor, ActTargetInfo target, ITacticalAct act, ISectorMap map)
        {
            bool isInDistance;
            if ((act.Stats.Targets & TacticalActTargets.Self) > 0 && actor == target)
            {
                isInDistance = true;
            }
            else
            {
                isInDistance = IsInDistance(actor, target.TargetNode, act, map);
            }

            if (!isInDistance)
            {
                // Это может произойти, если цель, в процессе применения действия
                // успела выйти из радиуса применения.
                // TODO Лучше сделать, чтобы этот метод возвращал объект с результатом выполнения действия.
                // А внешний код пусть либо считает исход допустимым, либо выбрасывает исключения типа UsageOutOfDistanceException
                return;
            }

            var targetNode = target.TargetNode;

            var targetIsOnLine = map.TargetIsOnLine(
                actor.Node,
                targetNode);

            if (targetIsOnLine)
            {
                actor.UseAct(targetNode, act);

                var tacticalActRoll = GetActEfficient(act);

                var actHandler = _actUsageHandlerSelector.GetHandler(target.TargetObject);
                actHandler.ProcessActUsage(actor, target.TargetObject, tacticalActRoll);

                UseActResources(actor, act);
            }
            else
            {
                // Ситация, когда цель за стеной может произойти по следующим причинам:
                // 1. В момент начала применения действия цель была доступна. К моменту выполнения дейтвия цель скрылась.
                // В этом случае изымаем патроны и начинаем КД по действию, так как фактически ресурсы на него потрачены. Но на цель не воздействуем.
                // 2. Ошибка во внешнем коде, когда не провели предварительную проверку. Это проверяется сравнением ячейки в которую целились
                // на момент начала действия и текущую ячейку цели.

                if (target.TargetNode == target.TargetObject.Node)
                {
                    throw new UsageThroughtWallException();
                }

                UseActResources(actor, act);
            }
        }

        private void UseActResources(IActor actor, ITacticalAct act)
        {
            // Изъятие патронов
            if (act.Constrains?.PropResourceType != null)
            {
                RemovePropResource(actor, act);
            }

            if (act.Equipment != null)
            {
                EquipmentDurableService?.UpdateByUse(act.Equipment, actor.Person);
            }

            // Сброс КД, если он есть.
            act.StartCooldownIfItIs();
        }

        public void UseOn(IActor actor, ActTargetInfo target, UsedTacticalActs usedActs, ISector sector)
        {
            if (actor is null)
            {
                throw new ArgumentNullException(nameof(actor));
            }

            if (target is null)
            {
                throw new ArgumentNullException(nameof(target));
            }

            if (usedActs is null)
            {
                throw new ArgumentNullException(nameof(usedActs));
            }

            if (sector is null)
            {
                throw new ArgumentNullException(nameof(sector));
            }

            Debug.Assert(SectorHasCurrentActor(sector, actor), "Current actor must be in sector");
            Debug.Assert(SectorHasAttackTarget(sector, target.TargetObject), "Target must be in sector");

            foreach (var act in usedActs.Primary)
            {
                if (!act.Stats.Targets.HasFlag(TacticalActTargets.Self) && actor == target)
                {
                    throw new ArgumentException("Актёр не может атаковать сам себя", nameof(target));
                }

                UseAct(actor, target, act, sector.Map);
            }

            // Использование дополнительных действий.
            // Используются с некоторой вероятностью.
            foreach (var act in usedActs.Secondary)
            {
                var useSuccessRoll = GetUseSuccessRoll();
                var useFactRoll = GetUseFactRoll();

                if (useFactRoll < useSuccessRoll)
                {
                    continue;
                }

                UseAct(actor, target, act, sector.Map);
            }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics;
4	using System.Linq;
5
6	using Zilon.Core.Components;
7	using Zilon.Core.Graphs;
8	using Zilon.Core.PersonModules;
9	using Zilon.Core.Persons;
10	using Zilon.Core.Props;
11	using Zilon.Core.Tactics.Spatial;
12
13	namespace Zilon.Core.Tactics
14	{
15	/// <summary>
16	/// Базовая реализация сервиса для работы с действиями персонажа.
17	/// </summary>
18	/// <seealso cref="ITacticalActUsageService" />
19	public sealed class TacticalActUsageService : ITacticalActUsageService
20	{
21	private readonly IActUsageHandlerSelector _actUsageHandlerSelector;
22	private readonly ITacticalActUsageRandomSource _actUsageRandomSource;
23
24	/// <summary>
25	/// Конструирует экземпляр службы <see cref="TacticalActUsageService" />.
26	/// </summary>
27	/// <param name="actUsageRandomSource">Источник рандома для выполнения действий.</param>
28	/// <param name="perkResolver">Сервис для работы с прогрессом перков.</param>
29	/// <exception cref="System.ArgumentNullException">
30	/// actUsageRandomSource
31	/// or
32	/// perkResolver
33	/// or
34	/// sectorManager
35	/// </exception>
36	public TacticalActUsageService(	×
37	ITacticalActUsageRandomSource actUsageRandomSource,	×
38	IActUsageHandlerSelector actUsageHandlerSelector)	×
39	{	27✔
40	_actUsageRandomSource =	×
41	actUsageRandomSource ?? throw new ArgumentNullException(nameof(actUsageRandomSource));	×
42	_actUsageHandlerSelector = actUsageHandlerSelector ??	×
43	throw new ArgumentNullException(nameof(actUsageHandlerSelector));	×
44	}	27✔
45
46	public TacticalActUsageService(
47	ITacticalActUsageRandomSource actUsageRandomSource,
48	IActUsageHandlerSelector actUsageHandlerSelector,
49	IEquipmentDurableService equipmentDurableService) : this(actUsageRandomSource, actUsageHandlerSelector)	×
50	{	×
51	EquipmentDurableService = equipmentDurableService ??	×
52	throw new ArgumentNullException(nameof(equipmentDurableService));	×
53	}	×
54
55	/// <summary>Сервис для работы с прочностью экипировки.</summary>
56	public IEquipmentDurableService EquipmentDurableService { get; set; }
57
58	/// <summary>
59	/// Возвращает случайное значение эффективность действия.
60	/// </summary>
61	/// <param name="act"> Соверщённое действие. </param>
62	/// <returns> Возвращает выпавшее значение эффективности. </returns>
63	private TacticalActRoll GetActEfficient(ITacticalAct act)
64	{	238✔
65	var rolledEfficient = _actUsageRandomSource.RollEfficient(act.Efficient);	238✔
66
67	var roll = new TacticalActRoll(act, rolledEfficient);	238✔
68
69	return roll;	238✔
70	}	238✔
71
72	private static IEnumerable<IGraphNode> GetActorNodes(
73	PhysicalSizePattern physicalSize,
74	IGraphNode baseNode,
75	IMap map)
76	{
77	yield return baseNode;
78
79	if (physicalSize == PhysicalSizePattern.Size7)
80	{
81	var neighbors = map.GetNext(baseNode);
82	foreach (var neighbor in neighbors)
83	{
84	yield return neighbor;
85	}
86	}
87	}
88
89	private int GetUseFactRoll()
90	{	2✔
91	var roll = _actUsageRandomSource.RollUseSecondaryAct();	2✔
92	return roll;	2✔
93	}	2✔
94
95	private static int GetUseSuccessRoll()
96	{	2✔
97	// В будущем успех использования вторичных дейсвий будет зависить от действия, экипировки, перков.
98	return 5;	2✔
99	}	2✔
100
101	private static bool IsInDistance(IActor actor, IGraphNode targetNode, ITacticalAct act, ISectorMap map)
102	{	239✔
103	var actorNodes = GetActorNodes(actor.PhysicalSize, actor.Node, map);	239✔
104
105	foreach (var node in actorNodes)	956!
106	{	239✔
107	var isInDistanceInNode = act.CheckDistance(node, targetNode, map);	239✔
108	if (isInDistanceInNode)	239!
109	{	239✔
110	return true;	239✔
111	}
112	}	×
113
114	return false;	×
115	}	239✔
116
117	private static void RemovePropResource(IActor actor, ITacticalAct act)
118	{	3✔
119	var propResources = from prop in actor.Person.GetModule<IInventoryModule>().CalcActualItems()	×
UNCOV 120	where prop is Resource	×
UNCOV 121	where prop.Scheme.Bullet?.Caliber == act.Constrains.PropResourceType	×
122	select prop;	×
123
124	if (propResources.FirstOrDefault() is Resource propResource)	3!
125	{	3✔
126	if (propResource.Count >= act.Constrains.PropResourceCount)	3!
127	{	3✔
128	var usedResource = new Resource(propResource.Scheme, act.Constrains.PropResourceCount.Value);	3✔
129	actor.Person.GetModule<IInventoryModule>().Remove(usedResource);	3✔
130	}	3✔
131	else
132	{	×
133	throw new InvalidOperationException(	×
134	$"Не хватает ресурса {propResource} для использования действия {act}.");	×
135	}
136	}	3✔
137	else
138	{	×
139	throw new InvalidOperationException(	×
140	$"Не хватает ресурса {act.Constrains?.PropResourceType} для использования действия {act}.");	×
141	}
142	}	3✔
143
144	private static bool SectorHasAttackedActor(ISector sector, IAttackTarget target)
145	{	108✔
146	if (sector.ActorManager is null)	108✔
147	{	3✔
148	// In test environment not all sector mocks has actor manager
149	return true;	3✔
150	}
151
152	return sector.ActorManager.Items.Any(x => ReferenceEquals(x, target));	105✔
153	}	108✔
154
155	private static bool SectorHasAttackedStaticObject(ISector sector, IAttackTarget target)
156	{	130✔
157	if (sector.StaticObjectManager is null)	130!
158	{	×
159	// In test environment not all sector mocks has actor manager
160	return true;	×
161	}
162
163	return sector.StaticObjectManager.Items.Any(x => ReferenceEquals(x, target));	130✔
164	}	130✔
165
166	private static bool SectorHasAttackTarget(ISector sector, IAttackTarget target)
167	{	238✔
168	switch (target)	238!
169	{
170	case IActor actor:
171	return SectorHasAttackedActor(sector, actor);	108✔
172
173	case IStaticObject staticObject:
174	return SectorHasAttackedStaticObject(sector, staticObject);	130✔
175
176	default:
177	throw new InvalidOperationException($"Unknown attack target type {target.GetType().FullName}.");	×
178	}
179	}	238✔
180
181	private static bool SectorHasCurrentActor(ISector sector, IActor actor)
182	{	238✔
183	if (sector.ActorManager is null)	238✔
184	{	3✔
185	// In test environment not all sector mocks has actor manager
186	return true;	3✔
187	}
188
189	return sector.ActorManager.Items.Any(x => x == actor);	235✔
190	}	238✔
191
192	private void UseAct(IActor actor, ActTargetInfo target, ITacticalAct act, ISectorMap map)
193	{	239✔
194	bool isInDistance;
195	if ((act.Stats.Targets & TacticalActTargets.Self) > 0 && actor == target)	239!
196	{	×
197	isInDistance = true;	×
198	}	×
199	else
200	{	239✔
201	isInDistance = IsInDistance(actor, target.TargetNode, act, map);	239✔
202	}	239✔
203
204	if (!isInDistance)	239!
205	{	×
206	// Это может произойти, если цель, в процессе применения действия
207	// успела выйти из радиуса применения.
208	// TODO Лучше сделать, чтобы этот метод возвращал объект с результатом выполнения действия.
209	// А внешний код пусть либо считает исход допустимым, либо выбрасывает исключения типа UsageOutOfDistanceException
210	return;	×
211	}
212
213	var targetNode = target.TargetNode;	239✔
214
215	var targetIsOnLine = map.TargetIsOnLine(	×
216	actor.Node,	×
217	targetNode);	×
218
219	if (targetIsOnLine)	239✔
220	{	238✔
221	actor.UseAct(targetNode, act);	238✔
222
223	var tacticalActRoll = GetActEfficient(act);	238✔
224
225	var actHandler = _actUsageHandlerSelector.GetHandler(target.TargetObject);	238✔
226	actHandler.ProcessActUsage(actor, target.TargetObject, tacticalActRoll);	238✔
227
228	UseActResources(actor, act);	238✔
229	}	238✔
230	else
231	{	1✔
232	// Ситация, когда цель за стеной может произойти по следующим причинам:
233	// 1. В момент начала применения действия цель была доступна. К моменту выполнения дейтвия цель скрылась.
234	// В этом случае изымаем патроны и начинаем КД по действию, так как фактически ресурсы на него потрачены. Но на цель не воздействуем.
235	// 2. Ошибка во внешнем коде, когда не провели предварительную проверку. Это проверяется сравнением ячейки в которую целились
236	// на момент начала действия и текущую ячейку цели.
237
238	if (target.TargetNode == target.TargetObject.Node)	1!
239	{	1✔
240	throw new UsageThroughtWallException();	1✔
241	}
242
243	UseActResources(actor, act);	×
244	}	×
245	}	238✔
246
247	private void UseActResources(IActor actor, ITacticalAct act)
248	{	238✔
249	// Изъятие патронов
250	if (act.Constrains?.PropResourceType != null)	238✔
251	{	3✔
252	RemovePropResource(actor, act);	3✔
253	}	3✔
254
255	if (act.Equipment != null)	238✔
256	{	44✔
257	EquipmentDurableService?.UpdateByUse(act.Equipment, actor.Person);	44!
258	}	44✔
259
260	// Сброс КД, если он есть.
261	act.StartCooldownIfItIs();	238✔
262	}	238✔
263
264	public void UseOn(IActor actor, ActTargetInfo target, UsedTacticalActs usedActs, ISector sector)
265	{	238✔
266	if (actor is null)	238!
267	{	×
268	throw new ArgumentNullException(nameof(actor));	×
269	}
270
271	if (target is null)	238!
272	{	×
273	throw new ArgumentNullException(nameof(target));	×
274	}
275
276	if (usedActs is null)	238!
277	{	×
278	throw new ArgumentNullException(nameof(usedActs));	×
279	}
280
281	if (sector is null)	238!
282	{	×
283	throw new ArgumentNullException(nameof(sector));	×
284	}
285
286	Debug.Assert(SectorHasCurrentActor(sector, actor), "Current actor must be in sector");	238✔
287	Debug.Assert(SectorHasAttackTarget(sector, target.TargetObject), "Target must be in sector");	238✔
288
289	foreach (var act in usedActs.Primary)	1,189✔
290	{	238✔
291	if (!act.Stats.Targets.HasFlag(TacticalActTargets.Self) && actor == target)	238!
292	{	×
293	throw new ArgumentException("Актёр не может атаковать сам себя", nameof(target));	×
294	}
295
296	UseAct(actor, target, act, sector.Map);	238✔
297	}	237✔
298
299	// Использование дополнительных действий.
300	// Используются с некоторой вероятностью.
301	foreach (var act in usedActs.Secondary)	715✔
302	{	2✔
303	var useSuccessRoll = GetUseSuccessRoll();	2✔
304	var useFactRoll = GetUseFactRoll();	2✔
305
306	if (useFactRoll < useSuccessRoll)	2✔
307	{	1✔
308	continue;	1✔
309	}
310
311	UseAct(actor, target, act, sector.Map);	1✔
312	}	1✔
313	}	237✔
314	}
315	}

kreghek / Zilon_Roguelike / 480635047

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