363045721

Build Type

github

Committed by GitHub

Commit Message

Merge 6230b4a13 into c20d96a84

Pull Request Pull Request #892: Auto refactor by Resharper CLT

Run Details

4345 of 7126 branches covered (60.97%)

Branch coverage included in aggregate %.

940 of 1375 new or added lines in 274 files covered. (68.36%)

302 existing lines in 64 files now uncovered.

6278 of 8518 relevant lines covered (73.7%)

805453.75 hits per line

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

66.12

/Zilon.Core/Zilon.Core/Tactics/Spatial/HexMap.cs

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

using Zilon.Core.Common;
using Zilon.Core.Graphs;

namespace Zilon.Core.Tactics.Spatial
{
    public class HexMap : MapBase
    {
        private readonly IDictionary<SegmentKey, IGraphNode[,]> _segmentDict;
        private readonly int _segmentSize;

        public HexMap(int segmentSize)
        {
            if (segmentSize % 2 != 0)
            {
                throw new ArgumentException("Аргумент должен быть чётным", nameof(segmentSize));
            }

            _segmentSize = segmentSize;

            _segmentDict = new Dictionary<SegmentKey, IGraphNode[,]>();

            CreateSegment(0, 0);
        }

        /// <summary>Список узлов карты.</summary>
        public override IEnumerable<IGraphNode> Nodes
        {
            get
            {
                foreach (var segmentKeyValue in _segmentDict)
                {
                    for (var i = 0; i < _segmentSize; i++)
                    {
                        for (var j = 0; j < _segmentSize; j++)
                        {
                            if (segmentKeyValue.Value[i, j] != null)
                            {
                                yield return segmentKeyValue.Value[i, j];
                            }
                        }
                    }
                }
            }
        }

        /// <summary>Создаёт ребро между двумя узлами графа карты.</summary>
        /// <param name="node1">Узел графа карты.</param>
        /// <param name="node2">Узел графа карты.</param>
        public override void AddEdge(IGraphNode node1, IGraphNode node2)
        {
            // Эта возможность не нужна. Пока не будет сделан метод удаления ребра.
            // Сейчас ребра есть между всеми соседями в сетке шестиугольников.
        }

        /// <summary>Добавляет новый узел графа.</summary>
        /// <param name="node"></param>
        public override void AddNode(IGraphNode node)
        {
            if (node is null)
            {
                throw new ArgumentNullException(nameof(node));
            }

            var hexNode = (HexNode)node;
            var offsetX = hexNode.OffsetCoords.X;
            var offsetY = hexNode.OffsetCoords.Y;

            var nodeMatrix = _segmentDict.First().Value;

            if (nodeMatrix[offsetX, offsetY] != null)
            {
                // Эта проверка нужна, чтобы отлавливать дубликаты координат,
                // которые могут быть созданы фабриками.
                // Дубликаты так же попадают в регионы и могут быть сложными в отладке.
                // Потому что искажают дальнейшую работу с картой.
                //TODO Рассматреть вариант, когда проверка выполняется  стороне регионов.
                throw new InvalidOperationException($"В координатах {offsetX},{offsetY} уже есть узел графа.");
            }

            nodeMatrix[offsetX, offsetY] = hexNode;
        }

        protected HexNode GetByCoords(int x, int y)
        {
            var segmentKey = new SegmentKey(0, 0);
            var segment = _segmentDict[segmentKey];
            try
            {
                var node = segment[x, y];
                return (HexNode)node;
            }
            catch (IndexOutOfRangeException)
            {
                return null;
            }
        }

