예제 #1
0
 private void TryProcessNext()
 {
     if (!_isProcessingPath && _pathRequestQueue.Count > 0)
     {
         _currentPathRequest = _pathRequestQueue.Dequeue();
         _isProcessingPath   = true;
         _pathfinding.StartFindPath(_currentPathRequest.pathStart, _currentPathRequest.pathEnd);
     }
 }
예제 #2
0
 void TryProcessNext()
 {
     if (!isProcessingPath && pathRequestQueue.Count > 0)
     {
         currentPathRequest = pathRequestQueue.Dequeue();
         isProcessingPath   = true;
         _pathfinding.StartFindPath(currentPathRequest._pathStart, currentPathRequest._pathEnd);
     }
 }
 void TryProcessNext()
 {
     if (!isProcessingPath && pathRequestQueue.Count > 0)
     {
         Debug.Log("Processing...>");
         currentPathRequest = pathRequestQueue.Dequeue();
         isProcessingPath   = true;
         pathfinding.StartFindPath(currentPathRequest.pathStart, currentPathRequest.pathEnd);
     }
 }
예제 #4
0
        public void FindPath(PathRequest request, Action <PathResult> callback)
        {
            smooth = request.smooth;
            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;
                        }

                        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.Length > 0;
            }
            callback(new PathResult(waypoints, pathSuccess, request.callback));
        }