957754142

Build Type

github

Committed by GitHub

Commit Message

Merge 94eb03a8b into 0499ae95c

Pull Request Pull Request #1196: Feature 1115 huge sectors

Run Details

1940 of 3725 branches covered (52.08%)

Branch coverage included in aggregate %.

59 of 88 new or added lines in 11 files covered. (67.05%)

8 existing lines in 2 files now uncovered.

5001 of 7911 relevant lines covered (63.22%)

37254.45 hits per line

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

73.58

/Zilon.Core/Zilon.Core/MapGenerators/OpenStyle/OpenMapFactory.cs

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

using Zilon.Core.Common;
using Zilon.Core.CommonServices.Dices;
using Zilon.Core.Schemes;
using Zilon.Core.Tactics.Spatial;

namespace Zilon.Core.MapGenerators.OpenStyle
{
    public sealed class OpenMapFactory : IMapFactory
    {
        private const int START_REGION_ID = 1;
        private readonly IDice _dice;

        public OpenMapFactory(IDice dice)
        {
            _dice = dice;
        }

        private void CreateRegionsAndTranstions(ISectorMap map, int mapSize, HexNode centerNode,
            IEnumerable<SectorTransition> transitions)
        {
            var availableNodes = map.Nodes.OfType<HexNode>().ToList();

            // start region

            var startX = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.X;
            var startY = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.Y;

            var startRegionNodes = new[] { availableNodes.Single(x => x.OffsetCoords.CompsEqual(startX, startY)) };
            var startRegion = new MapRegion(START_REGION_ID, startRegionNodes)
            {
                IsStart = true
            };
            map.Regions.Add(startRegion);
            foreach (var node in startRegionNodes)
            {
                availableNodes.Remove(node);
            }

            // transition regions

            var transitionsList = transitions.ToArray();
            for (var i = 0; i < transitionsList.Length; i++)
            {
                var roundPart = Math.PI * 2 * i / transitionsList.Length;
                var x = (int)(Math.Cos(roundPart) * mapSize) + centerNode.OffsetCoords.X;
                var y = (int)(Math.Sin(roundPart) * mapSize) + centerNode.OffsetCoords.Y;

                var transitionRegionNodes = new[] { availableNodes.Single(node => node.OffsetCoords.CompsEqual(x, y)) };
                var transitionRegionId = START_REGION_ID + i + 1;
                var transitionRegion = new MapRegion(transitionRegionId, transitionRegionNodes);
                transitionRegion.ExitNodes = transitionRegion.Nodes;
                map.Regions.Add(transitionRegion);

                foreach (var node in transitionRegionNodes)
                {
                    availableNodes.Remove(node);
                    map.Transitions[node] = transitionsList[i];
                }
            }

            // main region
            var mainRegion = new MapRegion(1000, availableNodes.ToArray());
            map.Regions.Add(mainRegion);
        }

        private static void FillMap(ISectorMap map, int mapWidth, int mapHeight, int mapSize, HexNode centerNode)
        {
            for (var x = 0; x < mapWidth; x++)
            {
                for (var y = 0; y < mapHeight; y++)
                {
                    var testOffsetCoords = new OffsetCoords(x, y);
                    var testCubeCoords = HexHelper.ConvertToCube(testOffsetCoords);
                    var distanceToCenter = centerNode.CubeCoords.DistanceTo(testCubeCoords);
                    if (distanceToCenter > 0 && distanceToCenter <= mapSize)
                    {
                        var node = new HexNode(testOffsetCoords);
                        map.AddNode(node);
                    }
                }
            }
        }

