957853138

Build Type

github

Committed by GitHub

Commit Message

Merge 3c00c52f4 into 0499ae95c

Pull Request Pull Request #1196: Feature 1115 huge sectors

Run Details

1948 of 3743 branches covered (52.04%)

Branch coverage included in aggregate %.

67 of 99 new or added lines in 13 files covered. (67.68%)

8 existing lines in 2 files now uncovered.

5010 of 7928 relevant lines covered (63.19%)

37173.17 hits per line

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

0.0

/Zilon.Core/Zilon.Core/MapGenerators/StaticObstaclesGenerator.cs

﻿using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading.Tasks;

using Zilon.Core.MapGenerators.CellularAutomatonStyle;
using Zilon.Core.MapGenerators.StaticObjectFactories;
using Zilon.Core.PersonGeneration;
using Zilon.Core.Tactics;
using Zilon.Core.Tactics.Spatial;
using Zilon.Core.World;

namespace Zilon.Core.MapGenerators
{
    public sealed class StaticObstaclesGenerator : IStaticObstaclesGenerator
    {
        private readonly IChestGenerator _chestGenerator;
        private readonly IInteriorObjectRandomSource _interiorObjectRandomSource;
        private readonly IStaticObjectFactoryCollector _staticObjectfactoryCollector;
        private readonly IStaticObjectsGeneratorRandomSource _staticObjectsGeneratorRandomSource;

        public StaticObstaclesGenerator(IChestGenerator chestGenerator,
            IInteriorObjectRandomSource interiorObjectRandomSource,
            IStaticObjectFactoryCollector staticObjectfactoryCollector,
            IStaticObjectsGeneratorRandomSource staticObjectsGeneratorRandomSource)
        {
            _chestGenerator = chestGenerator ?? throw new ArgumentNullException(nameof(chestGenerator));
            _interiorObjectRandomSource = interiorObjectRandomSource ??
                                          throw new ArgumentNullException(nameof(interiorObjectRandomSource));
            _staticObjectfactoryCollector = staticObjectfactoryCollector ??
                                            throw new ArgumentNullException(nameof(staticObjectfactoryCollector));
            _staticObjectsGeneratorRandomSource = staticObjectsGeneratorRandomSource ??
                                                  throw new ArgumentNullException(
                                                      nameof(staticObjectsGeneratorRandomSource));
        }

        public IMonsterIdentifierGenerator? MonsterIdentifierGenerator { get; set; }

        private async Task CreateInternalAsync(IStaticObjectGenerationContext generationContext)
        {
            var sector = generationContext.Sector;

            await Task.Run(() =>
            {
                var exitNodes = sector.Map.Transitions.Keys.Cast<HexNode>().Select(x => x.OffsetCoords).ToArray();

                // Генерация препятсвий, как статических объектов.

                var checkPass = sector.Scheme?.Sid != "globe-node";
                foreach (var region in sector.Map.Regions)
                {
                    var regionNodes = region.Nodes.Cast<HexNode>().ToArray();
                    var regionCoords = regionNodes.Select(x => x.OffsetCoords).Except(exitNodes).ToArray();
                    var interiorMetas = _interiorObjectRandomSource.RollInteriorObjects(regionCoords, checkPass);

                    foreach (var interior in interiorMetas)
                    {
                        var node = regionNodes.Single(x => x.OffsetCoords == interior.Coords);
                        var resourceDepositData = generationContext.ResourceDepositData;
                        var staticObject = CreateStaticObject(sector, node, resourceDepositData);

                        sector.StaticObjectManager.Add(staticObject);
                    }
                }

                var sectorSubScheme = generationContext.Scheme;

                if (sectorSubScheme.TotalChestCount > 0)
                {
                    _chestGenerator.CreateChests(sector, sectorSubScheme, sector.Map.Regions);
                }
            });
        }

        private IStaticObject CreateStaticObject(ISector sector, HexNode node, IResourceDepositData resourceDepositData)
        {
            var staticObjectPurpose = RollPurpose(resourceDepositData);

            var factory = _staticObjectfactoryCollector.SelectFactoryByStaticObjectPurpose(staticObjectPurpose);

            var id = default(int);
            if (MonsterIdentifierGenerator != null)
            {
                id = MonsterIdentifierGenerator.GetNewId();
            }

            var staticObject = factory.Create(sector, node, id);

            return staticObject;
        }

        private PropContainerPurpose RollPurpose(IResourceDepositData resourceDepositData)
        {
            return _staticObjectsGeneratorRandomSource.RollPurpose(resourceDepositData);
        }

        public Task CreateAsync(IStaticObjectGenerationContext generationContext)
        {
            if (generationContext is null)
            {
                throw new ArgumentNullException(nameof(generationContext));
            }

            return CreateInternalAsync(generationContext);
        }
    }
}

