public static void RequestPath(PathRequest request) { ThreadStart threadStart = delegate { instance.pathfinding.FindPath(request, instance.FinishedProcessingPath); }; threadStart.Invoke(); }
public static void RequestPath(PathRequest Request) { ThreadStart mPathFinderThread = delegate { mInstance.mPathFinder.FindPath(Request, mInstance.OnFinishedPathFinding); }; mPathFinderThread.Invoke(); }
public void CreateSearcher(int2 start, int2 end) { var pathSearcher = entityManager.CreateEntity(typeof(PathRequest), typeof(Translation), typeof(NavigationCapabilities)); var translation = entityManager.GetComponentData <Translation>(pathSearcher); translation.Value = new float3(start.x, start.y, 0); entityManager.SetComponentData <Translation>(pathSearcher, translation); entityManager.AddBuffer <Waypoint>(pathSearcher); PathRequest pathRequest = new PathRequest { Entity = pathSearcher, start = start, end = end, Destination = NodeToWorldPosition(end), NavigateToBestIfIncomplete = true, NavigateToNearestIfBlocked = true }; entityManager.SetComponentData(pathSearcher, pathRequest); }
public void RequestPath(PathRequest request, bool useInfluenceData, bool needsSmoothing = false) { ThreadPool.QueueUserWorkItem(delegate(object state) { if (needsSmoothing && useInfluenceData) { PathfindingAlgorithms.AStarSearch(_pathfindingGrid, request, FinishedProcessingPath, true, true); } else if (needsSmoothing && !useInfluenceData) { PathfindingAlgorithms.AStarSearch(_pathfindingGrid, request, FinishedProcessingPath, true, false); } else if (!needsSmoothing && useInfluenceData) { PathfindingAlgorithms.AStarSearch(_pathfindingGrid, request, FinishedProcessingPath, false, true); } else if (!needsSmoothing && !useInfluenceData) { PathfindingAlgorithms.AStarSearch(_pathfindingGrid, request, FinishedProcessingPath, false, false); } }); }
public void FindPath(PathRequest request, Action <PathResult> callback) { Stopwatch sw = new Stopwatch(); sw.Start(); Vector3[] waypoints = new Vector3[0]; bool pathSuccess = false; Node startNode = grid.NodeFromWorldPoint(request.pathStart); Node targetNode = grid.NodeFromWorldPoint(request.pathEnd); startNode.parent = startNode; if (startNode.walkable && targetNode.walkable) { Heap <Node> openSet = new Heap <Node>(grid.MaxSize); HashSet <Node> closedSet = new HashSet <Node>(); openSet.Add(startNode); while (openSet.Count > 0) { Node currentNode = openSet.RemoveFirst(); closedSet.Add(currentNode); if (currentNode == targetNode) { sw.Stop(); //print ("Path found: " + sw.ElapsedMilliseconds + " ms"); pathSuccess = true; break; } foreach (Node neighbour in grid.GetNeighbours(currentNode)) { if (!neighbour.walkable || closedSet.Contains(neighbour)) { continue; } float newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour) + neighbour.movementPenalty; if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour)) { neighbour.gCost = newMovementCostToNeighbour; neighbour.hCost = GetDistance(neighbour, targetNode); neighbour.parent = currentNode; if (!openSet.Contains(neighbour)) { openSet.Add(neighbour); } else { openSet.UpdateItem(neighbour); } } } } } if (pathSuccess) { waypoints = RetracePath(startNode, targetNode); pathSuccess = waypoints.Length > 0; } callback(new PathResult(waypoints, pathSuccess, request.callback)); }
public void FindPath(PathRequest request, Action <PathResult> callback) { Stopwatch sw = new Stopwatch(); sw.Start(); Vector3[] waypoints = new Vector3[0]; bool pathSuccess = false; Node2D startNode = grid.NodeFromWorldPoint(request.pathStart); var endNodes = grid.NodesFromWorldBound(request.pathEnd, request.endBounds); UnityEngine.Debug.Log("nodes in end node: " + endNodes.Length); Node2D[] targetNode = endNodes.Where(n => n.walkable).ToArray(); UnityEngine.Debug.Log("usable target nodes: " + targetNode.Length); Node2D endNode = startNode; try { endNode = targetNode[0]; startNode.parent = startNode; if (startNode.walkable && targetNode != null && targetNode.Length > 0) { Heap <Node2D> openSet = new Heap <Node2D>(grid.MaxSize); HashSet <Node2D> closedSet = new HashSet <Node2D>(); openSet.Add(startNode); while (openSet.Count > 0) { Node2D currentNode = openSet.RemoveFirst(); closedSet.Add(currentNode); if (targetNode.Contains(currentNode)) { sw.Stop(); UnityEngine.Debug.Log("Path found: " + sw.ElapsedMilliseconds + " ms"); pathSuccess = true; endNode = currentNode; break; } foreach (Node2D neighbour in grid.GetNeighbours(currentNode)) { if (!neighbour.walkable || closedSet.Contains(neighbour)) { continue; } int newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour) + neighbour.movementPenalty; if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour)) { neighbour.gCost = newMovementCostToNeighbour; neighbour.hCost = GetDistance(neighbour, targetNode); neighbour.parent = currentNode; if (!openSet.Contains(neighbour)) { openSet.Add(neighbour); } else { openSet.UpdateItem(neighbour); } } } } } } catch (Exception e) { UnityEngine.Debug.Log("No usable end nodes"); callback(new PathResult(waypoints, pathSuccess, request.callback)); } if (pathSuccess) { waypoints = RetracePath(startNode, endNode); pathSuccess = waypoints.Length > 0; } callback(new PathResult(waypoints, pathSuccess, request.callback)); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { //BufferAccessor<Cell> accessor = this.GridChunks[0].GetBufferAccessor(this.CellTypeRO); //DynamicBuffer<Cell> grid = accessor[0].Reinterpret<Cell>(); int size = DimX * DimY; BufferAccessor <Waypoint> Waypoints = chunk.GetBufferAccessor(WaypointChunkBuffer); NativeArray <PathRequest> PathRequests = chunk.GetNativeArray(PathRequestsChunkComponent); NativeArray <Translation> Translations = chunk.GetNativeArray(TranslationsChunkComponent); NativeArray <NavigationCapabilities> NavigationCapabilities = chunk.GetNativeArray(NavigationCapabilitiesChunkComponent); NativeArray <float> CostSoFar = new NativeArray <float>(size * chunk.Count, Allocator.Temp); NativeArray <int2> CameFrom = new NativeArray <int2>(size * chunk.Count, Allocator.Temp); NativeMinHeap OpenSet = new NativeMinHeap((Iterations + 1) * Neighbors.Length * chunk.Count, Allocator.Temp); for (int i = chunkIndex; i < chunk.Count; i++) { NativeSlice <float> costSoFar = CostSoFar.Slice(i * size, size); NativeSlice <int2> cameFrom = CameFrom.Slice(i * size, size); int openSetSize = (Iterations + 1) * NeighborCount; NativeMinHeap openSet = OpenSet.Slice(i * openSetSize, openSetSize); PathRequest request = PathRequests[i]; // Clear our shared data //var buffer = costSoFar.GetUnsafePtr(); //UnsafeUtility.MemClear(buffer, (long)costSoFar.Length * UnsafeUtility.SizeOf<float>()); //openSet.Clear(); Translation currentPosition = Translations[i]; NavigationCapabilities capability = NavigationCapabilities[i]; // cache these as they're used a lot int2 start = currentPosition.Value.xy.FloorToInt(); int2 goal = request.end; DynamicBuffer <float3> waypoints = Waypoints[i].Reinterpret <float3>(); waypoints.Clear(); // Special case when the start is the same point as the goal if (start.Equals(goal)) { // We just set the destination as the goal, but need to get the correct height int gridIndex = this.GetIndex(goal); Cell cell = CellArray[gridIndex]; float3 point = new float3(request.Destination.x, request.Destination.y, cell.Height); waypoints.Add(point); continue; } var stash = new InstanceStash { Grid = CellArray, CameFrom = cameFrom, CostSoFar = costSoFar, OpenSet = openSet, Request = request, Capability = capability, CurrentPosition = currentPosition, Start = start, Goal = goal, Waypoints = waypoints, }; if (this.ProcessPath(ref stash)) { this.ReconstructPath(stash); } } CostSoFar.Dispose(); CameFrom.Dispose(); OpenSet.Dispose(); }
public void FindPath(PathRequest request, Action <PathResult> callback) { Stopwatch sw = new Stopwatch(); sw.Start(); Vector3[] waypoints = new Vector3[0]; bool pathSucces = false; Node startNode = _grid.WorldPositionToNode(request.start); Node targetNode = _grid.WorldPositionToNode(request.end); if (startNode.IsWalkable && targetNode.IsWalkable) { MinHeap <Node> openSet = new MinHeap <Node>(_grid.MaxSize); HashSet <Node> closedSet = new HashSet <Node>(); openSet.Add(startNode); while (openSet.Count > 0) { Node current = openSet.RemoveFirst(); closedSet.Add(current); if (current == targetNode) { sw.Stop(); UnityEngine.Debug.Log("Path found " + sw.ElapsedMilliseconds + " ms"); pathSucces = true; break; } foreach (Node neighbour in current.Neighbours) { if (neighbour == null || !neighbour.IsWalkable || closedSet.Contains(neighbour)) { continue; } int newMovementCost = current.GCost + GetDistance(current, neighbour); if (newMovementCost < neighbour.GCost || !openSet.Contains(neighbour)) { neighbour.GCost = newMovementCost; neighbour.HCost = GetDistance(neighbour, targetNode); neighbour.Parent = current; if (!openSet.Contains(neighbour)) { openSet.Add(neighbour); } else { openSet.UpdateItem(neighbour); } } } } } if (pathSucces) { waypoints = RetracePath(startNode, targetNode); } callback(new PathResult(waypoints, pathSucces, request.callback)); }
/// <summary> /// A* pathfinding algorithm. /// </summary> /// <param name="request">PathRequest object.</param> /// <param name="callback">Callback object.</param> public void FindPath(PathRequest request, Action <PathResult> callback) { Stopwatch sw = new Stopwatch(); sw.Start(); List <Node> waypoints = new List <Node>(); bool pathSuccess = false; Node startNode = _aGrid.getNode(request.pathStart); Node targetNode = _aGrid.getNode(request.pathEnd); startNode.parent = startNode; if (targetNode.GetState() == Enums.TileState.FREE) { Heap <Node> openSet = new Heap <Node>(_aGrid.MaxSize); HashSet <Node> closedSet = new HashSet <Node>(); openSet.Add(startNode); while (openSet.Count > 0) { Node currentNode = openSet.RemoveFirst(); closedSet.Add(currentNode); if (currentNode == targetNode) { sw.Stop(); //print ("Path found: " + sw.ElapsedMilliseconds + " ms"); pathSuccess = true; break; } foreach (Node neighbour in _aGrid.GetNeighbours(currentNode)) { if (neighbour.GetState() != Enums.TileState.FREE || closedSet.Contains(neighbour)) { continue; } int newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour) + neighbour.movementPenalty; if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour)) { neighbour.gCost = newMovementCostToNeighbour; neighbour.hCost = GetDistance(neighbour, targetNode); neighbour.parent = currentNode; if (!openSet.Contains(neighbour)) { openSet.Add(neighbour); } else { openSet.UpdateItem(neighbour); } } } } } if (pathSuccess) { waypoints = RetracePath(startNode, targetNode); pathSuccess = waypoints.Count > 0; } callback(new PathResult(waypoints, pathSuccess, request.parameter, request.callback)); }