#35: made generating sourcegrid faster

Source/Code/Duality.Plugins.Pathfindax.Tilemaps/Components/TilemapNodeGridGenerator.cs

@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using Duality.Editor;
@@ -37,7 +38,8 @@ public class TilemapNodeGridGenerator : Component, ISourceNodeNetworkProvider<So
 		public SourceNodeGrid GenerateGrid2D()
 		{
 			if (_sourceNodeGrid == null)
-			{				
+			{
+				var watch = Stopwatch.StartNew();
 				var tilemaps = SearchTilemaps().ToArray();
 				var baseTilemap = tilemaps.FirstOrDefault();
 				if (baseTilemap == null)
@@ -68,6 +70,7 @@ public SourceNodeGrid GenerateGrid2D()
 						}
 					}
 				});
+				Debug.WriteLine($"Generated definition nodegrid for tilemap in {watch.ElapsedMilliseconds} ms");
 			}
 			return _sourceNodeGrid;
 		}

Source/Code/Duality.Plugins.Pathfindax/Components/NodeNetworkVisualizer.cs

@@ -7,7 +7,7 @@
 namespace Duality.Plugins.Pathfindax.Components
 {
 	/// <summary>
-	/// Class for visualizing a <see cref="INodeNetwork{TNode}"/>
+	/// Class for visualizing a <see cref="IPathfindNodeNetwork{TNode}"/>
 	/// </summary>
 	[EditorHintCategory(PathfindaxStrings.Pathfindax)]
 	[RequiredComponent(typeof(IPathfinderComponent<ISourceNodeNetwork<SourceNode>>))]

Source/Code/Pathfindax/Algorithms/AStarAlgorithm.cs

@@ -11,9 +11,9 @@ namespace Pathfindax.Algorithms
 	/// <summary>
 	/// Class that implements the A* algorithm to find paths
 	/// </summary>
-	public class AStarAlgorithm : IPathFindAlgorithm<INodeNetwork<AstarNode>>
+	public class AStarAlgorithm : IPathFindAlgorithm<IPathfindNodeNetwork<AstarNode>>
 	{
-		public List<DefinitionNode> FindPath(INodeNetwork<AstarNode> nodeNetwork, PathRequest pathRequest)
+		public List<DefinitionNode> FindPath(IPathfindNodeNetwork<AstarNode> nodeNetwork, PathRequest pathRequest)
 		{
 			var pathfindingNetwork = nodeNetwork.GetPathfindingNetwork(pathRequest.CollisionLayer);
 			var startNode = NodePointer.Dereference(pathRequest.PathStart.Index, pathfindingNetwork);

Source/Code/Pathfindax/Grid/AstarNodeNetwork.cs

@@ -1,12 +1,13 @@
 using System.Collections.Generic;
+using System.Diagnostics;
 using Pathfindax.Nodes;
 
 namespace Pathfindax.Grid
 {
 	/// <summary>
 	/// A node network for <see cref="AstarNode"/>s
 	/// </summary>
-	public class AstarNodeNetwork : INodeNetwork<AstarNode>
+	public class AstarNodeNetwork : IPathfindNodeNetwork<AstarNode>
 	{
 		private Dictionary<PathfindaxCollisionCategory, AstarNode[]> NodeNetworks { get; } = new Dictionary<PathfindaxCollisionCategory, AstarNode[]>();
 		public ISourceNodeNetwork<SourceNode> SourceNodeNetwork { get; }
@@ -24,8 +25,11 @@ public AstarNode[] GetPathfindingNetwork(PathfindaxCollisionCategory collisionCa
 		{
 			if (!NodeNetworks.TryGetValue(collisionCategory, out var nodegrid))
 			{
+
 				var sourceNodeNetwork = SourceNodeNetwork.GetSourceNetwork(collisionCategory);
+				var watch = Stopwatch.StartNew();
 				nodegrid = GenerateNodeGrid(sourceNodeNetwork);
+				Debug.WriteLine($"Generated pathfind nodenetwork in {watch.ElapsedMilliseconds} ms");
 				NodeNetworks.Add(collisionCategory, nodegrid);
 			}
 			return nodegrid;

Source/Code/Pathfindax/Grid/Interfaces/INodeNetwork.cs

@@ -6,7 +6,7 @@ namespace Pathfindax.Grid
 	/// Generic interface for nodenetworks
 	/// </summary>
 	/// <typeparam name="TNode"></typeparam>
-	public interface INodeNetwork<out TNode> : INodeNetwork
+	public interface IPathfindNodeNetwork<out TNode> : INodeNetwork
 		where TNode : INode
 	{
 		TNode[] GetPathfindingNetwork(PathfindaxCollisionCategory collisionCategory);

Source/Code/Pathfindax/Grid/SourceNodeGrid.cs

@@ -63,15 +63,27 @@ private void GenerateConnections(SourceNode[] sourceNodeGrid, PathfindaxCollisio
 			for (var i = 0; i < DefinitionNodeArray.Length; i++)
 			{
 				var definitionNode = DefinitionNodeArray[i];
-				var nodeConnections = new List<NodePointer>();
+
+				var count = 0;
+				foreach (var nodeDefinitionConnection in definitionNode.Connections)
+				{
+					if ((nodeDefinitionConnection.CollisionCategory & collisionCategory) == 0)
+					{
+						count++;
+					}
+				}
+
+				var j = 0;
+				var nodeConnections = new NodePointer[count];
 				foreach (var nodeDefinitionConnection in definitionNode.Connections)
 				{
 					if ((nodeDefinitionConnection.CollisionCategory & collisionCategory) == 0)
 					{
-						nodeConnections.Add(nodeDefinitionConnection.To);
+						nodeConnections[j] = nodeDefinitionConnection.To;
+						j++;
 					}
 				}
-				sourceNodeGrid[i].Connections = nodeConnections.ToArray(); ;
+				sourceNodeGrid[i].Connections = nodeConnections;
 			}
 		}
 
@@ -96,36 +108,41 @@ private int CalculateGridNodeClearances(int index, PathfindaxCollisionCategory c
 			var fromGridCoordinates = DefinitionNodeArray.GetCoordinates(index);
 			for (var i = 0; i < maxClearance; i++)
 			{
-				var nodeConnections = new List<NodeConnection>(1 + i * 16); //Since we know the amount of connections that will likely be in this list we can specify the size beforehand for some extra performance.
-				foreach (var gridNode in GetNodesInArea(fromGridCoordinates.X, fromGridCoordinates.Y + i, i + 1, 1))
+				foreach (var definitionNode in GetNodesInArea(fromGridCoordinates.X, fromGridCoordinates.Y + i, i + 1, 1))
 				{
-					nodeConnections.AddRange(gridNode.Connections);
+					foreach (var nodeConnection in definitionNode.Connections)
+					{
+						if ((nodeConnection.CollisionCategory & collisionCategory) != 0) return i;
+					}
 				}
 
-				foreach (var gridNode in GetNodesInArea(fromGridCoordinates.X + i, fromGridCoordinates.Y, 1, i))
+				foreach (var definitionNode in GetNodesInArea(fromGridCoordinates.X + i, fromGridCoordinates.Y, 1, i))
 				{
-					nodeConnections.AddRange(gridNode.Connections);
-				}
-				foreach (var nodeConnection in nodeConnections)
-				{
-					if ((nodeConnection.CollisionCategory & collisionCategory) != 0) return i;
+					foreach (var nodeConnection in definitionNode.Connections)
+					{
+						if ((nodeConnection.CollisionCategory & collisionCategory) != 0) return i;
+					}
 				}
 			}
 			return maxClearance;
 		}
 
-		private List<DefinitionNode> GetNodesInArea(int gridX, int gridY, int width, int height)
+		private IEnumerable<DefinitionNode> GetNodesInArea(int gridX, int gridY, int width, int height)
 		{
-			var nodes = new List<DefinitionNode>();
-			for (var y = gridY; y < gridY + height; y++)
+			if (gridX >= DefinitionNodeArray.Width || gridY >= DefinitionNodeArray.Height) return new DefinitionNode[0];
+			var gridX2 = MathF.Clamp(gridX + width, 0, DefinitionNodeArray.Width - 1);
+			var gridY2 = MathF.Clamp(gridY + height, 0, DefinitionNodeArray.Height - 1);
+			var definitionNodes = new DefinitionNode[(gridX2 - gridX) * (gridY2 - gridY)];
+			var i = 0;
+			for (var y = gridY; y < gridY2; y++)
 			{
-				for (var x = gridX; x < gridX + width; x++)
+				for (var x = gridX; x < gridX2; x++)
 				{
-					if (x < DefinitionNodeArray.Width && y < DefinitionNodeArray.Height)
-						nodes.Add(DefinitionNodeArray[x, y]);
+					definitionNodes[i] = DefinitionNodeArray[x, y];
+					i++;
 				}
 			}
-			return nodes;
+			return definitionNodes;
 		}
 
 		public DefinitionNode GetNode(float worldX, float worldY)

Source/Code/Pathfindax/Nodes/AstarNode.cs

@@ -29,7 +29,6 @@ public class AstarNode : INode, IHeapItem<AstarNode>
 		public AstarNode(SourceNode sourceNode)
 		{
 			SourceNode = sourceNode;
-			Parent = NodePointer.NullPointer;
 		}
 
 		public int CompareTo(AstarNode other)

Source/Code/Pathfindax/Nodes/NodePointer.cs

@@ -1,5 +1,4 @@
-using Pathfindax.Collections;
-using Pathfindax.Grid;
+using Pathfindax.Grid;
 
 namespace Pathfindax.Nodes
 {
@@ -25,16 +24,6 @@ public static T Dereference<T>(NodePointer p, T[] nodeArray)
 			return nodeArray[p.Index];
 		}
 
-		public static T Dereference<T>(NodePointer p, IReadOnlyArray2D<T> nodeArray)
-		{
-			return nodeArray[p.Index];
-		}
-
-		public static T Dereference<T>(NodePointer p, Array2D<T> nodeArray)
-		{
-			return nodeArray[p.Index];
-		}
-
 		public static DefinitionNode Dereference<T>(NodePointer p, ISourceNodeNetwork<T> nodeArray) 
 			where T : ISourceNode
 		{