875466002

Build Type

github

Committed by GitHub

Commit Message

Merge b26b9ed56 into 734a1318e

Pull Request Pull Request #1130: Feature 1112 visualize Swords and Shield

Run Details

2284 of 3688 branches covered (61.93%)

Branch coverage included in aggregate %.

10 of 16 new or added lines in 4 files covered. (62.5%)

70 existing lines in 13 files now uncovered.

6118 of 8022 relevant lines covered (76.27%)

42759.95 hits per line

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

85.52

/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 chestDropTableSids = sectorSubScheme.ChestDropTableSids;
            if (chestDropTableSids is null)
            {
                return Array.Empty<IDropTableScheme>();
            }

            var dropTables = new List<IDropTableScheme>();

            foreach (var chestDropSid in chestDropTableSids)
            {
                if (chestDropSid is null)
                {
                    continue;
                }

                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;	43✔
36	var currentStaticObjectsNodes = sector.StaticObjectManager.Items.Select(x => x.Node).OfType<HexNode>();	43✔
37
38	var allNonObstacleNodes = map.Nodes.OfType<HexNode>().ToArray();	43✔
39	var allNonContainerNodes = allNonObstacleNodes.Where(x => !currentStaticObjectsNodes.Contains(x));	43✔
40	var allNodes = allNonContainerNodes.ToArray();	43✔
41
42	var matrix = new Matrix<bool>(1000, 1000);	43✔
43	foreach (var node in allNodes)	38,316✔
44	{
45	var x = node.OffsetCoords.X;	19,115✔
46	var y = node.OffsetCoords.Y;	19,115✔
47	matrix.Items[x, y] = true;	19,115✔
48	}
49
50	// Закрываем проверяемый узел
51	matrix.Items[containerNode.OffsetCoords.X, containerNode.OffsetCoords.Y] = false;	43✔
52
53	var startNode = allNodes.First();	43✔
54	var startPoint = startNode.OffsetCoords;	43✔
55	var floodPoints = HexBinaryFiller.FloodFill(matrix, startPoint);	43✔
56
57	foreach (var point in floodPoints)	38,240✔
58	{
59	matrix.Items[point.X, point.Y] = false;	19,077✔
60	}
61
62	foreach (var node in allNodes)	38,316✔
63	{
64	var x = node.OffsetCoords.X;	19,115✔
65	var y = node.OffsetCoords.Y;	19,115✔
66	if (matrix.Items[x, y])	19,115!
67	{
UNCOV 68	return false;	×
69	}
70	}
71
72	return true;	43✔
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);	43✔
80	var map = sector.Map;	43✔
81	var containerNode = MapRegionHelper.FindNonBlockedNode(openNodes[rollIndex], map, openNodes);	43✔
82	if (containerNode == null)	43!
83	{
84	// в этом случае будет сгенерировано на один сундук меньше.
85	// узел, с которого не удаётся найти подходящий узел, удаляем,
86	// чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
87	openNodes.Remove(openNodes[rollIndex]);	×
88	return;	×
89	}
90
91	// Проверка, что сундук не перегораживает проход.
92	var isValid = CheckMap(sector, (HexNode)containerNode);	43✔
93	if (!isValid)	43!
94	{
95	// в этом случае будет сгенерировано на один сундук меньше.
96	// узел, с которого не удаётся найти подходящий узел, удаляем,
97	// чтобы больше его не анализировать, т.к. всё равно будет такой же исход.
UNCOV 98	openNodes.Remove(openNodes[rollIndex]);	×
UNCOV 99	return;	×
100	}
101
102	openNodes.Remove(containerNode);	43✔
103
104	var staticObject = CreateChestStaticObject(trashDropTables, treasuresDropTable, containerNode);	43✔
105	sector.StaticObjectManager.Add(staticObject);	43✔
106	}	43✔
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)	60✔
117	{
118	// Для регионов, где только один узел,
119	// не создаём сундуки, иначе проход может быть загорожен.
120	// Актуально для фабрики карт на основе клеточного автомата,
121	// потому что он может генерить регионы из одного узла.
122
123	//TODO Попробовать проверять соседей узла.
124	// Возможно, одноклеточный регион находится в конце тупика.
125	// Тогда в нём можно разместить сундук.
126	// Критерий доступности такого региона - у узла только одни сосед.
127	return;	14✔
128	}
129
130	var rolledCount = _chestGeneratorRandomSource.RollChestCount(maxChestCount);	46✔
131
132	var map = sector.Map;	46✔
133	var availableNodes = from node in region.Nodes	46✔
134	where !map.Transitions.Keys.Contains(node)	46✔
135	where map.IsPositionAvailableForContainer(node)	46✔
136	select node;	46✔
137
138	var openNodes = new List<IGraphNode>(availableNodes);	46✔
139	for (var i = 0; i < rolledCount; i++)	170✔
140	{
141	CreateChest(openNodes, sector, trashDropTables, treasuresDropTable);	43✔
142
143	chestCounter--;	43✔
144
145	if (chestCounter <= 0)	43✔
146	{
147	// лимит сундуков в секторе исчерпан.
148	break;
149	}
150	}
151	}	46✔
152
153	private IStaticObject CreateChestStaticObject(IDropTableScheme[] trashDropTables,
154	IDropTableScheme[] treasuresDropTable, IGraphNode containerNode)
155	{
156	var containerPurpose = _chestGeneratorRandomSource.RollPurpose();	43✔
157	var container = CreateContainerModuleByPurpose(trashDropTables,	43✔
158	treasuresDropTable,	43✔
159	containerPurpose);	43✔
160
161	var staticObject = new StaticObject(containerNode, containerPurpose, default);	43✔
162	staticObject.AddModule(container);	43✔
163	return staticObject;	43✔
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)	40!
174	{	40✔
175	Purpose = PropContainerPurpose.Trash	40✔
176	};	40✔
177	break;	40✔
178
179	case PropContainerPurpose.Treasures:
180	container = new DropTablePropChest(treasuresDropTable, _dropResolver)	3✔
181	{	3✔
182	Purpose = PropContainerPurpose.Treasures	3✔
183	};	3✔
184	break;	3✔
185
186	default:
187	throw new InvalidOperationException($"Не корректное назначение {containerPurpose}.");	×
188	}
189
190	return container;	43✔
191	}
192
193	private IDropTableScheme[] GetTrashDropTables(ISectorSubScheme sectorSubScheme)
194	{
195	var chestDropTableSids = sectorSubScheme.ChestDropTableSids;	9✔
196	if (chestDropTableSids is null)	9!
197	{
198	return Array.Empty<IDropTableScheme>();	×
199	}
200
201	var dropTables = new List<IDropTableScheme>();	9✔
202
203	foreach (var chestDropSid in chestDropTableSids)	54✔
204	{
205	if (chestDropSid is null)	18✔
206	{
207	continue;
208	}
209
210	var dropTable = _schemeService.GetScheme<IDropTableScheme>(chestDropSid);	18✔
211	dropTables.Add(dropTable);	18✔
212	}
213
214	return dropTables.ToArray();	9✔
215	}
216
217	private IDropTableScheme[] GetTreasuresDropTable()
218	{
219	return new[] { _schemeService.GetScheme<IDropTableScheme>("treasures") };	9✔
220	}
221
222	/// <inheritdoc />
223	/// <summary>
224	/// Создать сундуки в секторе.
225	/// </summary>
226	public void CreateChests(ISector sector, ISectorSubScheme sectorSubScheme, IEnumerable<MapRegion> regions)
227	{
228	if (sector is null)	9!
229	{
230	throw new ArgumentNullException(nameof(sector));	×
231	}
232
233	if (sectorSubScheme is null)	9!
234	{
235	throw new ArgumentNullException(nameof(sectorSubScheme));	×
236	}
237
238	if (regions is null)	9!
239	{
240	throw new ArgumentNullException(nameof(regions));	×
241	}
242
243	var trashDropTables = GetTrashDropTables(sectorSubScheme);	9✔
244	var treasuresDropTable = GetTreasuresDropTable();	9✔
245	var chestCounter = sectorSubScheme.TotalChestCount;	9✔
246
247	//TODO В схемах хранить уже приведённое значение пропорции.
248	var countChestRatioNormal = 1f / sectorSubScheme.RegionChestCountRatio;	9✔
249	foreach (var region in regions)	138✔
250	{
251	var maxChestCountRaw = region.Nodes.Length * countChestRatioNormal;	60✔
252	var maxChestCount = (int)Math.Max(maxChestCountRaw, 1);	60✔
253
254	CreateChestsForRegion(region, maxChestCount, sector, trashDropTables, treasuresDropTable,	60✔
255	ref chestCounter);	60✔
256	}
257	}	9✔
258	}
259	}

kreghek / Zilon_Roguelike / 875466002

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