476598642

Build Type

github

Committed by GitHub

Commit Message

Merge 50e2e12ba into 16ec4ccf0

Pull Request Pull Request #987: Restore code coverage gate passing

Run Details

2251 of 3728 branches covered (60.38%)

Branch coverage included in aggregate %.

10 of 33 new or added lines in 2 files covered. (30.3%)

1229 existing lines in 221 files now uncovered.

9272 of 12814 relevant lines covered (72.36%)

335958.3 hits per line

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

60.19

/Zilon.Core/Zilon.Core/Tactics/Spatial/GraphMap.cs

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

using JetBrains.Annotations;

using Zilon.Core.Graphs;

namespace Zilon.Core.Tactics.Spatial
{
    public class GraphMap : MapBase
    {
        private readonly IList<IGraphEdge> _edges;
        private readonly IList<IGraphNode> _nodes;

        [ExcludeFromCodeCoverage]
        public GraphMap()
        {
            _edges = new List<IGraphEdge>();
            _nodes = new List<IGraphNode>();
        }

        public override IEnumerable<IGraphNode> Nodes => _nodes;

        public override void AddEdge([NotNull] IGraphNode node1, [NotNull] IGraphNode node2)
        {
            if (node1 == null)
            {
                throw new ArgumentNullException(nameof(node1));
            }

            if (node2 == null)
            {
                throw new ArgumentNullException(nameof(node2));
            }

            if (!CheckNodeInMap(node1))
            {
                throw new ArgumentException($"Указанный узел {node1} не найден в текущей карте", nameof(node1));
            }

            if (!CheckNodeInMap(node2))
            {
                throw new ArgumentException($"Указанный узел {node2} не найден в текущей карте", nameof(node2));
            }

            _edges.Add(new Edge(node1, node2));
        }

        [ExcludeFromCodeCoverage]
        public override void AddNode(IGraphNode node)
        {
            _nodes.Add(node);
        }

        public override int DistanceBetween(IGraphNode currentNode, IGraphNode targetNode)
        {
            if (currentNode is null)
            {
                throw new ArgumentNullException(nameof(currentNode));
            }

            if (targetNode is null)
            {
                throw new ArgumentNullException(nameof(targetNode));
            }

            if (!(currentNode is HexNode))
            {
                throw new ArgumentException($"{nameof(currentNode)} должен быть типа {typeof(HexNode)}");
            }

            if (!(targetNode is HexNode))
            {
                throw new ArgumentException($"{nameof(targetNode)} должен быть типа {typeof(HexNode)}");
            }

            var actorHexNode = (HexNode)currentNode;
            var containerHexNode = (HexNode)targetNode;

            var actorCoords = actorHexNode.CubeCoords;
            var containerCoords = containerHexNode.CubeCoords;

            var distance = actorCoords.DistanceTo(containerCoords);

            return distance;
        }

        public override IEnumerable<IGraphNode> GetNext(IGraphNode node)
        {
            var hexCurrent = (HexNode)node;
            var hexNodes = Nodes.Cast<HexNode>().ToArray();
            var neighbors = HexNodeHelper.GetSpatialNeighbors(hexCurrent, hexNodes);

            var currentEdges = from edge in _edges
                               where edge.Nodes.Contains(node)
                               select edge;
            var currentEdgeArray = currentEdges.ToArray();

            foreach (var testedNeighbor in neighbors)
            {
                var edge = currentEdgeArray.SingleOrDefault(x => x.Nodes.Contains(testedNeighbor));
                if (edge == null)
                {
                    continue;
                }

                yield return testedNeighbor;
            }
        }

        public override bool IsPositionAvailableForContainer(IGraphNode targetNode)
        {
            throw new NotImplementedException();
        }

        public override void RemoveEdge(IGraphNode node1, IGraphNode node2)
        {
            var currentEdge = (from edge in _edges
                               where edge.Nodes.Contains(node1)
                               where edge.Nodes.Contains(node2)
                               select edge).Single();

            _edges.Remove(currentEdge);
        }

        /// <inheritdoc />
        public override void RemoveNode(IGraphNode node)
        {
            _nodes.Remove(node);

            var edgesCopy = _edges.ToArray();
            foreach (var edge in edgesCopy)
            {
                if (edge.Nodes.Contains(node))
                {
                    _edges.Remove(edge);
                }
            }
        }

        public bool TargetIsOnLine(IGraphNode currentNode, IGraphNode targetNode)
        {
            return true;
        }