1	using System;
2	using System.Collections.Concurrent;
3	using System.Linq;
4	using System.Threading.Tasks;
5
6	using Zilon.Core.MapGenerators.CellularAutomatonStyle;
7	using Zilon.Core.MapGenerators.StaticObjectFactories;
8	using Zilon.Core.PersonGeneration;
9	using Zilon.Core.Tactics;
10	using Zilon.Core.Tactics.Spatial;
11	using Zilon.Core.World;
12
13	namespace Zilon.Core.MapGenerators
14	{
15	public sealed class StaticObstaclesGenerator : IStaticObstaclesGenerator
16	{
17	private readonly IChestGenerator _chestGenerator;
18	private readonly IInteriorObjectRandomSource _interiorObjectRandomSource;
19	private readonly IStaticObjectFactoryCollector _staticObjectfactoryCollector;
20	private readonly IStaticObjectsGeneratorRandomSource _staticObjectsGeneratorRandomSource;
21
22	public StaticObstaclesGenerator(IChestGenerator chestGenerator,	×
23	IInteriorObjectRandomSource interiorObjectRandomSource,	×
24	IStaticObjectFactoryCollector staticObjectfactoryCollector,	×
25	IStaticObjectsGeneratorRandomSource staticObjectsGeneratorRandomSource)	×
26	{
27	_chestGenerator = chestGenerator ?? throw new ArgumentNullException(nameof(chestGenerator));	×
28	_interiorObjectRandomSource = interiorObjectRandomSource ??	×
29	throw new ArgumentNullException(nameof(interiorObjectRandomSource));	×
30	_staticObjectfactoryCollector = staticObjectfactoryCollector ??	×
31	throw new ArgumentNullException(nameof(staticObjectfactoryCollector));	×
32	_staticObjectsGeneratorRandomSource = staticObjectsGeneratorRandomSource ??	×
33	throw new ArgumentNullException(	×
34	nameof(staticObjectsGeneratorRandomSource));	×
35	}	×
36
37	public IMonsterIdentifierGenerator? MonsterIdentifierGenerator { get; set; }
38
39	private async Task CreateInternalAsync(IStaticObjectGenerationContext generationContext)
40	{
41	var sector = generationContext.Sector;
42
43	await Task.Run(() =>
44	{
45	var exitNodes = sector.Map.Transitions.Keys.Cast<HexNode>().Select(x => x.OffsetCoords).ToArray();
46
47	// Генерация препятсвий, как статических объектов.
48
49	var checkPass = sector.Scheme?.Sid != "globe-node";
50	foreach (var region in sector.Map.Regions)
51	{
52	var regionNodes = region.Nodes.Cast<HexNode>().ToArray();
53	var regionCoords = regionNodes.Select(x => x.OffsetCoords).Except(exitNodes).ToArray();
54	var interiorMetas = _interiorObjectRandomSource.RollInteriorObjects(regionCoords, checkPass);
55
56	foreach (var interior in interiorMetas)
57	{
58	var node = regionNodes.Single(x => x.OffsetCoords == interior.Coords);
59	var resourceDepositData = generationContext.ResourceDepositData;
60	var staticObject = CreateStaticObject(sector, node, resourceDepositData);
61
62	sector.StaticObjectManager.Add(staticObject);
63	}
64	}
65
66	var sectorSubScheme = generationContext.Scheme;
67
68	if (sectorSubScheme.TotalChestCount > 0)
69	{
70	_chestGenerator.CreateChests(sector, sectorSubScheme, sector.Map.Regions);
71	}
72	});
73	}
74
75	private IStaticObject CreateStaticObject(ISector sector, HexNode node, IResourceDepositData resourceDepositData)
76	{
77	var staticObjectPurpose = RollPurpose(resourceDepositData);	×
78
79	var factory = _staticObjectfactoryCollector.SelectFactoryByStaticObjectPurpose(staticObjectPurpose);	×
80
81	var id = default(int);	×
82	if (MonsterIdentifierGenerator != null)	×
83	{
84	id = MonsterIdentifierGenerator.GetNewId();	×
85	}
86
87	var staticObject = factory.Create(sector, node, id);	×
88
89	return staticObject;	×
90	}
91
92	private PropContainerPurpose RollPurpose(IResourceDepositData resourceDepositData)
93	{
94	return _staticObjectsGeneratorRandomSource.RollPurpose(resourceDepositData);	×
95	}
96
97	public Task CreateAsync(IStaticObjectGenerationContext generationContext)
98	{
99	if (generationContext is null)	×
100	{
101	throw new ArgumentNullException(nameof(generationContext));	×
102	}
103
NEW 104	return CreateInternalAsync(generationContext);	×
105	}
106	}
107	}

kreghek / Zilon_Roguelike / 957853138

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