904944812

Build Type

github

Committed by GitHub

Commit Message

Merge 31abab6b0 into df45d3ffc

Pull Request Pull Request #1168: Feature hit and death sounds

Run Details

2318 of 3704 branches covered (62.58%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 3 files covered. (100.0%)

17 existing lines in 7 files now uncovered.

6157 of 8074 relevant lines covered (76.26%)

36752.82 hits per line

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

67.89

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

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

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

kreghek / Zilon_Roguelike / 904944812

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