480189843

Build Type

github

Committed by GitHub

Commit Message

Merge af9e97e61 into 022a51f71

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

Run Details

1824 of 3658 branches covered (49.86%)

Branch coverage included in aggregate %.

11 of 43 new or added lines in 4 files covered. (25.58%)

1024 existing lines in 76 files now uncovered.

7035 of 12437 relevant lines covered (56.57%)

458130.95 hits per line

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

65.0

/Zilon.Core/Zilon.Core/Common/HexBinaryFiller.cs

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

namespace Zilon.Core.Common
{
    /// <summary>
    /// Вспомогательный класс для работы с заливкой
    /// в поле шестиугольников.
    /// </summary>
    public static class HexBinaryFiller
    {
        /// <summary>
        /// Выполняет заливку области в поле шестиугольников.
        /// </summary>
        /// <param name="matrix"> Поле шестиугольников. Будут заливаться ячейки со сзначением <b>true</b>. </param>
        /// <param name="point"> Точка, с которой начинается заливка. Должна указывать на ячейку со значением <b>true</b>. </param>
        /// <returns> Возвращает точки, которые были залиты. </returns>
        public static IEnumerable<OffsetCoords> FloodFill(Matrix<bool> matrix, OffsetCoords point)
        {
            return FloodFillInner(matrix, point, nextNeighbour => true);
        }

        /// <summary>
        /// Выполняет заливку области в поле шестиугольников с учётом размера в 7 узлов.
        /// </summary>
        /// <param name="matrix"> Поле шестиугольников. Будут заливаться ячейки со сзначением <b>true</b>. </param>
        /// <param name="point"> Точка, с которой начинается заливка. Должна указывать на ячейку со значением <b>true</b>. </param>
        /// <returns> Возвращает точки, которые были залиты. </returns>
        public static IEnumerable<OffsetCoords> FloodFill7(Matrix<bool> matrix, OffsetCoords point)
        {
            return FloodFillInner(
                matrix,
                point,
                nextCoords => CheckAvailableFor7(nextCoords, matrix));
        }

        /// <param name="availabilityDelegate"> In - coords on next, neightbor nodes to check if it next fron current node. </param>
        /// <returns></returns>
        public static IEnumerable<OffsetCoords> FloodFillInner(Matrix<bool> matrix, OffsetCoords point,
            Func<OffsetCoords, bool> availabilityDelegate)
        {
            if (matrix is null)
            {
                throw new ArgumentNullException(nameof(matrix));
            }

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

            var snapshotCellMap = (bool[,])matrix.Items.Clone();

            var regionPoints = new List<OffsetCoords>();

            var openPoints = new HashSet<OffsetCoords>
            {
                point
            };

            while (openPoints.Count > 0)
            {
                var currentCell = openPoints.First();
                openPoints.Remove(currentCell);

                var isInBound = IsInBounds(currentCell, matrix.Width, matrix.Height);

                if (!isInBound)
                {
                    // Если текущая точка указывает за край карты, то не пытаемся её заливать.
                    // Пропускаем.
                    continue;
                }

                if (!snapshotCellMap[currentCell.X, currentCell.Y])
                {
                    // Заливаем только живые клетки.
                    // Мертвые клетки являются границей, они не попадают в заливку.
                    continue;
                }

                regionPoints.Add(currentCell);
                snapshotCellMap[currentCell.X, currentCell.Y] = false;
                var nextPoints = AddNextOpenNodes(currentCell, availabilityDelegate);
                AddAllInOpenPoints(openPoints, nextPoints);
            }

            return regionPoints;
        }

        private static void AddAllInOpenPoints(HashSet<OffsetCoords> openPoints, IEnumerable<OffsetCoords> nextPoints)
        {
            foreach (var nextPoint in nextPoints)
            {
                // Hashset garantee unique points. Do not check occurrence of an item in a hashset.
                openPoints.Add(nextPoint);
            }
        }

        private static IEnumerable<OffsetCoords> AddNextOpenNodes(
            OffsetCoords currentCell,
            Func<OffsetCoords, bool> availabilityDelegate)
        {
            var cubeCoords = HexHelper.ConvertToCube(currentCell);
            var clockwiseOffsets = HexHelper.GetOffsetClockwise();

            foreach (var offset in clockwiseOffsets)
            {
                var neighbourCubeCoords = cubeCoords + offset;

                var neighbourCoords = HexHelper.ConvertToOffset(neighbourCubeCoords);

                var isAvailable = availabilityDelegate(neighbourCoords);
                if (isAvailable)
                {
                    yield return neighbourCoords;
                }
            }
        }

