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));
}
