956917937

Build Type

github

Committed by GitHub

Commit Message

Merge d6ece2602 into 1fcec6eb0

Pull Request Pull Request #1196: Feature 1115 huge sectors

Run Details

1956 of 3759 branches covered (52.04%)

Branch coverage included in aggregate %.

71 of 124 new or added lines in 11 files covered. (57.26%)

1 existing line in 1 file now uncovered.

5031 of 7957 relevant lines covered (63.23%)

37039.01 hits per line

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

50.42

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

﻿using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
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;
        }

        /// <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;
        }

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

        /// <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;
        }

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

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

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

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

            var matrix = _segmentDict.First().Value;
            using StreamWriter file = new 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();
            }
        }

        protected HexNode? GetByCoords(int x, int y)
        {
            var segmentKey = new SegmentKey(0, 0);
            var segment = _segmentDict[segmentKey];

            if (x < 0 || y < 0)
            {
                //TODO Handle correctly.
                return null;
            }

            try
            {
                var node = segment[x, y];
                return (HexNode)node;
            }
            catch (IndexOutOfRangeException)
            {
                return null;
            }
        }

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

            var key = new SegmentKey(segmentX, segmentY);
            _segmentDict[key] = 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;
                }
            }
        }

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

            return neighborX;
        }

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

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

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

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

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

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

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

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

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

kreghek / Zilon_Roguelike / 956917937

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