869989902

Build Type

github

Committed by GitHub

Commit Message

Merge a15f66586 into 00d2fa5b7

Pull Request Pull Request #1124: Feature 1100 autoplay mode

Run Details

2303 of 3696 branches covered (62.31%)

Branch coverage included in aggregate %.

46 of 55 new or added lines in 15 files covered. (83.64%)

37 existing lines in 16 files now uncovered.

6146 of 8030 relevant lines covered (76.54%)

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

kreghek / Zilon_Roguelike / 869989902

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