957677157

Build Type

github

Committed by GitHub

Commit Message

Merge 276b08d3b 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 86 new or added lines in 11 files covered. (68.6%)

8 existing lines in 2 files now uncovered.

5001 of 7909 relevant lines covered (63.23%)

37263.87 hits per line

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

73.33

/Zilon.Core/Zilon.Core/Tactics/HumanSectorFowData.cs

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

using Zilon.Core.Graphs;

namespace Zilon.Core.Tactics
{
    public sealed class HumanSectorFowData : ISectorFowData
    {
        private readonly object _lockObject;
        private readonly Dictionary<IGraphNode, SectorMapFowNode> _nodes;

        private readonly Dictionary<SectorMapNodeFowState, List<SectorMapFowNode>> _sectorNodeHash;

        public HumanSectorFowData()
        {
            _lockObject = new object();
            _nodes = new Dictionary<IGraphNode, SectorMapFowNode>();
            _sectorNodeHash = new Dictionary<SectorMapNodeFowState, List<SectorMapFowNode>>
            {
                { SectorMapNodeFowState.TerraIncognita, new List<SectorMapFowNode>() },
                { SectorMapNodeFowState.Explored, new List<SectorMapFowNode>() },
                { SectorMapNodeFowState.Observing, new List<SectorMapFowNode>() }
            };
        }

        public IEnumerable<SectorMapFowNode> Nodes
        {
            get
            {
                lock (_lockObject) { return _nodes.Values; }
            }
        }

        public SectorMapFowNode? GetFowByNode(IGraphNode node)
        {
            lock (_lockObject)
            {
                if (!_nodes.TryGetValue(node, out var fowData))
                {
                    return null;
                }

                return fowData;
            }
        }

        public void AddNodes(IEnumerable<SectorMapFowNode> nodes)
        {
            lock (_lockObject)
            {
                if (nodes is null)
                {
                    throw new ArgumentNullException(nameof(nodes));
                }

                var overlapedNodes = nodes.Where(x => Nodes.Contains(x));
                if (overlapedNodes.Any())
                {
                    throw new InvalidOperationException(
                        $"Добавляются узлы тумана войны, перекрывающие существующик узлы {string.Join(",", overlapedNodes.Select(x => x.Node))}.");
                }

                foreach (var node in nodes)
                {
                    _nodes[node.Node] = node;

                    var targetList = _sectorNodeHash[node.State];
                    targetList.Add(node);
                }
            }
        }

        public void ChangeNodeState(SectorMapFowNode node, SectorMapNodeFowState targetState)
        {
            lock (_lockObject)
            {
                if (node is null)
                {
                    throw new ArgumentNullException(nameof(node));
                }

                var sourceList = _sectorNodeHash[node.State];
                sourceList.Remove(node);

                var targetList = _sectorNodeHash[targetState];
                targetList.Add(node);

                node.ChangeState(targetState);
            }
        }

        public IEnumerable<SectorMapFowNode> GetFowNodeByState(SectorMapNodeFowState targetState)
        {
            lock (_lockObject)
            {
                var targetList = _sectorNodeHash[targetState];
                return targetList;
            }
        }

        public SectorMapFowNode? GetNode(IGraphNode node)
        {
            lock (_lockObject)
            {
                if (_nodes.TryGetValue(node, out var sectorMapFowNode))
                {
                    return sectorMapFowNode;
                }

                return null;
            }
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	using Zilon.Core.Graphs;
6
7	namespace Zilon.Core.Tactics
8	{
9	public sealed class HumanSectorFowData : ISectorFowData
10	{
11	private readonly object _lockObject;
12	private readonly Dictionary<IGraphNode, SectorMapFowNode> _nodes;
13
14	private readonly Dictionary<SectorMapNodeFowState, List<SectorMapFowNode>> _sectorNodeHash;
15
16	public HumanSectorFowData()	5✔
17	{
18	_lockObject = new object();	5✔
19	_nodes = new Dictionary<IGraphNode, SectorMapFowNode>();	5✔
20	_sectorNodeHash = new Dictionary<SectorMapNodeFowState, List<SectorMapFowNode>>	5✔
21	{	5✔
22	{ SectorMapNodeFowState.TerraIncognita, new List<SectorMapFowNode>() },	5✔
23	{ SectorMapNodeFowState.Explored, new List<SectorMapFowNode>() },	5✔
24	{ SectorMapNodeFowState.Observing, new List<SectorMapFowNode>() }	5✔
25	};	5✔
26	}	5✔
27
28	public IEnumerable<SectorMapFowNode> Nodes
29	{
30	get
31	{
32	lock (_lockObject) { return _nodes.Values; }	1,222✔
33	}	611✔
34	}
35
36	public SectorMapFowNode? GetFowByNode(IGraphNode node)
37	{
NEW 38	lock (_lockObject)	×
39	{
NEW 40	if (!_nodes.TryGetValue(node, out var fowData))	×
41	{
NEW 42	return null;	×
43	}
44
NEW 45	return fowData;	×
46	}
NEW 47	}	×
48
49	public void AddNodes(IEnumerable<SectorMapFowNode> nodes)
50	{
51	lock (_lockObject)	611✔
52	{
53	if (nodes is null)	611!
54	{
55	throw new ArgumentNullException(nameof(nodes));	×
56	}
57
58	var overlapedNodes = nodes.Where(x => Nodes.Contains(x));	611✔
59	if (overlapedNodes.Any())	611!
60	{
61	throw new InvalidOperationException(	×
62	$"Добавляются узлы тумана войны, перекрывающие существующик узлы {string.Join(",", overlapedNodes.Select(x => x.Node))}.");	×
63	}
64
65	foreach (var node in nodes)	2,444✔
66	{
67	_nodes[node.Node] = node;	611✔
68
69	var targetList = _sectorNodeHash[node.State];	611✔
70	targetList.Add(node);	611✔
71	}
72	}
73	}	611✔
74
75	public void ChangeNodeState(SectorMapFowNode node, SectorMapNodeFowState targetState)
76	{
77	lock (_lockObject)	611✔
78	{
79	if (node is null)	611!
80	{
81	throw new ArgumentNullException(nameof(node));	×
82	}
83
84	var sourceList = _sectorNodeHash[node.State];	611✔
85	sourceList.Remove(node);	611✔
86
87	var targetList = _sectorNodeHash[targetState];	611✔
88	targetList.Add(node);	611✔
89
90	node.ChangeState(targetState);	611✔
91	}	611✔
92	}	611✔
93
94	public IEnumerable<SectorMapFowNode> GetFowNodeByState(SectorMapNodeFowState targetState)
95	{
96	lock (_lockObject)	10✔
97	{
98	var targetList = _sectorNodeHash[targetState];	10✔
99	return targetList;	10✔
100	}
101	}	10✔
102
103	public SectorMapFowNode? GetNode(IGraphNode node)
104	{
105	lock (_lockObject)	611✔
106	{
107	if (_nodes.TryGetValue(node, out var sectorMapFowNode))	611!
108	{
109	return sectorMapFowNode;	×
110	}
111
112	return null;	611✔
113	}
114	}	611✔
115	}
116	}

kreghek / Zilon_Roguelike / 957677157

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