        private static bool CheckAvailableFor7(OffsetCoords testCoords, Matrix<bool> matrix)
        {
            if (!matrix[testCoords.X, testCoords.Y])
            {
                return false;
            }

            var neighbours = HexHelper.GetNeighbors(testCoords.X, testCoords.Y);
            foreach (var neighbour in neighbours)
            {
                if (neighbour.X >= matrix.Width || neighbour.Y >= matrix.Height)
                {
                    return false;
                }

                if (!matrix.Items[neighbour.X, neighbour.Y])
                {
                    return false;
                }
            }

            return true;
        }

        private static bool IsInBounds(OffsetCoords coords, int width, int height)
        {
            // ReSharper disable once ArgumentsStyleNamedExpression
            // ReSharper disable once ArgumentsStyleLiteral
            // ReSharper disable once ArgumentsStyleOther
            // There used named argument to improve readable of code.
            if (!ValueInRange(value: coords.X, min: 0, max: width - 1))
            {
                return false;
            }

            // ReSharper disable once ArgumentsStyleNamedExpression
            // ReSharper disable once ArgumentsStyleLiteral
            // ReSharper disable once ArgumentsStyleOther
            // There used named argument to improve readable of code.
            if (!ValueInRange(value: coords.Y, min: 0, max: height - 1))
            {
                return false;
            }

            return true;
        }

