477922989

Build Type

github

Committed by GitHub

Commit Message

Merge 4b1e25423 into 0faa57fb2

Pull Request Pull Request #1001: Fix path visualizer

Run Details

2261 of 3734 branches covered (60.55%)

Branch coverage included in aggregate %.

12 of 16 new or added lines in 1 file covered. (75.0%)

136 existing lines in 23 files now uncovered.

8459 of 12825 relevant lines covered (65.96%)

310609.11 hits per line

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

63.58

/Zilon.Core/Zilon.Core/MapGenerators/RoomStyle/RoomGeneratorRandomSource.cs

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

using JetBrains.Annotations;

using Zilon.Core.CommonServices.Dices;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.MapGenerators.RoomStyle
{
    /// <summary>
    /// Реализация источника рандома для генератора комнат сектора.
    /// </summary>
    /// <seealso cref="Zilon.Core.MapGenerators.RoomStyle.IRoomGeneratorRandomSource" />
    public class RoomGeneratorRandomSource : IRoomGeneratorRandomSource
    {
        private readonly IDice _dice;
        private readonly IDice _roomSizeDice;

        public RoomGeneratorRandomSource(IDice dice, IDice roomSizeDice)
        {
            _dice = dice;
            _roomSizeDice = roomSizeDice;
        }

        /// <summary>
        /// Выбирает комнаты, с которыми есть соединение.
        /// </summary>
        /// <param name="currentRoom">Текущая комната, для которой ищуются соединённые соседи.</param>
        /// <param name="maxNeighbors">Максимальное количество соединённых соседей.</param>
        /// <param name="availableRooms">Набор доступных для соединения соседенй.</param>
        /// <returns>
        /// Возвращает целевые комнаты для соединения.
        /// </returns>
        [NotNull]
        [ItemNotNull]
        public Room[] RollConnectedRooms(Room currentRoom, int maxNeighbors, IList<Room> availableRooms)
        {
            var openRooms = new List<Room>(availableRooms);
            var selectedRooms = new HashSet<Room>();
            var neighborCount = _dice.Roll(1, maxNeighbors);
            for (var i = 0; i < neighborCount; i++)
            {
                var rolledRoomIndex = _dice.Roll(0, openRooms.Count - 1);
                var selectedRoom = openRooms[rolledRoomIndex];
                selectedRooms.Add(selectedRoom);
                openRooms.Remove(selectedRoom);

                if (!openRooms.Any())
                {
                    break;
                }
            }

            return selectedRooms.ToArray();
        }

        /// <summary>Выбрасывает случаный набор элементов интерьера комнаты.</summary>
        /// <param name="roomWidth">Ширина комнаты.</param>
        /// <param name="roomHeight">Высота комнаты.</param>
        /// <returns>Возвращает набор элементов интерьера комнаты.</returns>
        public RoomInteriorObjectMeta[] RollInteriorObjects(int roomWidth, int roomHeight)
        {
            if (roomWidth <= 2 || roomHeight <= 2)
            {
                return System.Array.Empty<RoomInteriorObjectMeta>();
            }

            const int PASS_PADDING = 1;

            var minHorizontalBorder = 0;
            var maxHorizontalBorder = roomWidth - 1;
            var minVerticalBorder = 0;
            var maxVerticalBorder = roomHeight - 1;

            var leftBorder = minHorizontalBorder + PASS_PADDING;
            var topBorder = minVerticalBorder + PASS_PADDING;

            var rightBorder = maxHorizontalBorder - PASS_PADDING;
            var bottomBorder = maxVerticalBorder - PASS_PADDING;

            var list = new List<RoomInteriorObjectMeta>();
            var maxCount = (roomWidth * roomHeight) / 9;
            var count = _dice.Roll(0, maxCount);
            for (var i = 0; i < count; i++)
            {
                var x = _dice.Roll(leftBorder, rightBorder);
                var y = _dice.Roll(topBorder, bottomBorder);

                var same = list.SingleOrDefault(o => o.Coords.CompsEqual(x, y));
                if (same != null)
                {
                    continue;
                }

                var interiorObjectCoords = new OffsetCoords(x, y);
                var interiorObject = new RoomInteriorObjectMeta(interiorObjectCoords);

                list.Add(interiorObject);
            }

            return list.ToArray();
        }

        /// <summary>
        /// Выбрасывает случайный набор уникальных координат в матрице комнат указаной длины.
        /// </summary>
        /// <param name="roomGridSize">Размер матрицы комнат.</param>
        /// <param name="roomCount">Количество комнат в секторе.</param>
        /// <returns>
        /// Возвращает массив координат из матрицы комнат.
        /// </returns>
        public IEnumerable<OffsetCoords> RollRoomMatrixPositions(int roomGridSize, int roomCount)
        {
            var roomMatrixPosList = new List<OffsetCoords>(roomGridSize * roomGridSize);
            for (var x = 0; x < roomGridSize; x++)
            {
                for (var y = 0; y < roomGridSize; y++)
                {
                    roomMatrixPosList.Add(new OffsetCoords(x, y));
                }
            }

            var rolledCoords = new List<OffsetCoords>(roomCount);
            for (var i = 0; i < roomCount; i++)
            {
                var rolledIndex = _dice.Roll(0, roomMatrixPosList.Count - 1);
                var currentRolledCoords = roomMatrixPosList[rolledIndex];
                rolledCoords.Add(currentRolledCoords);
                roomMatrixPosList.RemoveAt(rolledIndex);
            }

            return rolledCoords;
        }

        /// <summary>
        /// Возвращает матрицу смежности между комнатами (сеть комнат).
        /// </summary>
        /// <param name="rooms">Всё комнаты, которые должны быть соединены в сеть.</param>
        /// <param name="maxNeighbors">Максимальное количество соседей у комнаты.</param>
        /// <returns>
        /// Возвращает словарь, представляющий собой матрицу смежности комнат.
        /// Минимальное число соседей - 1. Максимальное - не превышает указанное в аргументе значение.
        /// </returns>
        public IDictionary<Room, Room[]> RollRoomNet(IEnumerable<Room> rooms, int maxNeighbors)
        {
            var result = new Dictionary<Room, Room[]>();

            var roomsInGraph = new Dictionary<Room, int>();
            var roomsNotInGraph = new List<Room>(rooms);
            while (roomsNotInGraph.Any())
            {
                var room = roomsNotInGraph.First();
                roomsInGraph.Add(room, 0);
                roomsNotInGraph.Remove(room);
                // для каждой комнаты выбираем произвольную другую комнату
                // и проводим к ней коридор

                var availableRooms = roomsInGraph
                    .Where(x => x.Key != room && x.Value < maxNeighbors)
                    .Select(x => x.Key)
                    .ToArray();

                if (!availableRooms.Any())
                {
                    continue;
                }

                var selectedRooms = RollConnectedRooms(room,
                    maxNeighbors,
                    availableRooms);

                if (!selectedRooms.Any())
                {
                    //Значит текущая комната тупиковая
                    continue;
                }

                result.Add(room, selectedRooms);
                foreach (var selectedRoom in selectedRooms)
                {
                    roomsInGraph[selectedRoom]++;
                }
            }

            return result;
        }

        /// <summary>
        /// Выбрасывает случайный размер комнаты.
        /// </summary>
        /// <param name="minSize">Минимальный размер комнаты.</param>
        /// <param name="maxSize">Максимальный размер комнаты.</param>
        /// <returns>
        /// Возвращает размер с произвольными шириной и высотой в диапазоне (minSize, maxSize).
        /// </returns>
        /// <remarks>
        /// Источник рандома возвращает случайный размер комнаты в указанном диапазоне.
        /// </remarks>
        public Size[] RollRoomSize(int minSize, int maxSize, int count)
        {
            var sizeList = new Size[count];

            for (var i = 0; i < count; i++)
            {
                var diffSize = maxSize - minSize;

                var rollDiffWidth = _roomSizeDice.Roll(diffSize);
                var rollDiffHeight = _roomSizeDice.Roll(diffSize);

                var rollWidth = (int)rollDiffWidth + minSize;
                var rollHeight = (int)rollDiffHeight + minSize;

                var size = new Size(rollWidth, rollHeight);

                sizeList[i] = size;
            }

            return sizeList;
        }

        public HexNode RollTransitionNode(IEnumerable<HexNode> openRoomNodes)
        {
            var index = _dice.Roll(0, openRoomNodes.Count() - 1);
            return openRoomNodes.ElementAt(index);
        }

        public IEnumerable<SectorTransition> RollTransitions(IEnumerable<SectorTransition> openTransitions)
        {
            var index = _dice.Roll(0, openTransitions.Count() - 1);
            return new[] { openTransitions.ElementAt(index) };
        }
    }
}