        public async Task<ISectorMap> CreateAsync(ISectorMapFactoryOptions generationOptions)
        {
            if (generationOptions is null)
            {
                throw new ArgumentNullException(nameof(generationOptions));
            }

            var factoryOptions = (ISectorOpenMapFactoryOptionsSubScheme)generationOptions.OptionsSubScheme;
            if (factoryOptions == null)
            {
                throw new ArgumentException(
                    $"Map generation options {nameof(ISectorSubScheme.MapGeneratorOptions)} are not defined in {nameof(generationOptions)}.");
            }

            var mapSize = factoryOptions.Size;
            var mapWidth = (mapSize * 2) + 2;
            var mapHeight = mapWidth;

            return await Task.Run(() =>
            {
                ISectorMap map = new SectorHexMap(mapWidth);

                var centerNode = new HexNode(mapSize, mapSize);
                map.AddNode(centerNode);

                FillMap(map, mapWidth, mapHeight, mapSize, centerNode);

                CreateRegionsAndTranstions(map, mapSize, centerNode, generationOptions.Transitions);

                map.Regions.Add(new MapRegion(1, map.Nodes.ToArray()));

                return map;
            });
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Threading.Tasks;
5
6	using Zilon.Core.Common;
7	using Zilon.Core.CommonServices.Dices;
8	using Zilon.Core.Schemes;
9	using Zilon.Core.Tactics.Spatial;
10
11	namespace Zilon.Core.MapGenerators.OpenStyle
12	{
13	public sealed class OpenMapFactory : IMapFactory
14	{
15	private const int START_REGION_ID = 1;
16	private readonly IDice _dice;
17
18	public OpenMapFactory(IDice dice)	1✔
19	{
20	_dice = dice;	1✔
21	}	1✔
22
23	private void CreateRegionsAndTranstions(ISectorMap map, int mapSize, HexNode centerNode,
24	IEnumerable<SectorTransition> transitions)
25	{
26	var availableNodes = map.Nodes.OfType<HexNode>().ToList();	1✔
27
28	// start region
29
30	var startX = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.X;	1✔
31	var startY = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.Y;	1✔
32
33	var startRegionNodes = new[] { availableNodes.Single(x => x.OffsetCoords.CompsEqual(startX, startY)) };	1✔
34	var startRegion = new MapRegion(START_REGION_ID, startRegionNodes)	1✔
35	{	1✔
36	IsStart = true	1✔
37	};	1✔
38	map.Regions.Add(startRegion);	1✔
39	foreach (var node in startRegionNodes)	4✔
40	{
41	availableNodes.Remove(node);	1✔
42	}
43
44	// transition regions
45
46	var transitionsList = transitions.ToArray();	1✔
47	for (var i = 0; i < transitionsList.Length; i++)	2!
48	{
NEW 49	var roundPart = Math.PI * 2 * i / transitionsList.Length;	×
NEW 50	var x = (int)(Math.Cos(roundPart) * mapSize) + centerNode.OffsetCoords.X;	×
NEW 51	var y = (int)(Math.Sin(roundPart) * mapSize) + centerNode.OffsetCoords.Y;	×
52
NEW 53	var transitionRegionNodes = new[] { availableNodes.Single(node => node.OffsetCoords.CompsEqual(x, y)) };	×
NEW 54	var transitionRegionId = START_REGION_ID + i + 1;	×
NEW 55	var transitionRegion = new MapRegion(transitionRegionId, transitionRegionNodes);	×
NEW 56	transitionRegion.ExitNodes = transitionRegion.Nodes;	×
NEW 57	map.Regions.Add(transitionRegion);	×
58
NEW 59	foreach (var node in transitionRegionNodes)	×
60	{
NEW 61	availableNodes.Remove(node);	×
NEW 62	map.Transitions[node] = transitionsList[i];	×
63	}
64	}
65
66	// main region
67	var mainRegion = new MapRegion(1000, availableNodes.ToArray());	1✔
68	map.Regions.Add(mainRegion);	1✔
69	}	1✔
70
71	private static void FillMap(ISectorMap map, int mapWidth, int mapHeight, int mapSize, HexNode centerNode)
72	{
73	for (var x = 0; x < mapWidth; x++)	4,010✔
74	{
75	for (var y = 0; y < mapHeight; y++)	8,036,040✔
76	{
77	var testOffsetCoords = new OffsetCoords(x, y);	4,016,016✔
78	var testCubeCoords = HexHelper.ConvertToCube(testOffsetCoords);	4,016,016✔
79	var distanceToCenter = centerNode.CubeCoords.DistanceTo(testCubeCoords);	4,016,016✔
80	if (distanceToCenter > 0 && distanceToCenter <= mapSize)	4,016,016✔
81	{
82	var node = new HexNode(testOffsetCoords);	3,009,006✔
83	map.AddNode(node);	3,009,006✔
84	}
85	}
86	}
87	}	1✔
88
89	public async Task<ISectorMap> CreateAsync(ISectorMapFactoryOptions generationOptions)
90	{
91	if (generationOptions is null)
92	{
93	throw new ArgumentNullException(nameof(generationOptions));
94	}
95
96	var factoryOptions = (ISectorOpenMapFactoryOptionsSubScheme)generationOptions.OptionsSubScheme;
97	if (factoryOptions == null)
98	{
99	throw new ArgumentException(
100	$"Map generation options {nameof(ISectorSubScheme.MapGeneratorOptions)} are not defined in {nameof(generationOptions)}.");
101	}
102
103	var mapSize = factoryOptions.Size;
104	var mapWidth = (mapSize * 2) + 2;
105	var mapHeight = mapWidth;
106
107	return await Task.Run(() =>
108	{
109	ISectorMap map = new SectorHexMap(mapWidth);
110
111	var centerNode = new HexNode(mapSize, mapSize);
112	map.AddNode(centerNode);
113
114	FillMap(map, mapWidth, mapHeight, mapSize, centerNode);
115
116	CreateRegionsAndTranstions(map, mapSize, centerNode, generationOptions.Transitions);
117
118	map.Regions.Add(new MapRegion(1, map.Nodes.ToArray()));
119
120	return map;
121	});
122	}
123	}
124	}

kreghek / Zilon_Roguelike / 957754142

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