/// <summary> /// Returns a preconfigured <see cref="Array2D{TItem}"/> which can be used to make a <see cref="DefinitionNodeGrid"/> /// </summary> /// <param name="width"></param> /// <param name="height"></param> /// <param name="generateNodeGridConnections"></param> /// <returns></returns> public static Array2D <DefinitionNode> GeneratePreFilledArray(GenerateNodeGridConnections generateNodeGridConnections, int width, int height) { var array = new Array2D <DefinitionNode>(width, height); for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { var worldPosition = new Vector2(x, y); var i = width * y + x; var node = new DefinitionNode(i, worldPosition, 1); array[x, y] = node; } } if (generateNodeGridConnections != GenerateNodeGridConnections.None) { for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { var node = array[x, y]; var neighbours = GetNeighbours(array, x, y, generateNodeGridConnections); foreach (var neighbour in neighbours) { node.Connections.Add(new NodeConnection(neighbour)); } } } } return(array); }
private static float GetDistance(DefinitionNode sourceNodeA, DefinitionNode sourceNodeB) { var dstX = Math.Abs(sourceNodeA.Position.X - sourceNodeB.Position.X); var dstY = Math.Abs(sourceNodeA.Position.Y - sourceNodeB.Position.Y); return(dstY + dstX); }
public DefinitionNode AddNode(Vector2 position, float movementPenalty = 1f) { var definitionNode = new DefinitionNode(DefinitionNodes.Count, position, movementPenalty); DefinitionNodes.Add(definitionNode); return(definitionNode); }
private static float GetDistance(DefinitionNode dijkstraNodeA, DefinitionNode dijkstraNodeB) { var dstX = Math.Abs(dijkstraNodeA.Position.X - dijkstraNodeB.Position.X); var dstY = Math.Abs(dijkstraNodeA.Position.Y - dijkstraNodeB.Position.Y); return(dstY + dstX); }
public int AddNode(Vector2 position, float movementPenalty = 1f) { var index = NodeArray.Length; var definitionNode = new DefinitionNode(position, movementPenalty); NodeArray = NodeArray.Append(definitionNode); return(index); }
private static object[] GeneratePathLengthTestCase(int gridWidth, int gridHeight, int[] path, float expectedPathLength) { var nodes = new Array2D <DefinitionNode>(gridWidth, gridHeight); for (var y = 0; y < gridHeight; y++) { for (var x = 0; x < gridWidth; x++) { nodes[x, y] = new DefinitionNode(new Vector2(x, y)); } } return(new object[] { nodes.Array, path, expectedPathLength }); }
public static string GenerateFullName(DefinitionNode node) { var fullName = new System.Text.StringBuilder(); while (node != null) { fullName.Insert(0, node.name + '.'); node = node.parent; } fullName.Length -= 1; return(fullName.ToString()); }
private void GetTreeData(MainWinVM mainWinVM) { PLMProductService service = (PLMProductService)CatiaService.catia.ActiveEditor.GetService("PLMProductService"); VPMRootOccurrence vpmRootOcc = service.RootOccurrence; VPMReference vpmRefOnRoot = vpmRootOcc.ReferenceRootOccurrenceOf; // get all children of the root VPMInstances vpmInstsL1 = vpmRefOnRoot.Instances; DefinitionNode rootNode = new DefinitionNode(); rootNode.Name = vpmRefOnRoot.GetAttributeValue("V_Name"); mainWinVM.DefinitionNodes = new ObservableCollection <DefinitionNode>(); mainWinVM.DefinitionNodes.Add(rootNode); Recursion(vpmInstsL1, rootNode); }
/// <summary> /// Calculates the clearances up to a maximum <paramref name="maxClearance"/> /// </summary> /// <param name="definitionNode"></param> /// <param name="collisionCategory"></param> /// <param name="maxClearance"></param> /// <returns></returns> public float CalculateGridNodeClearances(DefinitionNode definitionNode, PathfindaxCollisionCategory collisionCategory, int maxClearance) { var fromCoordinates = new Point2((int)definitionNode.Position.X, (int)definitionNode.Position.Y); for (var checkClearance = 0; checkClearance < maxClearance; checkClearance++) { var nextClearanceIsBlocked = false; for (var x = 0; x < checkClearance + 1; x++) { switch (IsBlocked(x + fromCoordinates.X, checkClearance + fromCoordinates.Y, collisionCategory, fromCoordinates)) { case BlockType.Current: return(checkClearance); case BlockType.Next: nextClearanceIsBlocked = true; break; } } for (var y = 0; y < checkClearance; y++) { switch (IsBlocked(checkClearance + fromCoordinates.X, y + fromCoordinates.Y, collisionCategory, fromCoordinates)) { case BlockType.Current: return(checkClearance); case BlockType.Next: nextClearanceIsBlocked = true; break; } } if (nextClearanceIsBlocked) { var isBlocked = true; for (var i = 0; i < definitionNode.Connections.Count; i++) { if ((definitionNode.Connections[i].CollisionCategory & collisionCategory) == 0) { isBlocked = false; } } return(isBlocked ? checkClearance : checkClearance + 1); } } return(maxClearance); }
private void Recursion(PLMEntities vpmInsts, DefinitionNode node) { ObservableCollection <DefinitionNode> definitionNodes = new ObservableCollection <DefinitionNode>(); for (int i = 1; i < vpmInsts.Count + 1; i++) { DefinitionNode definitionNode = new DefinitionNode(); VPMInstance vpmInstL1 = vpmInsts.Item(i) as VPMInstance; VPMReference vpmRefInstL1 = vpmInstL1.ReferenceInstanceOf; definitionNode.Name = vpmRefInstL1.GetAttributeValue("V_Name"); definitionNodes.Add(definitionNode); VPMInstances vpmInstsL2 = vpmRefInstL1.Instances; if (vpmInstsL2.Count > 0) { Recursion(vpmInstsL2, definitionNode); } else { VPMRepInstances vpmRefInstsL3 = vpmRefInstL1.RepInstances; ObservableCollection <DefinitionNode> nodes = new ObservableCollection <DefinitionNode>(); for (int k = i; k < vpmRefInstsL3.Count + 1; k++) { VPMRepInstance vpmRepInstL3 = vpmRefInstsL3.Item(k) as VPMRepInstance; VPMRepReference vpmRepRefL3 = vpmRepInstL3.ReferenceInstanceOf; DefinitionNode oneNode = new DefinitionNode(); oneNode.Name = vpmRepRefL3.GetAttributeValue("V_Name"); nodes.Add(oneNode); } definitionNode.Children = nodes; } } node.Children = definitionNodes; }
public IDefinitionNodeNetwork GenerateGrid2D() { const int width = 1000; const int height = 1000; var random = new Random(); var dictionary = new Dictionary <DelaunayNode, DefinitionNode>(); var nodeNetwork = new DefinitionNodeNetwork(new Vector2(1, 1)); for (var i = 0; i < 100; i++) { var node = new DefinitionNode(i, new Vector2(random.Next(0, width), random.Next(0, height))); var defaultNode = new DelaunayNode(new Vector2(node.Position.X, node.Position.Y)); dictionary.Add(defaultNode, node); nodeNetwork.DefinitionNodes.Add(node); } var graph = new Graph <DelaunayNode>(); graph.Nodes.AddRange(dictionary.Keys); graph.Triangulate(); foreach (var graphLink in graph.Links.GroupBy(x => x.From)) { var from = dictionary[graphLink.Key]; var connections = new List <DefinitionNode>(); foreach (var link in graphLink) { var to = dictionary[link.To]; connections.Add(to); } for (var i = 0; i < connections.Count; i++) { var to = connections[i]; from.Connections.Add(new NodeConnection(to.Index)); to.Connections.Add(new NodeConnection(from.Index)); } } return(nodeNetwork); }
/// <summary> /// Returns a preconfigured <see cref="Array2D{DefinitionNode}"/> which can be used to make a <see cref="DefinitionNodeGrid"/> /// </summary> /// <param name="width"></param> /// <param name="height"></param> /// <param name="generateNodeGridConnections"></param> /// <param name="nodeGridCollisionLayers"></param> /// <param name="crossCorners"></param> /// <returns></returns> public Array2D <DefinitionNode> GeneratePreFilledArray(GenerateNodeGridConnections generateNodeGridConnections, int width, int height, NodeGridCollisionMask nodeGridCollisionLayers = null, bool crossCorners = false) { var array = new Array2D <DefinitionNode>(width, height); for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { var worldPosition = new Vector2(x, y); if (generateNodeGridConnections == GenerateNodeGridConnections.None) { array[x, y] = new DefinitionNode(worldPosition); } else { var connections = GetNeighbours(width, height, x, y, generateNodeGridConnections, nodeGridCollisionLayers, crossCorners); array[x, y] = new DefinitionNode(worldPosition, connections: connections); } } } return(array); }
public PathRequest <TPath> RequestPath(DefinitionNode start, DefinitionNode end, PathfindaxCollisionCategory collisionLayer = PathfindaxCollisionCategory.None, byte agentSize = 1) { return(PathRequest.Create(this, start, end, collisionLayer, agentSize)); }
/// <summary> /// Calculates the <see cref="NodeConnection"/>s for the <paramref name="definitionNode"/> /// </summary> /// <param name="tilemapColliderWithBodies"></param> /// <param name="definitionNode"></param> /// <param name="definitionNodeGrid"></param> public void CalculateGridNodeCollision(TilemapColliderWithBody[] tilemapColliderWithBodies, DefinitionNode definitionNode, DefinitionNodeGrid definitionNodeGrid) { var nodeGridCoordinates = new Point2((int)definitionNode.Position.X, (int)definitionNode.Position.Y); CalculateNodeCollisionCategories(nodeGridCoordinates.X, nodeGridCoordinates.Y, tilemapColliderWithBodies); if (nodeGridCoordinates.X == 0 || nodeGridCoordinates.Y == 0 || nodeGridCoordinates.X == definitionNodeGrid.NodeGrid.Width - 1 || nodeGridCoordinates.Y == definitionNodeGrid.NodeGrid.Height - 1) { for (var index = 1; index < _nodeCollisions.Length; index++) { var collisionCategory = _nodeCollisions[index]; if (collisionCategory.X >= 0 && collisionCategory.Y >= 0 && collisionCategory.X < definitionNodeGrid.NodeGrid.Width && collisionCategory.Y < definitionNodeGrid.NodeGrid.Height) { //TODO provide option to exclude diagonal neighbours. var toNode = definitionNodeGrid.NodeGrid[collisionCategory.X, collisionCategory.Y]; definitionNode.Connections.Add(new NodeConnection(toNode.Index, collisionCategory.PathfindaxCollisionCategory | _nodeCollisions[0].PathfindaxCollisionCategory)); } } } else { for (var index = 1; index < _nodeCollisions.Length; index++) { var collisionCategory = _nodeCollisions[index]; //TODO provide option to exclude diagonal neighbours. var toNode = definitionNodeGrid.NodeGrid[collisionCategory.X, collisionCategory.Y]; definitionNode.Connections.Add(new NodeConnection(toNode.Index, collisionCategory.PathfindaxCollisionCategory | _nodeCollisions[0].PathfindaxCollisionCategory)); } } }