        /// <summary>Возвращает узлы, напрямую соединённые с указанным узлом.</summary>
        /// <param name="node">Опорный узел, относительно которого выбираются соседние узлы.</param>
        /// <returns>Возвращает набор соседних узлов.</returns>
        public override IEnumerable<IGraphNode> GetNext(IGraphNode node)
        {
            if (node is null)
            {
                throw new ArgumentNullException(nameof(node));
            }

            var hexCurrent = (HexNode)node;
            var offsetCoords = hexCurrent.OffsetCoords;
            var segmentX = offsetCoords.X / _segmentSize;
            if (offsetCoords.X < 0)
            {
                segmentX--;
            }

            var segmentY = offsetCoords.Y / _segmentSize;
            if (offsetCoords.Y < 0)
            {
                segmentY--;
            }

            var localOffsetX = NormalizeNeighborCoord(offsetCoords.X % _segmentSize);
            var localOffsetY = NormalizeNeighborCoord(offsetCoords.Y % _segmentSize);

            var segmentKey = new SegmentKey(segmentX, segmentY);
            var matrix = _segmentDict[segmentKey];

            return GetNextFromMatrix(localOffsetX, localOffsetY, segmentX, segmentY, matrix);
        }

        private IEnumerable<IGraphNode> GetNextFromMatrix(int localOffsetX, int localOffsetY, int segmentX,
            int segmentY, IGraphNode[,] matrix)
        {
            var directions = HexHelper.GetOffsetClockwise();
            var currentCubeCoords = HexHelper.ConvertToCube(localOffsetX, localOffsetY);

            for (var i = 0; i < 6; i++)
            {
                var dir = directions[i];
                var neighborLocalCube = new CubeCoords(dir.X + currentCubeCoords.X,
                    dir.Y + currentCubeCoords.Y,
                    dir.Z + currentCubeCoords.Z);

                var neighborLocalOffset = HexHelper.ConvertToOffset(neighborLocalCube);

                var neighborSegmentX = segmentX;
                var neighborSegmentY = segmentY;

                if (neighborLocalOffset.X < 0)
                {
                    neighborSegmentX--;
                }
                else if (neighborLocalOffset.X >= _segmentSize)
                {
                    neighborSegmentX++;
                }

                if (neighborLocalOffset.Y < 0)
                {
                    neighborSegmentY--;
                }
                else if (neighborLocalOffset.Y >= _segmentSize)
                {
                    neighborSegmentY++;
                }

                IGraphNode currentNeibour;
                if (neighborSegmentX == segmentX &&
                    neighborSegmentY == segmentY)
                {
                    currentNeibour = matrix[neighborLocalOffset.X, neighborLocalOffset.Y];

                    if (currentNeibour == null)
                    {
                        continue;
                    }

                    yield return currentNeibour;
                }
            }
        }

        /// <summary>
        /// Проверяет, является ли данная ячейка доступной для текущего актёра.
        /// </summary>
        /// <param name="targetNode">Целевая ячейка.</param>
        /// <param name="actor">Проверяемый актёр.</param>
        /// <returns>true, если указанный узел проходим для актёра. Иначе - false.</returns>
        public override bool IsPositionAvailableFor(IGraphNode targetNode, IActor actor)
        {
            if (targetNode is null)
            {
                throw new ArgumentNullException(nameof(targetNode));
            }

            if (!base.IsPositionAvailableFor(targetNode, actor))
            {
                return false;
            }

            return true;
        }

        /// <summary>Удаляет ребро между двумя узлами графа карты.</summary>
        /// <param name="node1">Узел графа карты.</param>
        /// <param name="node2">Узел графа карты.</param>
        public override void RemoveEdge(IGraphNode node1, IGraphNode node2)
        {
            // Эта возможность не нужна. Пока не будет сделан метод удаления ребра.
            // Сейчас ребра есть между всеми соседями в сетке шестиугольников.
        }

        public void SaveToFile(string fileName)
        {
            const int cellWidth = 4;

            var matrix = _segmentDict.First().Value;
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(fileName))
            {
                file.Write(" ".PadLeft(cellWidth, ' '));
                for (var x = 0; x < _segmentSize; x++)
                {
                    file.Write($"{x,3}".PadRight(cellWidth, ' '));
                }

                file.WriteLine();

                for (var y = 0; y < _segmentSize; y++)
                {
                    file.Write($"{y,3}".PadLeft(cellWidth, ' '));
                    for (var x = 0; x < _segmentSize; x++)
                    {
                        if (matrix[x, y] != null)
                        {
                            file.Write(" ".PadLeft(cellWidth, ' '));
                        }
                        else
                        {
                            file.Write("x".PadLeft(cellWidth, ' '));
                        }
                    }

                    file.WriteLine();
                }
            }
        }