        private bool CheckNodeInMap(IGraphNode node)
        {
            return Nodes.Contains(node);
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5
6	using JetBrains.Annotations;
7
8	using Zilon.Core.Graphs;
9
10	namespace Zilon.Core.Tactics.Spatial
11	{
12	public class GraphMap : MapBase
13	{
14	private readonly IList<IGraphEdge> _edges;
15	private readonly IList<IGraphNode> _nodes;
16
17	[ExcludeFromCodeCoverage]
18	public GraphMap()
19	{
20	_edges = new List<IGraphEdge>();
21	_nodes = new List<IGraphNode>();
22	}
23
24	public override IEnumerable<IGraphNode> Nodes => _nodes;	54,741✔
25
26	public override void AddEdge([NotNull] IGraphNode node1, [NotNull] IGraphNode node2)
27	{	12,273✔
28	if (node1 == null)	12,273!
UNCOV 29	{	×
30	throw new ArgumentNullException(nameof(node1));	×
31	}
32
33	if (node2 == null)	12,273!
UNCOV 34	{	×
35	throw new ArgumentNullException(nameof(node2));	×
36	}
37
38	if (!CheckNodeInMap(node1))	12,273!
UNCOV 39	{	×
40	throw new ArgumentException($"Указанный узел {node1} не найден в текущей карте", nameof(node1));	×
41	}
42
43	if (!CheckNodeInMap(node2))	12,273!
UNCOV 44	{	×
45	throw new ArgumentException($"Указанный узел {node2} не найден в текущей карте", nameof(node2));	×
46	}
47
48	_edges.Add(new Edge(node1, node2));	12,273✔
49	}	12,273✔
50
51	[ExcludeFromCodeCoverage]
52	public override void AddNode(IGraphNode node)
53	{
54	_nodes.Add(node);
55	}
56
57	public override int DistanceBetween(IGraphNode currentNode, IGraphNode targetNode)
58	{	2✔
59	if (currentNode is null)	2!
UNCOV 60	{	×
61	throw new ArgumentNullException(nameof(currentNode));	×
62	}
63
64	if (targetNode is null)	2!
UNCOV 65	{	×
66	throw new ArgumentNullException(nameof(targetNode));	×
67	}
68
69	if (!(currentNode is HexNode))	2!
UNCOV 70	{	×
71	throw new ArgumentException($"{nameof(currentNode)} должен быть типа {typeof(HexNode)}");	×
72	}
73
74	if (!(targetNode is HexNode))	2!
UNCOV 75	{	×
76	throw new ArgumentException($"{nameof(targetNode)} должен быть типа {typeof(HexNode)}");	×
77	}
78
79	var actorHexNode = (HexNode)currentNode;	2✔
80	var containerHexNode = (HexNode)targetNode;	2✔
81
82	var actorCoords = actorHexNode.CubeCoords;	2✔
83	var containerCoords = containerHexNode.CubeCoords;	2✔
84
85	var distance = actorCoords.DistanceTo(containerCoords);	2✔
86
87	return distance;	2✔
88	}	2✔
89
90	public override IEnumerable<IGraphNode> GetNext(IGraphNode node)
91	{	24,848✔
92	var hexCurrent = (HexNode)node;	24,848✔
93	var hexNodes = Nodes.Cast<HexNode>().ToArray();	24,848✔
94	var neighbors = HexNodeHelper.GetSpatialNeighbors(hexCurrent, hexNodes);	24,848✔
95
96	var currentEdges = from edge in _edges	24,848✔
97	where edge.Nodes.Contains(node)	4,330,171✔
98	select edge;	24,848✔
99	var currentEdgeArray = currentEdges.ToArray();	24,848✔
100
101	foreach (var testedNeighbor in neighbors)	286,406✔
102	{	112,067✔
103	var edge = currentEdgeArray.SingleOrDefault(x => x.Nodes.Contains(testedNeighbor));	601,097✔
104	if (edge == null)	112,067✔
105	{	23,387✔
106	continue;	23,387✔
107	}
108
109	yield return testedNeighbor;	88,680✔
110	}	76,408✔
111	}	12,576✔
112
113	public override bool IsPositionAvailableForContainer(IGraphNode targetNode)
UNCOV 114	{	×
115	throw new NotImplementedException();	×
116	}
117
118	public override void RemoveEdge(IGraphNode node1, IGraphNode node2)
119	{	18✔
120	var currentEdge = (from edge in _edges	18✔
121	where edge.Nodes.Contains(node1)	655✔
122	where edge.Nodes.Contains(node2)	63✔
123	select edge).Single();	18✔
124
125	_edges.Remove(currentEdge);	18✔
126	}	18✔
127
128	/// <inheritdoc />
129	public override void RemoveNode(IGraphNode node)
UNCOV 130	{	×
131	_nodes.Remove(node);	×
132
133	var edgesCopy = _edges.ToArray();	×
134	foreach (var edge in edgesCopy)	×
UNCOV 135	{	×
136	if (edge.Nodes.Contains(node))	×
UNCOV 137	{	×
138	_edges.Remove(edge);	×
UNCOV 139	}	×
UNCOV 140	}	×
141	}	×
142
143	public bool TargetIsOnLine(IGraphNode currentNode, IGraphNode targetNode)
144	{	352✔
145	return true;	352✔
146	}	352✔
147
148	private bool CheckNodeInMap(IGraphNode node)
149	{	24,546✔
150	return Nodes.Contains(node);	24,546✔
151	}	24,546✔
152	}
153	}

kreghek / Zilon_Roguelike / 476598642

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