370448557

Build Type

github

Committed by GitHub

Commit Message

Merge 32faf007e into ddff96f32

Pull Request Pull Request #902: Fix attack though walls

Run Details

4285 of 7134 branches covered (60.06%)

Branch coverage included in aggregate %.

40 of 44 new or added lines in 5 files covered. (90.91%)

8 existing lines in 3 files now uncovered.

6439 of 8725 relevant lines covered (73.8%)

757182.88 hits per line

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

65.5

/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 SectorHasAttackTarget(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 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);
            }
        }
    }

    public class ActTargetInfo
    {
        public ActTargetInfo(IAttackTarget targetObject, IGraphNode targetNode)
        {
            TargetObject = targetObject ?? throw new ArgumentNullException(nameof(targetObject));
            TargetNode = targetNode ?? throw new ArgumentNullException(nameof(targetNode));
        }

        public IGraphNode TargetNode { get; }

        public IAttackTarget TargetObject { get; }
    }
}

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(	52✔
37	ITacticalActUsageRandomSource actUsageRandomSource,	52✔
38	IActUsageHandlerSelector actUsageHandlerSelector)	52✔
39	{	26✔
40	_actUsageRandomSource =	52!
41	actUsageRandomSource ?? throw new ArgumentNullException(nameof(actUsageRandomSource));	52✔
42	_actUsageHandlerSelector = actUsageHandlerSelector ??	52!
43	throw new ArgumentNullException(nameof(actUsageHandlerSelector));	52✔
44	}	52✔
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; }	74✔
57
58	/// <summary>
59	/// Возвращает случайное значение эффективность действия.
60	/// </summary>
61	/// <param name="act"> Соверщённое действие. </param>
62	/// <returns> Возвращает выпавшее значение эффективности. </returns>
63	private TacticalActRoll GetActEfficient(ITacticalAct act)
64	{	49✔
65	var rolledEfficient = _actUsageRandomSource.RollEfficient(act.Efficient);	153✔
66
67	var roll = new TacticalActRoll(act, rolledEfficient);	153✔
68
69	return roll;	153✔
70	}	49✔
71
72	private static IEnumerable<IGraphNode> GetActorNodes(
73	PhysicalSizePattern physicalSize,
74	IGraphNode baseNode,
75	IMap map)
76	{	50✔
77	yield return baseNode;	155✔
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();	4✔
92	return roll;	4✔
93	}	2✔
94
95	private static int GetUseSuccessRoll()
96	{	2✔
97	// В будущем успех использования вторичных дейсвий будет зависить от действия, экипировки, перков.
98	return 5;	4✔
99	}	2✔
100
101	private static bool IsInDistance(IActor actor, IGraphNode targetNode, ITacticalAct act, ISectorMap map)
102	{	50✔
103	var actorNodes = GetActorNodes(actor.PhysicalSize, actor.Node, map);	155✔
104
105	foreach (var node in actorNodes)	515!
106	{	50✔
107	var isInDistanceInNode = act.CheckDistance(node, targetNode, map);	155✔
108	if (isInDistanceInNode)	155!
109	{	50✔
110	return true;	155✔
111	}
112	}
113
114	return false;	×
115	}	155✔
116
117	private static void RemovePropResource(IActor actor, ITacticalAct act)
118	{	3✔
119	var propResources = from prop in actor.Person.GetModule<IInventoryModule>().CalcActualItems()	8✔
120	where prop is Resource	16✔
121	where prop.Scheme.Bullet?.Caliber == act.Constrains.PropResourceType	16!
122	select prop;	8✔
123
124	if (propResources.FirstOrDefault() is Resource propResource)	8!
125	{	3✔
126	if (propResource.Count >= act.Constrains.PropResourceCount)	8!
127	{	3✔
128	var usedResource = new Resource(propResource.Scheme, act.Constrains.PropResourceCount.Value);	8✔
129	actor.Person.GetModule<IInventoryModule>().Remove(usedResource);	8✔
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 SectorHasAttackTarget(ISector sector, IAttackTarget target)
145	{	49✔
146	if (sector.ActorManager is null)	49!
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));	171✔
153	}	49✔
154
155	private static bool SectorHasCurrentActor(ISector sector, IActor actor)
156	{	49✔
157	if (sector.ActorManager is null)	49!
158	{	3✔
159	// In test environment not all sector mocks has actor manager
160	return true;	3✔
161	}
162
163	return sector.ActorManager.Items.Any(x => x == actor);	125✔
164	}	49✔
165
166	private void UseAct(IActor actor, ActTargetInfo target, ITacticalAct act, ISectorMap map)
167	{	50✔
168	bool isInDistance;
169	if ((act.Stats.Targets & TacticalActTargets.Self) > 0 && actor == target)	155!
170	{
171	isInDistance = true;	×
172	}
173	else
174	{	50✔
175	isInDistance = IsInDistance(actor, target.TargetNode, act, map);	155✔
176	}	50✔
177
178	if (!isInDistance)	155!
179	{
180	// Это может произойти, если цель, в процессе применения действия
181	// успела выйти из радиуса применения.
182	// TODO Лучше сделать, чтобы этот метод возвращал объект с результатом выполнения действия.
183	// А внешний код пусть либо считает исход допустимым, либо выбрасывает исключения типа UsageOutOfDistanceException
184	return;	×
185	}
186
187	var targetNode = target.TargetNode;	155✔
188
189	var targetIsOnLine = map.TargetIsOnLine(	155✔
190	actor.Node,	155✔
191	targetNode);	155✔
192
193	if (targetIsOnLine)	155✔
194	{	49✔
195	actor.UseAct(targetNode, act);	153✔
196
197	var tacticalActRoll = GetActEfficient(act);	153✔
198
199	var actHandler = _actUsageHandlerSelector.GetHandler(target.TargetObject);	153✔
200	actHandler.ProcessActUsage(actor, target.TargetObject, tacticalActRoll);	153✔
201
202	UseActResources(actor, act);	153✔
203	}	49✔
204	else
205	{	1✔
206	// Ситация, когда цель за стеной может произойти по следующим причинам:
207	// 1. В момент начала применения действия цель была доступна. К моменту выполнения дейтвия цель скрылась.
208	// В этом случае изымаем патроны и начинаем КД по действию, так как фактически ресурсы на него потрачены. Но на цель не воздействуем.
209	// 2. Ошибка во внешнем коде, когда не провели предварительную проверку. Это проверяется сравнением ячейки в которую целились
210	// на момент начала действия и текущую ячейку цели.
211
212	if (target.TargetNode == target.TargetObject.Node)	2!
213	{	1✔
214	throw new UsageThroughtWallException();	2✔
215	}
216
NEW 217	UseActResources(actor, act);	×
218	}
219	}	49✔
220
221	private void UseActResources(IActor actor, ITacticalAct act)
222	{	49✔
223	// Изъятие патронов
224	if (act.Constrains?.PropResourceType != null)	153✔
225	{	3✔
226	RemovePropResource(actor, act);	8✔
227	}	3✔
228
229	if (act.Equipment != null)	153✔
230	{	10✔
231	EquipmentDurableService?.UpdateByUse(act.Equipment, actor.Person);	32!
232	}	10✔
233
234	// Сброс КД, если он есть.
235	act.StartCooldownIfItIs();	153✔
236	}	153✔
237
238	public void UseOn(IActor actor, ActTargetInfo target, UsedTacticalActs usedActs, ISector sector)
239	{	49✔
240	if (actor is null)	153!
241	{
242	throw new ArgumentNullException(nameof(actor));	×
243	}
244
245	if (target is null)	153!
246	{
247	throw new ArgumentNullException(nameof(target));	×
248	}
249
250	if (usedActs is null)	153!
251	{
252	throw new ArgumentNullException(nameof(usedActs));	×
253	}
254
255	if (sector is null)	153!
256	{
257	throw new ArgumentNullException(nameof(sector));	×
258	}
259
260	Debug.Assert(SectorHasCurrentActor(sector, actor), "Current actor must be in sector");	49✔
261	Debug.Assert(SectorHasAttackTarget(sector, target.TargetObject), "Target must be in sector");	49✔
262
263	foreach (var act in usedActs.Primary)	659✔
264	{	49✔
265	if (!act.Stats.Targets.HasFlag(TacticalActTargets.Self) && actor == target)	153!
266	{
267	throw new ArgumentException("Актёр не может атаковать сам себя", nameof(target));	×
268	}
269
270	UseAct(actor, target, act, sector.Map);	153✔
271	}	48✔
272
273	// Использование дополнительных действий.
274	// Используются с некоторой вероятностью.
275	foreach (var act in usedActs.Secondary)	143✔
276	{	2✔
277	var useSuccessRoll = GetUseSuccessRoll();	4✔
278	var useFactRoll = GetUseFactRoll();	4✔
279
280	if (useFactRoll < useSuccessRoll)	4✔
281	{	1✔
282	continue;	1✔
283	}
284
285	UseAct(actor, target, act, sector.Map);	2✔
286	}	1✔
287	}	151✔
288	}
289
290	public class ActTargetInfo
291	{
292	public ActTargetInfo(IAttackTarget targetObject, IGraphNode targetNode)	153✔
293	{	49✔
294	TargetObject = targetObject ?? throw new ArgumentNullException(nameof(targetObject));	153!
295	TargetNode = targetNode ?? throw new ArgumentNullException(nameof(targetNode));	153!
296	}	153✔
297
298	public IGraphNode TargetNode { get; }	312✔
299
300	public IAttackTarget TargetObject { get; }	357✔
301	}
302	}

kreghek / Zilon_Roguelike / 370448557

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