656258625

Build Type

github

Committed by GitHub

Commit Message

Merge 3fa0dbac9 into 54b1be009

Pull Request Pull Request #1053: Not-nullable references in Core

Run Details

2258 of 3676 branches covered (61.43%)

Branch coverage included in aggregate %.

357 of 536 new or added lines in 66 files covered. (66.6%)

53 existing lines in 23 files now uncovered.

6019 of 7926 relevant lines covered (75.94%)

34290.39 hits per line

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

73.24

/Zilon.Core/Zilon.Core/Commands/Sector/MoveCommand.cs

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

using Zilon.Core.Client;
using Zilon.Core.Graphs;
using Zilon.Core.PathFinding;
using Zilon.Core.Players;
using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Behaviour;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.Commands
{
    /// <summary>
    /// Команда на перемещение взвода в указанный узел карты.
    /// </summary>
    public class MoveCommand : ActorCommandBase, IRepeatableCommand
    {
        private readonly IPlayer _player;

        /// <summary>
        /// Конструктор на создание команды перемещения.
        /// </summary>
        /// <param name="gameLoop">
        /// Игровой цикл.
        /// Нужен для того, чтобы команда выполнила обновление игрового цикла
        /// после завершения перемещения персонажа.
        /// </param>
        /// <param name="sectorManager">
        /// Менеджер сектора.
        /// Нужен для получения информации о секторе.
        /// </param>
        /// <param name="playerState">
        /// Состояние игрока.
        /// Нужен для получения информации о текущем состоянии игрока.
        /// </param>
        /// <param name="actorManager">
        /// Менеджер актёров.
        /// Нужен для отслеживания противников при автоперемещении.
        /// </param>
        [ExcludeFromCodeCoverage]
        public MoveCommand(
            IPlayer player,
            ISectorUiState playerState) :
            base(playerState)
        {
            if (playerState is null)
            {
                throw new ArgumentNullException(nameof(playerState));
            }

            Path = new List<IGraphNode>();

            _player = player ?? throw new ArgumentNullException(nameof(player));
        }

        /// <summary>
        /// Текущий путь, по которому будет перемещаться персонаж.
        /// </summary>
        public IList<IGraphNode> Path { get; }

        /// <summary>
        /// Выполнение команды на перемещение и обновление игрового цикла.
        /// </summary>
        protected override void ExecuteTacticCommand()
        {
            var selectedNodeVm = GetSelectedNodeViewModel();
            if (selectedNodeVm == null)
            {
                throw new InvalidOperationException(
                    "Невозможно выполнить команду на перемещение, если не указан целевой узел.");
            }

            CreatePath(selectedNodeVm);

            var targetNode = selectedNodeVm.Node;

            var sector = _player.SectorNode.Sector;
            if (sector is null)
            {
                throw new InvalidOperationException();
            }

            var currentSector = sector;

            var moveIntetion = new MoveIntention(targetNode, currentSector);
            var actor = PlayerState.ActiveActor?.Actor;
            if (actor is null)
            {
                throw new InvalidOperationException();
            }

            var taskSource = PlayerState?.TaskSource;
            if (taskSource is null)
            {
                throw new InvalidOperationException();
            }

            taskSource.Intent(moveIntetion, actor);
        }

        private bool CanExecuteForHover()
        {
            var nodeViewModel = GetHoverNodeViewModel();
            if (nodeViewModel is null)
            {
                return false;
            }

            if (PlayerState.ActiveActor?.Actor is null)
            {
                return false;
            }

            //test

            CreatePath(nodeViewModel);
            return Path.Any();
        }

        private bool CanExecuteForSelected()
        {
            var nodeViewModel = GetSelectedNodeViewModel();
            if (nodeViewModel is null)
            {
                return false;
            }

            if (PlayerState.ActiveActor?.Actor is null)
            {
                return false;
            }

            //test

            CreatePath(nodeViewModel);
            return Path.Any();
        }

        private bool CheckEnemies()
        {
            var actor = PlayerState?.ActiveActor?.Actor;
            if (actor is null)
            {
                throw new InvalidOperationException();
            }

            var sector = _player.SectorNode.Sector;
            if (sector is null)
            {
                throw new InvalidOperationException();
            }

            var enemies = sector.ActorManager.Items
                .Where(x => x != actor && x.Person.Fraction != actor.Person.Fraction).ToArray();

            foreach (var enemyActor in enemies)
            {
                var distance = ((HexNode)actor.Node).CubeCoords.DistanceTo(((HexNode)enemyActor.Node).CubeCoords);

                if (distance > 5)
                {
                    continue;
                }

                var isAvailable = sector.Map.TargetIsOnLine(
                    actor.Node,
                    enemyActor.Node);

                if (isAvailable)
                {
                    return false;
                }
            }

            return true;
        }

        private void CreatePath(IMapNodeViewModel targetNode)
        {
            var actor = PlayerState.ActiveActor?.Actor;
            if (actor is null)
            {
                throw new InvalidOperationException();
            }

            var startNode = actor.Node;
            var finishNode = targetNode.Node;

            var sector = _player.SectorNode.Sector;
            if (sector is null)
            {
                throw new InvalidOperationException();
            }

            var map = sector.Map;

            Path.Clear();

            if (!map.IsPositionAvailableFor(finishNode, actor))
            {
                return;
            }

            var context = new ActorPathFindingContext(actor, map, finishNode);

            var astar = new AStar(context, startNode, finishNode);
            var resultState = astar.Run();
            if (resultState != State.GoalFound)
            {
                return;
            }

            RememberFoundPath(astar);
        }

        private IMapNodeViewModel? GetHoverNodeViewModel()
        {
            return PlayerState.HoverViewModel as IMapNodeViewModel;
        }

        private IMapNodeViewModel? GetSelectedNodeViewModel()
        {
            return PlayerState.SelectedViewModel as IMapNodeViewModel;
        }

        private void RememberFoundPath(AStar astar)
        {
            var foundPath = astar.GetPath().Skip(1).ToArray();
            foreach (var pathNode in foundPath)
            {
                Path.Add(pathNode);
            }
        }

        /// <summary>
        /// Определяем, может ли команда выполниться.
        /// </summary>
        /// <returns> Возвращает true, если перемещение возможно. Иначе, false. </returns>
        public override bool CanExecute()
        {
            var nodeViewModel = GetHoverNodeViewModel();
            if (nodeViewModel is null)
            {
                return false;
            }

            var canExecuteForHover = CanExecuteForHover();
            if (!canExecuteForHover)
            {
                return false;
            }

            CreatePath(nodeViewModel);

            var pathIsNotEmpty = Path.Any();
            return pathIsNotEmpty;
        }

        /// <summary>
        /// Проверяет, может ли команда совершить очередное перемещение по уже найденному пути.
        /// </summary>
        /// <returns> Возвращает true, если команду можно повторить. </returns>
        public bool CanRepeat()
        {
            var canRepeat = CanExecuteForSelected() && CheckEnemies();
            return canRepeat;
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5
6	using Zilon.Core.Client;
7	using Zilon.Core.Graphs;
8	using Zilon.Core.PathFinding;
9	using Zilon.Core.Players;
10	using Zilon.Core.Tactics;
11	using Zilon.Core.Tactics.Behaviour;
12	using Zilon.Core.Tactics.Spatial;
13
14	namespace Zilon.Core.Commands
15	{
16	/// <summary>
17	/// Команда на перемещение взвода в указанный узел карты.
18	/// </summary>
19	public class MoveCommand : ActorCommandBase, IRepeatableCommand
20	{
21	private readonly IPlayer _player;
22
23	/// <summary>
24	/// Конструктор на создание команды перемещения.
25	/// </summary>
26	/// <param name="gameLoop">
27	/// Игровой цикл.
28	/// Нужен для того, чтобы команда выполнила обновление игрового цикла
29	/// после завершения перемещения персонажа.
30	/// </param>
31	/// <param name="sectorManager">
32	/// Менеджер сектора.
33	/// Нужен для получения информации о секторе.
34	/// </param>
35	/// <param name="playerState">
36	/// Состояние игрока.
37	/// Нужен для получения информации о текущем состоянии игрока.
38	/// </param>
39	/// <param name="actorManager">
40	/// Менеджер актёров.
41	/// Нужен для отслеживания противников при автоперемещении.
42	/// </param>
43	[ExcludeFromCodeCoverage]
44	public MoveCommand(
45	IPlayer player,
46	ISectorUiState playerState) :
47	base(playerState)
48	{
49	if (playerState is null)
50	{
51	throw new ArgumentNullException(nameof(playerState));
52	}
53
54	Path = new List<IGraphNode>();
55
56	_player = player ?? throw new ArgumentNullException(nameof(player));
57	}
58
59	/// <summary>
60	/// Текущий путь, по которому будет перемещаться персонаж.
61	/// </summary>
62	public IList<IGraphNode> Path { get; }
63
64	/// <summary>
65	/// Выполнение команды на перемещение и обновление игрового цикла.
66	/// </summary>
67	protected override void ExecuteTacticCommand()
68	{
69	var selectedNodeVm = GetSelectedNodeViewModel();	7✔
70	if (selectedNodeVm == null)	7!
71	{
72	throw new InvalidOperationException(	×
73	"Невозможно выполнить команду на перемещение, если не указан целевой узел.");	×
74	}
75
76	CreatePath(selectedNodeVm);	7✔
77
78	var targetNode = selectedNodeVm.Node;	7✔
79
80	var sector = _player.SectorNode.Sector;	7✔
81	if (sector is null)	7!
82	{
NEW 83	throw new InvalidOperationException();	×
84	}
85
86	var currentSector = sector;	7✔
87
88	var moveIntetion = new MoveIntention(targetNode, currentSector);	7✔
89	var actor = PlayerState.ActiveActor?.Actor;	7!
90	if (actor is null)	7!
91	{
NEW 92	throw new InvalidOperationException();	×
93	}
94
95	var taskSource = PlayerState?.TaskSource;	7!
96	if (taskSource is null)	7!
97	{
NEW 98	throw new InvalidOperationException();	×
99	}
100
101	taskSource.Intent(moveIntetion, actor);	7✔
102	}	7✔
103
104	private bool CanExecuteForHover()
105	{
106	var nodeViewModel = GetHoverNodeViewModel();	12✔
107	if (nodeViewModel is null)	12!
108	{
109	return false;	×
110	}
111
112	if (PlayerState.ActiveActor?.Actor is null)	12!
113	{
114	return false;	×
115	}
116
117	//test
118
119	CreatePath(nodeViewModel);	12✔
120	return Path.Any();	12✔
121	}
122
123	private bool CanExecuteForSelected()
124	{
125	var nodeViewModel = GetSelectedNodeViewModel();	3✔
126	if (nodeViewModel is null)	3!
127	{
128	return false;	×
129	}
130
131	if (PlayerState.ActiveActor?.Actor is null)	3!
132	{
133	return false;	×
134	}
135
136	//test
137
138	CreatePath(nodeViewModel);	3✔
139	return Path.Any();	3✔
140	}
141
142	private bool CheckEnemies()
143	{
144	var actor = PlayerState?.ActiveActor?.Actor;	3!
145	if (actor is null)	3!
146	{
NEW 147	throw new InvalidOperationException();	×
148	}
149
150	var sector = _player.SectorNode.Sector;	3✔
151	if (sector is null)	3!
152	{
NEW 153	throw new InvalidOperationException();	×
154	}
155
156	var enemies = sector.ActorManager.Items	3✔
157	.Where(x => x != actor && x.Person.Fraction != actor.Person.Fraction).ToArray();	3✔
158
159	foreach (var enemyActor in enemies)	9✔
160	{
161	var distance = ((HexNode)actor.Node).CubeCoords.DistanceTo(((HexNode)enemyActor.Node).CubeCoords);	2✔
162
163	if (distance > 5)	2✔
164	{
165	continue;
166	}
167
168	var isAvailable = sector.Map.TargetIsOnLine(	1✔
169	actor.Node,	1✔
170	enemyActor.Node);	1✔
171
172	if (isAvailable)	1✔
173	{
174	return false;	1✔
175	}
176	}
177
178	return true;	2✔
179	}
180
181	private void CreatePath(IMapNodeViewModel targetNode)
182	{
183	var actor = PlayerState.ActiveActor?.Actor;	32!
184	if (actor is null)	32!
185	{
NEW 186	throw new InvalidOperationException();	×
187	}
188
189	var startNode = actor.Node;	32✔
190	var finishNode = targetNode.Node;	32✔
191
192	var sector = _player.SectorNode.Sector;	32✔
193	if (sector is null)	32!
194	{
NEW 195	throw new InvalidOperationException();	×
196	}
197
198	var map = sector.Map;	32✔
199
200	Path.Clear();	32✔
201
202	if (!map.IsPositionAvailableFor(finishNode, actor))	32!
203	{
204	return;	×
205	}
206
207	var context = new ActorPathFindingContext(actor, map, finishNode);	32✔
208
209	var astar = new AStar(context, startNode, finishNode);	32✔
210	var resultState = astar.Run();	32✔
211	if (resultState != State.GoalFound)	32✔
212	{
213	return;	2✔
214	}
215
216	RememberFoundPath(astar);	30✔
217	}	30✔
218
219	private IMapNodeViewModel? GetHoverNodeViewModel()
220	{
221	return PlayerState.HoverViewModel as IMapNodeViewModel;	24✔
222	}
223
224	private IMapNodeViewModel? GetSelectedNodeViewModel()
225	{
226	return PlayerState.SelectedViewModel as IMapNodeViewModel;	10✔
227	}
228
229	private void RememberFoundPath(AStar astar)
230	{
231	var foundPath = astar.GetPath().Skip(1).ToArray();	30✔
232	foreach (var pathNode in foundPath)	182✔
233	{
234	Path.Add(pathNode);	61✔
235	}
236	}	30✔
237
238	/// <summary>
239	/// Определяем, может ли команда выполниться.
240	/// </summary>
241	/// <returns> Возвращает true, если перемещение возможно. Иначе, false. </returns>
242	public override bool CanExecute()
243	{
244	var nodeViewModel = GetHoverNodeViewModel();	12✔
245	if (nodeViewModel is null)	12!
246	{
247	return false;	×
248	}
249
250	var canExecuteForHover = CanExecuteForHover();	12✔
251	if (!canExecuteForHover)	12✔
252	{
253	return false;	2✔
254	}
255
256	CreatePath(nodeViewModel);	10✔
257
258	var pathIsNotEmpty = Path.Any();	10✔
259	return pathIsNotEmpty;	10✔
260	}
261
262	/// <summary>
263	/// Проверяет, может ли команда совершить очередное перемещение по уже найденному пути.
264	/// </summary>
265	/// <returns> Возвращает true, если команду можно повторить. </returns>
266	public bool CanRepeat()
267	{
268	var canRepeat = CanExecuteForSelected() && CheckEnemies();	3!
269	return canRepeat;	×
270	}
271	}
272	}

kreghek / Zilon_Roguelike / 656258625

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