        private void CreateSegment(int segmentX, int segmentY)
        {
            //TODO Отказаться от многомерного массива. Вместо этого сделать одномерный и адресацию через смещение.
            var matrix = new IGraphNode[_segmentSize, _segmentSize];

            var key = new SegmentKey(segmentX, segmentY);
            _segmentDict[key] = matrix;
        }

        private int NormalizeNeighborCoord(int neighborX)
        {
            if (neighborX < 0)
            {
                neighborX += _segmentSize;
            }
            else if (neighborX >= _segmentSize)
            {
                neighborX -= _segmentSize;
            }

            return neighborX;
        }

        public override bool IsPositionAvailableForContainer(IGraphNode targetNode)
        {
            return true;
        }

        /// <summary>
        /// Distances the between.
        /// </summary>
        /// <param name="currentNode">The current node.</param>
        /// <param name="targetNode">The target node.</param>
        /// <returns></returns>
        public override int DistanceBetween(IGraphNode currentNode, IGraphNode targetNode)
        {
            if (currentNode is null)
            {
                throw new ArgumentNullException(nameof(currentNode));
            }

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

            var actorHexNode = (HexNode)currentNode;
            var containerHexNode = (HexNode)targetNode;

            var actorCoords = actorHexNode.CubeCoords;
            var containerCoords = containerHexNode.CubeCoords;

            var distance = actorCoords.DistanceTo(containerCoords);

            return distance;
        }

        public override void RemoveNode(IGraphNode node)
        {
            throw new NotImplementedException();
        }

        private struct SegmentKey : IEquatable<SegmentKey>
        {
            // ReSharper disable once MemberCanBePrivate.Local
            public readonly int X;

            // ReSharper disable once MemberCanBePrivate.Local
            public readonly int Y;

            public SegmentKey(int x, int y)
            {
                X = x;
                Y = y;
            }

            public override bool Equals(object obj)
            {
                return obj is SegmentKey key && Equals(key);
            }

            public bool Equals(SegmentKey other)
            {
                return X == other.X &&
                       Y == other.Y;
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    var hashCode = 1861411795;
                    hashCode = hashCode * -1521134295 + X.GetHashCode();
                    hashCode = hashCode * -1521134295 + Y.GetHashCode();
                    return hashCode;
                }
            }

            public static bool operator ==(SegmentKey left, SegmentKey right)
            {
                return left.Equals(right);
            }

