495467136

Build Type

github

Committed by GitHub

Commit Message

Merge 799305fbd into 1348daebd

Pull Request Pull Request #1013: Prop usage rules

Run Details

2042 of 3404 branches covered (59.99%)

Branch coverage included in aggregate %.

29 of 63 new or added lines in 9 files covered. (46.03%)

28 existing lines in 10 files now uncovered.

5463 of 7439 relevant lines covered (73.44%)

143351.48 hits per line

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

86.13

/Zilon.Core/Zilon.Core/MapGenerators/ChestGenerator.cs

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

using Zilon.Core.Common;
using Zilon.Core.Graphs;
using Zilon.Core.Schemes;
using Zilon.Core.StaticObjectModules;
using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.MapGenerators
{
    /// <summary>
    /// Сервис для генерации сундуков в секторе.
    /// </summary>
    public class ChestGenerator : IChestGenerator
    {
        private readonly IChestGeneratorRandomSource _chestGeneratorRandomSource;
        private readonly IDropResolver _dropResolver;
        private readonly ISchemeService _schemeService;

        public ChestGenerator(ISchemeService schemeService,
            IDropResolver dropResolver,
            IChestGeneratorRandomSource chestGeneratorRandomSource)
        {
            _schemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));
            _dropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));
            _chestGeneratorRandomSource = chestGeneratorRandomSource ??
                                          throw new ArgumentNullException(nameof(chestGeneratorRandomSource));
        }

        private static bool CheckMap(ISector sector, HexNode containerNode)
        {
            var map = sector.Map;
            var currentStaticObjectsNodes = sector.StaticObjectManager.Items.Select(x => x.Node).OfType<HexNode>();

            var allNonObstacleNodes = map.Nodes.OfType<HexNode>().ToArray();
            var allNonContainerNodes = allNonObstacleNodes.Where(x => !currentStaticObjectsNodes.Contains(x));
            var allNodes = allNonContainerNodes.ToArray();

            var matrix = new Matrix<bool>(1000, 1000);
            foreach (var node in allNodes)
            {
                var x = node.OffsetCoords.X;
                var y = node.OffsetCoords.Y;
                matrix.Items[x, y] = true;
            }

            // Закрываем проверяемый узел
            matrix.Items[containerNode.OffsetCoords.X, containerNode.OffsetCoords.Y] = false;

            var startNode = allNodes.First();
            var startPoint = startNode.OffsetCoords;
            var floodPoints = HexBinaryFiller.FloodFill(matrix, startPoint);

            foreach (var point in floodPoints)
            {
                matrix.Items[point.X, point.Y] = false;
            }

            foreach (var node in allNodes)
            {
                var x = node.OffsetCoords.X;
                var y = node.OffsetCoords.Y;
                if (matrix.Items[x, y])
                {
                    return false;
                }
            }

            return true;
        }

        private void CreateChest(List<IGraphNode> openNodes, ISector sector, IDropTableScheme[] trashDropTables,
            IDropTableScheme[] treasuresDropTable)
        {
            // Выбрать из коллекции доступных узлов
            var rollIndex = _chestGeneratorRandomSource.RollNodeIndex(openNodes.Count);
            var map = sector.Map;
            var containerNode = MapRegionHelper.FindNonBlockedNode(openNodes[rollIndex], map, openNodes);
            if (containerNode == null)
            {
                // в этом случае будет сгенерировано на один сундук меньше.
                // узел, с которого не удаётся найти подходящий узел, удаляем,
                // чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
                openNodes.Remove(openNodes[rollIndex]);
                return;
            }

            // Проверка, что сундук не перегораживает проход.
            var isValid = CheckMap(sector, (HexNode)containerNode);
            if (!isValid)
            {
                // в этом случае будет сгенерировано на один сундук меньше.
                // узел, с которого не удаётся найти подходящий узел, удаляем,
                // чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
                openNodes.Remove(openNodes[rollIndex]);
                return;
            }

            openNodes.Remove(containerNode);

            var staticObject = CreateChestStaticObject(trashDropTables, treasuresDropTable, containerNode);
            sector.StaticObjectManager.Add(staticObject);
        }

        private void CreateChestsForRegion(
            MapRegion region,
            int maxChestCount,
            ISector sector,
            IDropTableScheme[] trashDropTables,
            IDropTableScheme[] treasuresDropTable,
            ref int chestCounter)
        {
            if (region.Nodes.Length <= 1)
            {
                // Для регионов, где только один узел,
                // не создаём сундуки, иначе проход может быть загорожен.
                // Актуально для фабрики карт на основе клеточного автомата,
                // потому что он может генерить регионы из одного узла.

                //TODO Попробовать проверять соседей узла.
                // Возможно, одноклеточный регион находится в конце тупика.
                // Тогда в нём можно разместить сундук.
                // Критерий доступности такого региона - у узла только одни сосед.
                return;
            }

            var rolledCount = _chestGeneratorRandomSource.RollChestCount(maxChestCount);

            var map = sector.Map;
            var availableNodes = from node in region.Nodes
                                 where !map.Transitions.Keys.Contains(node)
                                 where map.IsPositionAvailableForContainer(node)
                                 select node;

            var openNodes = new List<IGraphNode>(availableNodes);
            for (var i = 0; i < rolledCount; i++)
            {
                CreateChest(openNodes, sector, trashDropTables, treasuresDropTable);

                chestCounter--;

                if (chestCounter <= 0)
                {
                    // лимит сундуков в секторе исчерпан.
                    break;
                }
            }
        }

        private IStaticObject CreateChestStaticObject(IDropTableScheme[] trashDropTables,
            IDropTableScheme[] treasuresDropTable, IGraphNode containerNode)
        {
            var containerPurpose = _chestGeneratorRandomSource.RollPurpose();
            var container = CreateContainerModuleByPurpose(trashDropTables,
                treasuresDropTable,
                containerPurpose);

            var staticObject = new StaticObject(containerNode, containerPurpose, default);
            staticObject.AddModule(container);
            return staticObject;
        }

        private IPropContainer CreateContainerModuleByPurpose(IDropTableScheme[] trashDropTables,
            IDropTableScheme[] treasuresDropTable, PropContainerPurpose containerPurpose)
        {
            IPropContainer container;
            switch (containerPurpose)
            {
                case PropContainerPurpose.Trash:
                    container = new DropTablePropChest(trashDropTables, _dropResolver)
                    {
                        Purpose = PropContainerPurpose.Trash
                    };
                    break;

                case PropContainerPurpose.Treasures:
                    container = new DropTablePropChest(treasuresDropTable, _dropResolver)
                    {
                        Purpose = PropContainerPurpose.Treasures
                    };
                    break;

                default:
                    throw new InvalidOperationException($"Не корректное назначение {containerPurpose}.");
            }

            return container;
        }

        private IDropTableScheme[] GetTrashDropTables(ISectorSubScheme sectorSubScheme)
        {
            var dropTables = new List<IDropTableScheme>();
            foreach (var chestDropSid in sectorSubScheme.ChestDropTableSids)
            {
                var dropTable = _schemeService.GetScheme<IDropTableScheme>(chestDropSid);
                dropTables.Add(dropTable);
            }

            return dropTables.ToArray();
        }

        private IDropTableScheme[] GetTreasuresDropTable()
        {
            return new[] { _schemeService.GetScheme<IDropTableScheme>("treasures") };
        }

        /// <inheritdoc />
        /// <summary>
        /// Создать сундуки в секторе.
        /// </summary>
        public void CreateChests(ISector sector, ISectorSubScheme sectorSubScheme, IEnumerable<MapRegion> regions)
        {
            if (sector is null)
            {
                throw new ArgumentNullException(nameof(sector));
            }

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

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

            var trashDropTables = GetTrashDropTables(sectorSubScheme);
            var treasuresDropTable = GetTreasuresDropTable();
            var chestCounter = sectorSubScheme.TotalChestCount;

            //TODO В схемах хранить уже приведённое значение пропорции.
            var countChestRatioNormal = 1f / sectorSubScheme.RegionChestCountRatio;
            foreach (var region in regions)
            {
                var maxChestCountRaw = region.Nodes.Length * countChestRatioNormal;
                var maxChestCount = (int)Math.Max(maxChestCountRaw, 1);

                CreateChestsForRegion(region, maxChestCount, sector, trashDropTables, treasuresDropTable,
                    ref chestCounter);
            }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.Common;
6	using Zilon.Core.Graphs;
7	using Zilon.Core.Schemes;
8	using Zilon.Core.StaticObjectModules;
9	using Zilon.Core.Tactics;
10	using Zilon.Core.Tactics.Spatial;
11
12	namespace Zilon.Core.MapGenerators
13	{
14	/// <summary>
15	/// Сервис для генерации сундуков в секторе.
16	/// </summary>
17	public class ChestGenerator : IChestGenerator
18	{
19	private readonly IChestGeneratorRandomSource _chestGeneratorRandomSource;
20	private readonly IDropResolver _dropResolver;
21	private readonly ISchemeService _schemeService;
22
23	public ChestGenerator(ISchemeService schemeService,	4✔
24	IDropResolver dropResolver,	4✔
25	IChestGeneratorRandomSource chestGeneratorRandomSource)	4✔
26	{
27	_schemeService = schemeService ?? throw new ArgumentNullException(nameof(schemeService));	4!
28	_dropResolver = dropResolver ?? throw new ArgumentNullException(nameof(dropResolver));	4!
29	_chestGeneratorRandomSource = chestGeneratorRandomSource ??	4!
30	throw new ArgumentNullException(nameof(chestGeneratorRandomSource));	4✔
31	}	4✔
32
33	private static bool CheckMap(ISector sector, HexNode containerNode)
34	{
35	var map = sector.Map;	35✔
36	var currentStaticObjectsNodes = sector.StaticObjectManager.Items.Select(x => x.Node).OfType<HexNode>();	35✔
37
38	var allNonObstacleNodes = map.Nodes.OfType<HexNode>().ToArray();	35✔
39	var allNonContainerNodes = allNonObstacleNodes.Where(x => !currentStaticObjectsNodes.Contains(x));	35✔
40	var allNodes = allNonContainerNodes.ToArray();	35✔
41
42	var matrix = new Matrix<bool>(1000, 1000);	35✔
43	foreach (var node in allNodes)	96,400✔
44	{
45	var x = node.OffsetCoords.X;	48,165✔
46	var y = node.OffsetCoords.Y;	48,165✔
47	matrix.Items[x, y] = true;	48,165✔
48	}
49
50	// Закрываем проверяемый узел
51	matrix.Items[containerNode.OffsetCoords.X, containerNode.OffsetCoords.Y] = false;	35✔
52
53	var startNode = allNodes.First();	35✔
54	var startPoint = startNode.OffsetCoords;	35✔
55	var floodPoints = HexBinaryFiller.FloodFill(matrix, startPoint);	35✔
56
57	foreach (var point in floodPoints)	96,336✔
58	{
59	matrix.Items[point.X, point.Y] = false;	48,133✔
60	}
61
62	foreach (var node in allNodes)	96,400✔
63	{
64	var x = node.OffsetCoords.X;	48,165✔
65	var y = node.OffsetCoords.Y;	48,165✔
66	if (matrix.Items[x, y])	48,165!
67	{
UNCOV 68	return false;	×
69	}
70	}
71
72	return true;	35✔
73	}
74
75	private void CreateChest(List<IGraphNode> openNodes, ISector sector, IDropTableScheme[] trashDropTables,
76	IDropTableScheme[] treasuresDropTable)
77	{
78	// Выбрать из коллекции доступных узлов
79	var rollIndex = _chestGeneratorRandomSource.RollNodeIndex(openNodes.Count);	35✔
80	var map = sector.Map;	35✔
81	var containerNode = MapRegionHelper.FindNonBlockedNode(openNodes[rollIndex], map, openNodes);	35✔
82	if (containerNode == null)	35!
83	{
84	// в этом случае будет сгенерировано на один сундук меньше.
85	// узел, с которого не удаётся найти подходящий узел, удаляем,
86	// чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
87	openNodes.Remove(openNodes[rollIndex]);	×
88	return;	×
89	}
90
91	// Проверка, что сундук не перегораживает проход.
92	var isValid = CheckMap(sector, (HexNode)containerNode);	35✔
93	if (!isValid)	35!
94	{
95	// в этом случае будет сгенерировано на один сундук меньше.
96	// узел, с которого не удаётся найти подходящий узел, удаляем,
97	// чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
UNCOV 98	openNodes.Remove(openNodes[rollIndex]);	×
UNCOV 99	return;	×
100	}
101
102	openNodes.Remove(containerNode);	35✔
103
104	var staticObject = CreateChestStaticObject(trashDropTables, treasuresDropTable, containerNode);	35✔
105	sector.StaticObjectManager.Add(staticObject);	35✔
106	}	35✔
107
108	private void CreateChestsForRegion(
109	MapRegion region,
110	int maxChestCount,
111	ISector sector,
112	IDropTableScheme[] trashDropTables,
113	IDropTableScheme[] treasuresDropTable,
114	ref int chestCounter)
115	{
116	if (region.Nodes.Length <= 1)	49✔
117	{
118	// Для регионов, где только один узел,
119	// не создаём сундуки, иначе проход может быть загорожен.
120	// Актуально для фабрики карт на основе клеточного автомата,
121	// потому что он может генерить регионы из одного узла.
122
123	//TODO Попробовать проверять соседей узла.
124	// Возможно, одноклеточный регион находится в конце тупика.
125	// Тогда в нём можно разместить сундук.
126	// Критерий доступности такого региона - у узла только одни сосед.
127	return;	16✔
128	}
129
130	var rolledCount = _chestGeneratorRandomSource.RollChestCount(maxChestCount);	33✔
131
132	var map = sector.Map;	33✔
133	var availableNodes = from node in region.Nodes	33✔
134	where !map.Transitions.Keys.Contains(node)	33✔
135	where map.IsPositionAvailableForContainer(node)	33✔
136	select node;	33✔
137
138	var openNodes = new List<IGraphNode>(availableNodes);	33✔
139	for (var i = 0; i < rolledCount; i++)	130✔
140	{
141	CreateChest(openNodes, sector, trashDropTables, treasuresDropTable);	35✔
142
143	chestCounter--;	35✔
144
145	if (chestCounter <= 0)	35✔
146	{
147	// лимит сундуков в секторе исчерпан.
148	break;
149	}
150	}
151	}	33✔
152
153	private IStaticObject CreateChestStaticObject(IDropTableScheme[] trashDropTables,
154	IDropTableScheme[] treasuresDropTable, IGraphNode containerNode)
155	{
156	var containerPurpose = _chestGeneratorRandomSource.RollPurpose();	35✔
157	var container = CreateContainerModuleByPurpose(trashDropTables,	35✔
158	treasuresDropTable,	35✔
159	containerPurpose);	35✔
160
161	var staticObject = new StaticObject(containerNode, containerPurpose, default);	35✔
162	staticObject.AddModule(container);	35✔
163	return staticObject;	35✔
164	}
165
166	private IPropContainer CreateContainerModuleByPurpose(IDropTableScheme[] trashDropTables,
167	IDropTableScheme[] treasuresDropTable, PropContainerPurpose containerPurpose)
168	{
169	IPropContainer container;
170	switch (containerPurpose)
171	{
172	case PropContainerPurpose.Trash:
173	container = new DropTablePropChest(trashDropTables, _dropResolver)	33!
174	{	33✔
175	Purpose = PropContainerPurpose.Trash	33✔
176	};	33✔
177	break;	33✔
178
179	case PropContainerPurpose.Treasures:
180	container = new DropTablePropChest(treasuresDropTable, _dropResolver)	2✔
181	{	2✔
182	Purpose = PropContainerPurpose.Treasures	2✔
183	};	2✔
184	break;	2✔
185
186	default:
187	throw new InvalidOperationException($"Не корректное назначение {containerPurpose}.");	×
188	}
189
190	return container;	35✔
191	}
192
193	private IDropTableScheme[] GetTrashDropTables(ISectorSubScheme sectorSubScheme)
194	{
195	var dropTables = new List<IDropTableScheme>();	9✔
196	foreach (var chestDropSid in sectorSubScheme.ChestDropTableSids)	54✔
197	{
198	var dropTable = _schemeService.GetScheme<IDropTableScheme>(chestDropSid);	18✔
199	dropTables.Add(dropTable);	18✔
200	}
201
202	return dropTables.ToArray();	9✔
203	}
204
205	private IDropTableScheme[] GetTreasuresDropTable()
206	{
207	return new[] { _schemeService.GetScheme<IDropTableScheme>("treasures") };	9✔
208	}
209
210	/// <inheritdoc />
211	/// <summary>
212	/// Создать сундуки в секторе.
213	/// </summary>
214	public void CreateChests(ISector sector, ISectorSubScheme sectorSubScheme, IEnumerable<MapRegion> regions)
215	{
216	if (sector is null)	9!
217	{
218	throw new ArgumentNullException(nameof(sector));	×
219	}
220
221	if (sectorSubScheme is null)	9!
222	{
223	throw new ArgumentNullException(nameof(sectorSubScheme));	×
224	}
225
226	if (regions is null)	9!
227	{
228	throw new ArgumentNullException(nameof(regions));	×
229	}
230
231	var trashDropTables = GetTrashDropTables(sectorSubScheme);	9✔
232	var treasuresDropTable = GetTreasuresDropTable();	9✔
233	var chestCounter = sectorSubScheme.TotalChestCount;	9✔
234
235	//TODO В схемах хранить уже приведённое значение пропорции.
236	var countChestRatioNormal = 1f / sectorSubScheme.RegionChestCountRatio;	9✔
237	foreach (var region in regions)	116✔
238	{
239	var maxChestCountRaw = region.Nodes.Length * countChestRatioNormal;	49✔
240	var maxChestCount = (int)Math.Max(maxChestCountRaw, 1);	49✔
241
242	CreateChestsForRegion(region, maxChestCount, sector, trashDropTables, treasuresDropTable,	49✔
243	ref chestCounter);	49✔
244	}
245	}	9✔
246	}
247	}

kreghek / Zilon_Roguelike / 495467136

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