955666002

Build Type

github

Committed by GitHub

Commit Message

Merge d121b02a7 into 1fcec6eb0

Pull Request Pull Request #1196: Feature 1115 huge sectors

Run Details

1947 of 3721 branches covered (52.32%)

Branch coverage included in aggregate %.

41 of 64 new or added lines in 8 files covered. (64.06%)

32 existing lines in 7 files now uncovered.

5008 of 7904 relevant lines covered (63.36%)

37285.35 hits per line

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

76.47

/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 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 startRegion = new MapRegion(1,
                new[] { availableNodes.Single(x => x.OffsetCoords.CompsEqual(startX, startY)) })
            {
                IsStart = true
            };
            map.Regions.Add(startRegion);
            foreach (HexNode node in startRegion.Nodes)
            {
                availableNodes.Remove(node);
            }

            // transition regions

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

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

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

kreghek / Zilon_Roguelike / 955666002

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