            public static bool operator !=(SegmentKey left, SegmentKey right)
            {
                return !(left == right);
            }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.Common;
6	using Zilon.Core.Graphs;
7
8	namespace Zilon.Core.Tactics.Spatial
9	{
10	public class HexMap : MapBase
11	{
12	private readonly IDictionary<SegmentKey, IGraphNode[,]> _segmentDict;
13	private readonly int _segmentSize;
14
15	public HexMap(int segmentSize)	71✔
16	{	35✔
17	if (segmentSize % 2 != 0)	71!
18	{
19	throw new ArgumentException("Аргумент должен быть чётным", nameof(segmentSize));	×
20	}
21
22	_segmentSize = segmentSize;	71✔
23
24	_segmentDict = new Dictionary<SegmentKey, IGraphNode[,]>();	71✔
25
26	CreateSegment(0, 0);	71✔
27	}	71✔
28
29	/// <summary>Список узлов карты.</summary>
30	public override IEnumerable<IGraphNode> Nodes
31	{
32	get
33	{	13,894✔
34	foreach (var segmentKeyValue in _segmentDict)	123,177✔
35	{	13,894✔
36	for (var i = 0; i < _segmentSize; i++)	10,573,240✔
37	{	2,636,124✔
38	for (var j = 0; j < _segmentSize; j++)	2,178,079,456✔
39	{	543,061,072✔
40	if (segmentKeyValue.Value[i, j] != null)	1,083,780,848✔
41	{	51,364,284✔
42	yield return segmentKeyValue.Value[i, j];	102,733,584✔
43	}	51,363,454✔
44	}	543,060,242✔
45	}	2,635,294✔
46	}	26,063✔
47	}	26,063✔
48	}
49
50	/// <summary>Создаёт ребро между двумя узлами графа карты.</summary>
51	/// <param name="node1">Узел графа карты.</param>
52	/// <param name="node2">Узел графа карты.</param>
53	public override void AddEdge(IGraphNode node1, IGraphNode node2)
54	{	104,726✔
55	// Эта возможность не нужна. Пока не будет сделан метод удаления ребра.
56	// Сейчас ребра есть между всеми соседями в сетке шестиугольников.
57	}	209,452✔
58
59	/// <summary>Добавляет новый узел графа.</summary>
60	/// <param name="node"></param>
61	public override void AddNode(IGraphNode node)
62	{	4,067,635✔
63	if (node is null)	8,135,893!
64	{
65	throw new ArgumentNullException(nameof(node));	×
66	}
67
68	var hexNode = (HexNode)node;	8,135,893✔
69	var offsetX = hexNode.OffsetCoords.X;	8,135,893✔
70	var offsetY = hexNode.OffsetCoords.Y;	8,135,893✔
71
72	var nodeMatrix = _segmentDict.First().Value;	8,135,893✔
73
74	if (nodeMatrix[offsetX, offsetY] != null)	8,135,893!
75	{
76	// Эта проверка нужна, чтобы отлавливать дубликаты координат,
77	// которые могут быть созданы фабриками.
78	// Дубликаты так же попадают в регионы и могут быть сложными в отладке.
79	// Потому что искажают дальнейшую работу с картой.
80	//TODO Рассматреть вариант, когда проверка выполняется стороне регионов.
81	throw new InvalidOperationException($"В координатах {offsetX},{offsetY} уже есть узел графа.");	×
82	}
83
84	nodeMatrix[offsetX, offsetY] = hexNode;	8,135,893✔
85	}	8,135,893✔
86
87	protected HexNode GetByCoords(int x, int y)
88	{	345,206✔
89	var segmentKey = new SegmentKey(0, 0);	703,056✔
90	var segment = _segmentDict[segmentKey];	703,056✔
91	try
92	{	345,206✔
93	var node = segment[x, y];	703,056✔
94	return (HexNode)node;	703,056✔
95	}
96	catch (IndexOutOfRangeException)	×
97	{
98	return null;	×
99	}
100	}	703,056✔
101
102	/// <summary>Возвращает узлы, напрямую соединённые с указанным узлом.</summary>
103	/// <param name="node">Опорный узел, относительно которого выбираются соседние узлы.</param>
104	/// <returns>Возвращает набор соседних узлов.</returns>
105	public override IEnumerable<IGraphNode> GetNext(IGraphNode node)
106	{	226,800✔
107	if (node is null)	464,126!
108	{
109	throw new ArgumentNullException(nameof(node));	×
110	}
111
112	var hexCurrent = (HexNode)node;	464,126✔
113	var offsetCoords = hexCurrent.OffsetCoords;	464,126✔
114	var segmentX = offsetCoords.X / _segmentSize;	464,126✔
115	if (offsetCoords.X < 0)	464,126!
116	{
117	segmentX--;	×
118	}
119
120	var segmentY = offsetCoords.Y / _segmentSize;	464,126✔
121	if (offsetCoords.Y < 0)	464,126!
122	{
123	segmentY--;	×
124	}
125
126	var localOffsetX = NormalizeNeighborCoord(offsetCoords.X % _segmentSize);	464,126✔
127	var localOffsetY = NormalizeNeighborCoord(offsetCoords.Y % _segmentSize);	464,126✔
128
129	var segmentKey = new SegmentKey(segmentX, segmentY);	464,126✔
130	var matrix = _segmentDict[segmentKey];	464,126✔
131
132	return GetNextFromMatrix(localOffsetX, localOffsetY, segmentX, segmentY, matrix);	464,126✔
133	}	226,800✔
134
135	private IEnumerable<IGraphNode> GetNextFromMatrix(int localOffsetX, int localOffsetY, int segmentX,
136	int segmentY, IGraphNode[,] matrix)
137	{	226,800✔
138	var directions = HexHelper.GetOffsetClockwise();	464,126✔
139	var currentCubeCoords = HexHelper.ConvertToCube(localOffsetX, localOffsetY);	464,126✔
140
141	for (var i = 0; i < 6; i++)	4,054,214✔
142	{	929,279✔
143	var dir = directions[i];	1,908,654✔
144	var neighborLocalCube = new CubeCoords(dir.X + currentCubeCoords.X,	1,908,654✔
145	dir.Y + currentCubeCoords.Y,	1,908,654✔
146	dir.Z + currentCubeCoords.Z);	1,908,654✔
147
148	var neighborLocalOffset = HexHelper.ConvertToOffset(neighborLocalCube);	1,908,654✔
149
150	var neighborSegmentX = segmentX;	1,908,654✔
151	var neighborSegmentY = segmentY;	1,908,654✔
152
153	if (neighborLocalOffset.X < 0)	1,908,654✔
154	{	8✔
155	neighborSegmentX--;	16✔
156	}	8✔
157	else if (neighborLocalOffset.X >= _segmentSize)	1,908,638!
158	{
UNCOV 159	neighborSegmentX++;	×
160	}
161
162	if (neighborLocalOffset.Y < 0)	1,908,654✔
163	{	2✔
164	neighborSegmentY--;	4✔
165	}	2✔
166	else if (neighborLocalOffset.Y >= _segmentSize)	1,908,650!
167	{
UNCOV 168	neighborSegmentY++;	×
169	}
170
171	IGraphNode currentNeibour;
172	if (neighborSegmentX == segmentX &&	1,908,654✔
173	neighborSegmentY == segmentY)	1,908,654✔
174	{	929,270✔
175	currentNeibour = matrix[neighborLocalOffset.X, neighborLocalOffset.Y];	1,908,636✔
176
177	if (currentNeibour == null)	1,908,636✔
178	{	50,571✔
179	continue;	50,571✔
180	}
181
182	yield return currentNeibour;	1,798,814✔
183	}	708,587✔
184	}	708,596✔
185	}	118,453✔
186
187	/// <summary>
188	/// Проверяет, является ли данная ячейка доступной для текущего актёра.
189	/// </summary>
190	/// <param name="targetNode">Целевая ячейка.</param>
191	/// <param name="actor">Проверяемый актёр.</param>
192	/// <returns>true, если указанный узел проходим для актёра. Иначе - false.</returns>
193	public override bool IsPositionAvailableFor(IGraphNode targetNode, IActor actor)
194	{	31,428✔
195	if (targetNode is null)	64,420!
196	{
UNCOV 197	throw new ArgumentNullException(nameof(targetNode));	×
198	}
199
200	if (!base.IsPositionAvailableFor(targetNode, actor))	64,420✔
201	{	5,159✔
202	return false;	10,289✔
203	}
204
205	return true;	54,131✔
206	}	31,428✔
207
208	/// <summary>Удаляет ребро между двумя узлами графа карты.</summary>
209	/// <param name="node1">Узел графа карты.</param>
210	/// <param name="node2">Узел графа карты.</param>
211	public override void RemoveEdge(IGraphNode node1, IGraphNode node2)
212	{
213	// Эта возможность не нужна. Пока не будет сделан метод удаления ребра.
214	// Сейчас ребра есть между всеми соседями в сетке шестиугольников.
UNCOV 215	}	×
216
217	public void SaveToFile(string fileName)
218	{
219	const int cellWidth = 4;
220
UNCOV 221	var matrix = _segmentDict.First().Value;	×
222	using (System.IO.StreamWriter file = new System.IO.StreamWriter(fileName))	×
223	{
UNCOV 224	file.Write(" ".PadLeft(cellWidth, ' '));	×
225	for (var x = 0; x < _segmentSize; x++)	×
226	{
227	file.Write($"{x,3}".PadRight(cellWidth, ' '));	×
228	}
229
230	file.WriteLine();	×
231
232	for (var y = 0; y < _segmentSize; y++)	×
233	{
UNCOV 234	file.Write($"{y,3}".PadLeft(cellWidth, ' '));	×
UNCOV 235	for (var x = 0; x < _segmentSize; x++)	×
236	{
237	if (matrix[x, y] != null)	×
238	{
239	file.Write(" ".PadLeft(cellWidth, ' '));	×
240	}
241	else
242	{
243	file.Write("x".PadLeft(cellWidth, ' '));	×
244	}
245	}
246
247	file.WriteLine();	×
248	}
249	}	×
UNCOV 250	}	×
251
252	private void CreateSegment(int segmentX, int segmentY)
253	{	35✔
254	//TODO Отказаться от многомерного массива. Вместо этого сделать одномерный и адресацию через смещение.
255	var matrix = new IGraphNode[_segmentSize, _segmentSize];	71✔
256
257	var key = new SegmentKey(segmentX, segmentY);	71✔
258	_segmentDict[key] = matrix;	71✔
259	}	71✔
260
261	private int NormalizeNeighborCoord(int neighborX)
262	{	453,600✔
263	if (neighborX < 0)	928,252!
264	{
UNCOV 265	neighborX += _segmentSize;	×
266	}
267	else if (neighborX >= _segmentSize)	928,252!
268	{
269	neighborX -= _segmentSize;	×
270	}
271
272	return neighborX;	928,252✔
273	}	453,600✔
274
275	public override bool IsPositionAvailableForContainer(IGraphNode targetNode)
276	{	3,026✔
277	return true;	6,664✔
278	}	3,026✔
279
280	/// <summary>
281	/// Distances the between.
282	/// </summary>
283	/// <param name="currentNode">The current node.</param>
284	/// <param name="targetNode">The target node.</param>
285	/// <returns></returns>
286	public override int DistanceBetween(IGraphNode currentNode, IGraphNode targetNode)
287	{	4,171,980✔
288	if (currentNode is null)	8,335,294!
289	{
UNCOV 290	throw new ArgumentNullException(nameof(currentNode));	×
291	}
292
293	if (targetNode is null)	8,335,294!
294	{
UNCOV 295	throw new ArgumentNullException(nameof(targetNode));	×
296	}
297
298	var actorHexNode = (HexNode)currentNode;	8,335,294✔
299	var containerHexNode = (HexNode)targetNode;	8,335,294✔
300
301	var actorCoords = actorHexNode.CubeCoords;	8,335,294✔
302	var containerCoords = containerHexNode.CubeCoords;	8,335,294✔
303
304	var distance = actorCoords.DistanceTo(containerCoords);	8,335,294✔
305
306	return distance;	8,335,294✔
307	}	4,171,980✔
308
309	public override void RemoveNode(IGraphNode node)
310	{
UNCOV 311	throw new NotImplementedException();	×
312	}
313
314	private struct SegmentKey : IEquatable<SegmentKey>
315	{
316	// ReSharper disable once MemberCanBePrivate.Local
317	public readonly int X;
318
319	// ReSharper disable once MemberCanBePrivate.Local
320	public readonly int Y;
321
322	public SegmentKey(int x, int y)
323	{	572,041✔
324	X = x;	1,167,253✔
325	Y = y;	1,167,253✔
326	}	1,167,253✔
327
328	public override bool Equals(object obj)
329	{
UNCOV 330	return obj is SegmentKey key && Equals(key);	×
331	}
332
333	public bool Equals(SegmentKey other)
334	{	572,006✔
335	return X == other.X &&	1,167,182!
336	Y == other.Y;	1,167,182✔
337	}	572,006✔
338
339	public override int GetHashCode()
340	{	572,041✔
341	unchecked
342	{	572,041✔
343	var hashCode = 1861411795;	1,167,253✔
344	hashCode = hashCode * -1521134295 + X.GetHashCode();	1,167,253✔
345	hashCode = hashCode * -1521134295 + Y.GetHashCode();	1,167,253✔
346	return hashCode;	1,167,253✔
347	}
348	}	572,041✔
349
350	public static bool operator ==(SegmentKey left, SegmentKey right)
351	{
UNCOV 352	return left.Equals(right);	×
353	}
354
355	public static bool operator !=(SegmentKey left, SegmentKey right)
356	{
357	return !(left == right);	×
358	}
359	}
360	}
361	}

kreghek / Zilon_Roguelike / 363045721

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