Build has been canceled!

923943330

Build Type

github

Committed by GitHub

Commit Message

Merge 87753d7fe into 3567602cd

Pull Request Pull Request #1182: Feature loot

Run Details

1932 of 3698 branches covered (52.24%)

Branch coverage included in aggregate %.

30 of 39 new or added lines in 4 files covered. (76.92%)

1 existing line in 1 file now uncovered.

4971 of 7847 relevant lines covered (63.35%)

20926.56 hits per line

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

83.02

/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 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 void AddNodes(IEnumerable<SectorMapFowNode> nodes)
37	{
38	lock (_lockObject)	611✔
39	{
40	if (nodes is null)	611!
41	{
NEW 42	throw new ArgumentNullException(nameof(nodes));	×
43	}
44
45	var overlapedNodes = nodes.Where(x => Nodes.Contains(x));	611✔
46	if (overlapedNodes.Any())	611!
47	{
NEW 48	throw new InvalidOperationException(	×
NEW 49	$"Добавляются узлы тумана войны, перекрывающие существующик узлы {string.Join(",", overlapedNodes.Select(x => x.Node))}.");	×
50	}
51
52	foreach (var node in nodes)	2,444✔
53	{
54	_nodes[node.Node] = node;	611✔
55
56	var targetList = _sectorNodeHash[node.State];	611✔
57	targetList.Add(node);	611✔
58	}
59	}
60	}	611✔
61
62	public void ChangeNodeState(SectorMapFowNode node, SectorMapNodeFowState targetState)
63	{
64	lock (_lockObject)	611✔
65	{
66	if (node is null)	611!
67	{
NEW 68	throw new ArgumentNullException(nameof(node));	×
69	}
70
71	var sourceList = _sectorNodeHash[node.State];	611✔
72	sourceList.Remove(node);	611✔
73
74	var targetList = _sectorNodeHash[targetState];	611✔
75	targetList.Add(node);	611✔
76
77	node.ChangeState(targetState);	611✔
78	}	611✔
79	}	611✔
80
81	public IEnumerable<SectorMapFowNode> GetFowNodeByState(SectorMapNodeFowState targetState)
82	{
83	lock (_lockObject)	10✔
84	{
85	var targetList = _sectorNodeHash[targetState];	10✔
86	return targetList;	10✔
87	}
88	}	10✔
89
90	public SectorMapFowNode? GetNode(IGraphNode node)
91	{
92	lock (_lockObject)	611✔
93	{
94	if (_nodes.TryGetValue(node, out var sectorMapFowNode))	611!
95	{
NEW 96	return sectorMapFowNode;	×
97	}
98
99	return null;	611✔
100	}
101	}	611✔
102	}
103	}

kreghek / Zilon_Roguelike / 923943330

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