        private static bool ValueInRange(int value, int min, int max)
        {
            return min <= value && value <= max;
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	namespace Zilon.Core.Common
6	{
7	/// <summary>
8	/// Вспомогательный класс для работы с заливкой
9	/// в поле шестиугольников.
10	/// </summary>
11	public static class HexBinaryFiller
12	{
13	/// <summary>
14	/// Выполняет заливку области в поле шестиугольников.
15	/// </summary>
16	/// <param name="matrix"> Поле шестиугольников. Будут заливаться ячейки со сзначением <b>true</b>. </param>
17	/// <param name="point"> Точка, с которой начинается заливка. Должна указывать на ячейку со значением <b>true</b>. </param>
18	/// <returns> Возвращает точки, которые были залиты. </returns>
19	public static IEnumerable<OffsetCoords> FloodFill(Matrix<bool> matrix, OffsetCoords point)
20	{	786✔
21	return FloodFillInner(matrix, point, nextNeighbour => true);	1,930,116✔
22	}	786✔
23
24	/// <summary>
25	/// Выполняет заливку области в поле шестиугольников с учётом размера в 7 узлов.
26	/// </summary>
27	/// <param name="matrix"> Поле шестиугольников. Будут заливаться ячейки со сзначением <b>true</b>. </param>
28	/// <param name="point"> Точка, с которой начинается заливка. Должна указывать на ячейку со значением <b>true</b>. </param>
29	/// <returns> Возвращает точки, которые были залиты. </returns>
30	public static IEnumerable<OffsetCoords> FloodFill7(Matrix<bool> matrix, OffsetCoords point)
UNCOV 31	{	×
32	return FloodFillInner(	×
33	matrix,	×
34	point,	×
UNCOV 35	nextCoords => CheckAvailableFor7(nextCoords, matrix));	×
UNCOV 36	}	×
37
38	/// <param name="availabilityDelegate"> In - coords on next, neightbor nodes to check if it next fron current node. </param>
39	/// <returns></returns>
40	public static IEnumerable<OffsetCoords> FloodFillInner(Matrix<bool> matrix, OffsetCoords point,
41	Func<OffsetCoords, bool> availabilityDelegate)
42	{	786✔
43	if (matrix is null)	786!
44	{	×
45	throw new ArgumentNullException(nameof(matrix));	×
46	}
47
48	if (availabilityDelegate is null)	786!
49	{	×
50	throw new ArgumentNullException(nameof(availabilityDelegate));	×
51	}
52
53	var snapshotCellMap = (bool[,])matrix.Items.Clone();	786✔
54
55	var regionPoints = new List<OffsetCoords>();	786✔
56
57	var openPoints = new HashSet<OffsetCoords>	×
58	{	×
59	point	×
60	};	×
61
62	while (openPoints.Count > 0)	1,210,064✔
63	{	1,209,278✔
64	var currentCell = openPoints.First();	1,209,278✔
65	openPoints.Remove(currentCell);	1,209,278✔
66
67	var isInBound = IsInBounds(currentCell, matrix.Width, matrix.Height);	1,209,278✔
68
69	if (!isInBound)	1,209,278✔
70	{	7,133✔
71	// Если текущая точка указывает за край карты, то не пытаемся её заливать.
72	// Пропускаем.
73	continue;	7,133✔
74	}
75
76	if (!snapshotCellMap[currentCell.X, currentCell.Y])	1,202,145✔
77	{	880,590✔
78	// Заливаем только живые клетки.
79	// Мертвые клетки являются границей, они не попадают в заливку.
80	continue;	880,590✔
81	}
82
83	regionPoints.Add(currentCell);	321,555✔
84	snapshotCellMap[currentCell.X, currentCell.Y] = false;	321,555✔
85	var nextPoints = AddNextOpenNodes(currentCell, availabilityDelegate);	321,555✔
86	AddAllInOpenPoints(openPoints, nextPoints);	321,555✔
87	}	321,555✔
88
89	return regionPoints;	786✔
90	}	786✔
91
92	private static void AddAllInOpenPoints(HashSet<OffsetCoords> openPoints, IEnumerable<OffsetCoords> nextPoints)
93	{	321,555✔
94	foreach (var nextPoint in nextPoints)	4,823,325✔
95	{	1,929,330✔
96	// Hashset garantee unique points. Do not check occurrence of an item in a hashset.
97	openPoints.Add(nextPoint);	1,929,330✔
98	}	1,929,330✔
99	}	321,555✔
100
101	private static IEnumerable<OffsetCoords> AddNextOpenNodes(
102	OffsetCoords currentCell,
103	Func<OffsetCoords, bool> availabilityDelegate)
104	{	321,555✔
105	var cubeCoords = HexHelper.ConvertToCube(currentCell);	321,555✔
106	var clockwiseOffsets = HexHelper.GetOffsetClockwise();	321,555✔
107
108	foreach (var offset in clockwiseOffsets)	4,823,325✔
109	{	1,929,330✔
110	var neighbourCubeCoords = cubeCoords + offset;	1,929,330✔
111
112	var neighbourCoords = HexHelper.ConvertToOffset(neighbourCubeCoords);	1,929,330✔
113
114	var isAvailable = availabilityDelegate(neighbourCoords);	1,929,330✔
115	if (isAvailable)	1,929,330✔
116	{	1,929,330✔
117	yield return neighbourCoords;	1,929,330✔
118	}	1,929,330✔
119	}	1,929,330✔
120	}	321,555✔
121
122	private static bool CheckAvailableFor7(OffsetCoords testCoords, Matrix<bool> matrix)
UNCOV 123	{	×
UNCOV 124	if (!matrix[testCoords.X, testCoords.Y])	×
125	{	×
126	return false;	×
127	}
128
UNCOV 129	var neighbours = HexHelper.GetNeighbors(testCoords.X, testCoords.Y);	×
UNCOV 130	foreach (var neighbour in neighbours)	×
UNCOV 131	{	×
UNCOV 132	if (neighbour.X >= matrix.Width \|\| neighbour.Y >= matrix.Height)	×
133	{	×
134	return false;	×
135	}
136
UNCOV 137	if (!matrix.Items[neighbour.X, neighbour.Y])	×
UNCOV 138	{	×
UNCOV 139	return false;	×
140	}
UNCOV 141	}	×
142
UNCOV 143	return true;	×
UNCOV 144	}	×
145
146	private static bool IsInBounds(OffsetCoords coords, int width, int height)
147	{	1,209,278✔
148	// ReSharper disable once ArgumentsStyleNamedExpression
149	// ReSharper disable once ArgumentsStyleLiteral
150	// ReSharper disable once ArgumentsStyleOther
151	// There used named argument to improve readable of code.
152	if (!ValueInRange(value: coords.X, min: 0, max: width - 1))	1,209,278✔
153	{	3,975✔
154	return false;	3,975✔
155	}
156
157	// ReSharper disable once ArgumentsStyleNamedExpression
158	// ReSharper disable once ArgumentsStyleLiteral
159	// ReSharper disable once ArgumentsStyleOther
160	// There used named argument to improve readable of code.
161	if (!ValueInRange(value: coords.Y, min: 0, max: height - 1))	1,205,303✔
162	{	3,158✔
163	return false;	3,158✔
164	}
165
166	return true;	1,202,145✔
167	}	1,209,278✔
168
169	private static bool ValueInRange(int value, int min, int max)
170	{	2,414,581✔
171	return min <= value && value <= max;	2,414,581✔
172	}	2,414,581✔
173	}
174	}

kreghek / Zilon_Roguelike / 480189843

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