1	using System.Collections.Generic;
2	using System.Linq;
3
4	using JetBrains.Annotations;
5
6	using Zilon.Core.CommonServices.Dices;
7	using Zilon.Core.Tactics.Spatial;
8
9	namespace Zilon.Core.MapGenerators.RoomStyle
10	{
11	/// <summary>
12	/// Реализация источника рандома для генератора комнат сектора.
13	/// </summary>
14	/// <seealso cref="Zilon.Core.MapGenerators.RoomStyle.IRoomGeneratorRandomSource" />
15	public class RoomGeneratorRandomSource : IRoomGeneratorRandomSource
16	{
17	private readonly IDice _dice;
18	private readonly IDice _roomSizeDice;
19
20	public RoomGeneratorRandomSource(IDice dice, IDice roomSizeDice)	14✔
21	{	14✔
22	_dice = dice;	14✔
23	_roomSizeDice = roomSizeDice;	14✔
24	}	14✔
25
26	/// <summary>
27	/// Выбирает комнаты, с которыми есть соединение.
28	/// </summary>
29	/// <param name="currentRoom">Текущая комната, для которой ищуются соединённые соседи.</param>
30	/// <param name="maxNeighbors">Максимальное количество соединённых соседей.</param>
31	/// <param name="availableRooms">Набор доступных для соединения соседенй.</param>
32	/// <returns>
33	/// Возвращает целевые комнаты для соединения.
34	/// </returns>
35	[NotNull]
36	[ItemNotNull]
37	public Room[] RollConnectedRooms(Room currentRoom, int maxNeighbors, IList<Room> availableRooms)
38	{	190✔
39	var openRooms = new List<Room>(availableRooms);	190✔
40	var selectedRooms = new HashSet<Room>();	190✔
41	var neighborCount = _dice.Roll(1, maxNeighbors);	190✔
42	for (var i = 0; i < neighborCount; i++)	380✔
43	{	190✔
44	var rolledRoomIndex = _dice.Roll(0, openRooms.Count - 1);	190✔
45	var selectedRoom = openRooms[rolledRoomIndex];	190✔
46	selectedRooms.Add(selectedRoom);	190✔
47	openRooms.Remove(selectedRoom);	190✔
48
49	if (!openRooms.Any())	190!
50	{	190✔
51	break;	190✔
52	}
53	}	×
54
55	return selectedRooms.ToArray();	190✔
56	}	190✔
57
58	/// <summary>Выбрасывает случаный набор элементов интерьера комнаты.</summary>
59	/// <param name="roomWidth">Ширина комнаты.</param>
60	/// <param name="roomHeight">Высота комнаты.</param>
61	/// <returns>Возвращает набор элементов интерьера комнаты.</returns>
62	public RoomInteriorObjectMeta[] RollInteriorObjects(int roomWidth, int roomHeight)
63	{	×
64	if (roomWidth <= 2 \|\| roomHeight <= 2)	×
65	{	×
66	return System.Array.Empty<RoomInteriorObjectMeta>();	×
67	}
68
69	const int PASS_PADDING = 1;
70
71	var minHorizontalBorder = 0;	×
72	var maxHorizontalBorder = roomWidth - 1;	×
73	var minVerticalBorder = 0;	×
74	var maxVerticalBorder = roomHeight - 1;	×
75
76	var leftBorder = minHorizontalBorder + PASS_PADDING;	×
77	var topBorder = minVerticalBorder + PASS_PADDING;	×
78
79	var rightBorder = maxHorizontalBorder - PASS_PADDING;	×
80	var bottomBorder = maxVerticalBorder - PASS_PADDING;	×
81
82	var list = new List<RoomInteriorObjectMeta>();	×
83	var maxCount = (roomWidth * roomHeight) / 9;	×
84	var count = _dice.Roll(0, maxCount);	×
85	for (var i = 0; i < count; i++)	×
86	{	×
87	var x = _dice.Roll(leftBorder, rightBorder);	×
88	var y = _dice.Roll(topBorder, bottomBorder);	×
89
90	var same = list.SingleOrDefault(o => o.Coords.CompsEqual(x, y));	×
91	if (same != null)	×
92	{	×
93	continue;	×
94	}
95
96	var interiorObjectCoords = new OffsetCoords(x, y);	×
97	var interiorObject = new RoomInteriorObjectMeta(interiorObjectCoords);	×
98
99	list.Add(interiorObject);	×
100	}	×
101
102	return list.ToArray();	×
103	}	×
104
105	/// <summary>
106	/// Выбрасывает случайный набор уникальных координат в матрице комнат указаной длины.
107	/// </summary>
108	/// <param name="roomGridSize">Размер матрицы комнат.</param>
109	/// <param name="roomCount">Количество комнат в секторе.</param>
110	/// <returns>
111	/// Возвращает массив координат из матрицы комнат.
112	/// </returns>
113	public IEnumerable<OffsetCoords> RollRoomMatrixPositions(int roomGridSize, int roomCount)
114	{	10✔
115	var roomMatrixPosList = new List<OffsetCoords>(roomGridSize * roomGridSize);	10✔
116	for (var x = 0; x < roomGridSize; x++)	140✔
117	{	60✔
118	for (var y = 0; y < roomGridSize; y++)	840✔
119	{	360✔
120	roomMatrixPosList.Add(new OffsetCoords(x, y));	360✔
121	}	360✔
122	}	60✔
123
124	var rolledCoords = new List<OffsetCoords>(roomCount);	10✔
125	for (var i = 0; i < roomCount; i++)	420✔
126	{	200✔
127	var rolledIndex = _dice.Roll(0, roomMatrixPosList.Count - 1);	200✔
128	var currentRolledCoords = roomMatrixPosList[rolledIndex];	200✔
129	rolledCoords.Add(currentRolledCoords);	200✔
130	roomMatrixPosList.RemoveAt(rolledIndex);	200✔
131	}	200✔
132
133	return rolledCoords;	10✔
134	}	10✔
135
136	/// <summary>
137	/// Возвращает матрицу смежности между комнатами (сеть комнат).
138	/// </summary>
139	/// <param name="rooms">Всё комнаты, которые должны быть соединены в сеть.</param>
140	/// <param name="maxNeighbors">Максимальное количество соседей у комнаты.</param>
141	/// <returns>
142	/// Возвращает словарь, представляющий собой матрицу смежности комнат.
143	/// Минимальное число соседей - 1. Максимальное - не превышает указанное в аргументе значение.
144	/// </returns>
145	public IDictionary<Room, Room[]> RollRoomNet(IEnumerable<Room> rooms, int maxNeighbors)
146	{	10✔
147	var result = new Dictionary<Room, Room[]>();	10✔
148
149	var roomsInGraph = new Dictionary<Room, int>();	10✔
150	var roomsNotInGraph = new List<Room>(rooms);	10✔
151	while (roomsNotInGraph.Any())	210✔
152	{	200✔
153	var room = roomsNotInGraph.First();	200✔
154	roomsInGraph.Add(room, 0);	200✔
155	roomsNotInGraph.Remove(room);	200✔
156	// для каждой комнаты выбираем произвольную другую комнату
157	// и проводим к ней коридор
158
159	var availableRooms = roomsInGraph	×
160	.Where(x => x.Key != room && x.Value < maxNeighbors)	2,100✔
161	.Select(x => x.Key)	190✔
162	.ToArray();	×
163
164	if (!availableRooms.Any())	200✔
165	{	10✔
166	continue;	10✔
167	}
168
169	var selectedRooms = RollConnectedRooms(room,	×
170	maxNeighbors,	×
171	availableRooms);	×
172
173	if (!selectedRooms.Any())	190!
174	{	×
175	//Значит текущая комната тупиковая
176	continue;	×
177	}
178
179	result.Add(room, selectedRooms);	190✔
180	foreach (var selectedRoom in selectedRooms)	950✔
181	{	190✔
182	roomsInGraph[selectedRoom]++;	190✔
183	}	190✔
184	}	190✔
185
186	return result;	10✔
187	}	10✔
188
189	/// <summary>
190	/// Выбрасывает случайный размер комнаты.
191	/// </summary>
192	/// <param name="minSize">Минимальный размер комнаты.</param>
193	/// <param name="maxSize">Максимальный размер комнаты.</param>
194	/// <returns>
195	/// Возвращает размер с произвольными шириной и высотой в диапазоне (minSize, maxSize).
196	/// </returns>
197	/// <remarks>
198	/// Источник рандома возвращает случайный размер комнаты в указанном диапазоне.
199	/// </remarks>
200	public Size[] RollRoomSize(int minSize, int maxSize, int count)
201	{	10✔
202	var sizeList = new Size[count];	10✔
203
204	for (var i = 0; i < count; i++)	420✔
205	{	200✔
206	var diffSize = maxSize - minSize;	200✔
207
208	var rollDiffWidth = _roomSizeDice.Roll(diffSize);	200✔
209	var rollDiffHeight = _roomSizeDice.Roll(diffSize);	200✔
210
211	var rollWidth = (int)rollDiffWidth + minSize;	200✔
212	var rollHeight = (int)rollDiffHeight + minSize;	200✔
213
214	var size = new Size(rollWidth, rollHeight);	200✔
215
216	sizeList[i] = size;	200✔
217	}	200✔
218
219	return sizeList;	10✔
220	}	10✔
221
222	public HexNode RollTransitionNode(IEnumerable<HexNode> openRoomNodes)
UNCOV 223	{	×
UNCOV 224	var index = _dice.Roll(0, openRoomNodes.Count() - 1);	×
UNCOV 225	return openRoomNodes.ElementAt(index);	×
UNCOV 226	}	×
227
228	public IEnumerable<SectorTransition> RollTransitions(IEnumerable<SectorTransition> openTransitions)
UNCOV 229	{	×
UNCOV 230	var index = _dice.Roll(0, openTransitions.Count() - 1);	×
UNCOV 231	return new[] { openTransitions.ElementAt(index) };	×
UNCOV 232	}	×
233	}
234	}

kreghek / Zilon_Roguelike / 477922989

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