C# Heap.Pop方法代码示例

        public static void Dijkstra(List<Tuple<int, int>>[] adj, int source, out int[] dist, out int[] pred)
        {
            int inf = int.MaxValue;
            int N = adj.Length;
            dist = new int[N];
            pred = new int[N];
            for (int i = 0; i < N; i++)
                dist[i] = inf;
            dist[source] = 0;

            Heap<int, int> heap = new Heap<int, int>(N, true);
            heap.Push(source, 0);

            while (!heap.IsEmpty())
            {
                int u = heap.PeekData();
                if (dist[u] != heap.Pop().Priority) continue;
                foreach (var tuple in adj[u])
                {
                    int v = tuple.Item1;
                    int uvWeight = tuple.Item2;
                    if (dist[v] > dist[u] + uvWeight)
                    {
                        dist[v] = dist[u] + uvWeight;
                        pred[v] = u;
                        heap.Push(v, dist[v]);
                    }
                }
            }
        }

 //Calculates the path from a start to finish using the A* Pathfinding algorithm
 IEnumerator CalculatePath(Vector3 startPosition, Vector3 endPosition)
 {
     Vector3[] waypoints = new Vector3[0];
     bool success = false;
     Node startNode = grid.NodeFromPoint(startPosition);//Creates a node from the point
     Node endNode = grid.NodeFromPoint(endPosition);
     if (endNode.Walkable ) { //See if the end node is a walkable object or it is a resource
         Heap<Node> open = new Heap<Node> (grid.MaxGridSize);
         HashSet<Node> closed = new HashSet<Node> ();
         open.Add (startNode);
         while (open.Count > 0) {
             Node current = open.Pop ();//Removes first node in heap and re-sorts it
             closed.Add (current);//Adds the node to the closed list
             if (current == endNode) {
                 success = true;
                 break;
             }
             foreach (Node neighbour in grid.GetNeighbours(current)) {//Traverses through the neighbours of the nodes
                 if (!neighbour.Walkable || closed.Contains (neighbour)) {
                     continue;
                 }
                 int costToNeighbour = current.G + GetDist (current, neighbour);
                 if (costToNeighbour < neighbour.G || !open.Contains (neighbour)) {//If the cost to neighbour < neighbouring g value
                     neighbour.G = costToNeighbour;
                     neighbour.H = GetDist (neighbour, endNode);
                     neighbour.Parent = current;
                     if (!open.Contains (neighbour)) {
                         open.Add (neighbour); //Adds the neighbour to the heap
                     }
                     else{
                         open.UpdateItem(neighbour); // Resort the heap to include the neighbour
                     }
                 }
             }
         }
     }
     yield return null;//Makes wait for one frame
     if (success) // If successfully calculates path
     {
         waypoints = ReversePath(startNode, endNode); //reverse path since path is stored from end to beginning
     }
     request.FinishedProcessing(waypoints, success);
 }

        static void Main(string[] args)
        {
            Heap test = new Heap();
           
            test.Push(120);
            test.Push(230);
            test.Push(610);
            test.Push(20);
            test.Push(620);


            //test.Push(4);
            //test.Push(50);
            Console.WriteLine(test.Top());
           
            test.Pop();
            
           Console.WriteLine(test.Top());
            
            
            Console.ReadKey();

        }

		// Range: -1 Access: 0 Flags: ( 0, 4, 255 )
		public static dynamic AStar( dynamic start = null, dynamic end = null, Mob_Living_SimpleAnimal atom = null, System.Reflection.MethodInfo dist = null, dynamic maxnodes = null, dynamic maxnodedepth = null, dynamic mintargetdist = null, System.Reflection.MethodInfo adjacent = null, Ent_Item_Weapon_Card_Id id = null, dynamic exclude = null, bool? simulated_only = null ) {
			Heap open = null;
			ByTable closed = null;
			ByTable path = null;
			dynamic cur = null;
			bool? closeenough = null;
			dynamic L = null;
			dynamic T = null;
			dynamic newg = null;
			PathNode PN = null;
			dynamic T2 = null;
			double? i = null;
			if ( maxnodedepth == null ) {
				maxnodedepth = 30;
			}
			if ( adjacent == null ) {
				adjacent = typeof(Tile).GetMethod( "reachableAdjacentTurfs" );
			}
			if ( id == null ) {
				id = null;
			}
			if ( exclude == null ) {
				exclude = null;
			}
			if ( simulated_only == null ) {
				simulated_only = true;
			}
			if ( Lang13.Bool( maxnodes ) ) {
				if ( Lang13.Double( Lang13.call( Lang13.bindf( start, dist ), end ) ) > Lang13.Double( maxnodes ) ) {
					return 0;
				}
				maxnodedepth = maxnodes;
			}
			open = new Heap( typeof(GlobalFuncs).GetMethod( "HeapPathWeightCompare" ) );
			closed = new ByTable();
			path = null;
			start = GlobalFuncs.get_turf( start );
			if ( !Lang13.Bool( start ) ) {
				return 0;
			}
			open.Insert( new PathNode( start, null, false, Lang13.call( Lang13.bindf( start, dist ), end ), false ) );
			while (!open.IsEmpty() && !( path != null )) {
				cur = open.Pop();
				closed.Add( cur.source );
				closeenough = null;
				if ( Lang13.Bool( mintargetdist ) ) {
					closeenough = Lang13.Double( Lang13.call( Lang13.bindf( cur.source, dist ), end ) ) <= Lang13.Double( mintargetdist );
				}
				if ( Lang13.Bool( maxnodedepth ) && Lang13.Double( cur.nt ) > Lang13.Double( maxnodedepth ) ) {
					continue;
				}
				if ( cur.source == end || closeenough == true ) {
					path = new ByTable();
					path.Add( cur.source );
					while (Lang13.Bool( cur.prevNode )) {
						cur = cur.prevNode;
						path.Add( cur.source );
					}
					break;
				}
				L = Lang13.call( Lang13.bindf( cur.source, adjacent ), atom, id, simulated_only );
				T = null;
				foreach (dynamic _a in L ) {
					T = _a;
					if ( T == exclude || closed.contains( T ) ) {
						continue;
					}
					newg = cur.g + Lang13.call( Lang13.bindf( cur.source, dist ), T );
					if ( !Lang13.Bool( T.PNode ) ) {
						open.Insert( new PathNode( T, cur, Lang13.Bool( newg ), Lang13.call( Lang13.bindf( T, dist ), end ), Lang13.Bool( cur.nt + 1 ) ) );
					} else if ( Lang13.Double( newg ) < Lang13.Double( T.PNode.g ) ) {
						T.PNode.prevNode = cur;
						T.PNode.g = newg;
						((dynamic)T.PNode).calc_f();
						T.PNode.nt = cur.nt + 1;
						open.ReSort( T.PNode );
					}
				};
			}
			PN = null;
			foreach (dynamic _b in open.L ) {
				if ( !( _b is PathNode ) ) {
					continue;
				}
				PN = _b;
				PN.source.PNode = null;
			};
			T2 = null;
			foreach (dynamic _c in closed ) {
				T2 = _c;
				T2.PNode = null;
			};
			if ( path != null ) {
				i = null;
				i = 1;
				while (( i ??0) <= path.len / 2) {
					path.Swap( ((int)( i )), ((int)( path.len - ( i ??0) + 1 )) );
					i++;
				}
//.........这里部分代码省略.........

    /// <summary>
    /// Finds the shortest path from the start node to the goal node
    /// </summary>
    /// <param name="startPosition">Start position</param>
    /// <param name="goalPosition">Goal position</param>
    /// <param name="startMeshNode">Start mesh node</param>
    /// <param name="goalMeshNode">Goal mesh node</param>
    public List<NavmeshPolygon> FindPath(Vector3 startPosition, Vector3 goalPosition, NavmeshPolygon startPolygon, NavmeshPolygon goalPolygon)
    {
        //Debug.Log("AStar.FindPath");
        //Debug.Log("startPosition == " + startPosition);
        //Debug.Log("goalPosition == " + goalPosition);
        StartPosition = startPosition;
        GoalPosition = goalPosition;

        GoalNode = new AStarNode(this, null, goalPolygon, 0);
        StartNode = new AStarNode(this, null, startPolygon, 0);

        Heap openList = new Heap();
        Heap closedList = new Heap();
        List<AStarNode> solution = new List<AStarNode>();
        List<AStarNode> successors = new List<AStarNode>();

        int printed = 0;
        openList.Add(StartNode);
        while (openList.Count > 0) {
            //Debug.Log("AStar:main loop");
            // Get the node with the lowest TotalSum
            AStarNode nodeCurrent = (AStarNode)openList.Pop();
            if (printed < 1000){
                //Debug.Log("Current polygon: " + nodeCurrent.NavmeshPolygon.name + " - " + nodeCurrent.TotalCost);
                printed++;
            }

            // If the node is the goal copy the path to the solution array
            if (GoalNode.Equals(nodeCurrent)) {
                //Debug.Log("AStar:finish loop");
                while (nodeCurrent != null) {
                    solution.Insert(0, nodeCurrent);
                    nodeCurrent = nodeCurrent.Parent;
                }

                //convert solution
                //Debug.Log("Path found");
                return solution.ConvertAll(an => an.NavmeshPolygon);
            }

            // Get successors to the current node
            successors.Clear();
            nodeCurrent.GetSuccessors(successors);
            foreach (AStarNode nodeSuccessor in successors) {
                //Debug.Log("AStar:successor loop");
                // Test if the currect successor node is on the open list, if it is and
                // the TotalSum is higher, we will throw away the current successor.
                //Debug.Log("AStarNode nodeOpen");
                AStarNode nodeOpen;
                if (openList.Contains(nodeSuccessor)) {
                    //Debug.Log("openList check: nodeSuccessor (" + nodeSuccessor.NavmeshPolygon.name + ") - " + nodeSuccessor.TotalCost);
                    //Debug.Log("openList contains nodeSuccessor");
                    //Debug.Log("nodeOpen = (AStarNode)openList[openList.IndexOf(nodeSuccessor)];");
                    nodeOpen = (AStarNode)openList.GetEqual(nodeSuccessor);
                    //Debug.Log("openList check: nodeOpen (" + nodeOpen.NavmeshPolygon.name + ") - " + nodeOpen.TotalCost);
                    //Debug.Log("if ((nodeOpen != null) && (nodeSuccessor.TotalCost > nodeOpen.TotalCost))");
                    if ((nodeOpen != null) && (nodeSuccessor.TotalCost > nodeOpen.TotalCost)){
                        //Debug.Log("continue;");
                        //Debug.Log("openList check: continued");
                        continue;
                    } else {
                        //Debug.Log("openList check: not continued");
                    }

                }

                // Test if the currect successor node is on the closed list, if it is and
                // the TotalSum is higher, we will throw away the current successor.
                //Debug.Log("AStarNode nodeClosed;");
                AStarNode nodeClosed;
                //Debug.Log("if (closedList.Contains(nodeSuccessor)) {");
                if (closedList.Contains(nodeSuccessor)) {
                    //Debug.Log("closedList check: nodeSuccessor (" + nodeSuccessor.NavmeshPolygon.name + ") - " + nodeSuccessor.TotalCost);
                    //Debug.Log("closedList contains nodeSuccessor");
                    //Debug.Log("nodeClosed = (AStarNode)closedList[closedList.IndexOf(nodeSuccessor)];");
                    nodeClosed = (AStarNode)closedList.GetEqual(nodeSuccessor);
                    //Debug.Log("closedList check: nodeClosed (" + nodeClosed.NavmeshPolygon.name + ") - " + nodeClosed.TotalCost);
                    //Debug.Log("if ((nodeClosed != null) && (nodeSuccessor.TotalCost > nodeClosed.TotalCost))");
                    if ((nodeClosed != null) && (nodeSuccessor.TotalCost > nodeClosed.TotalCost)){
                        //Debug.Log("continue;");
                        continue;
                    }
                }

                // Remove the old successor from the open list
                //Debug.Log("openList.Remove(nodeSuccessor);");
                openList.Remove(nodeSuccessor);

                // Remove the old successor from the closed list
                //Debug.Log("closedList.Remove(nodeSuccessor);");
                closedList.Remove(nodeSuccessor);

                // Add the current successor to the open list
//.........这里部分代码省略.........

    IEnumerator FindPath(Vector3 startPos, Vector3 targetPos)
    {
        Node startNode = NodeGrid.NodeFromWorldPoint(startPos);
        Node targetNode = NodeGrid.NodeFromWorldPoint(targetPos);

        Vector3[] waypoints = new Vector3[0];
        bool pathSuccess = false;
        if (startNode.Walkable && targetNode.Walkable)
        {
            Heap<Node> openSet = new Heap<Node>(NodeGrid.MaxSize);
            HashSet<Node> closedSet = new HashSet<Node>();
            openSet.Push(startNode);

            while (openSet.Count > 0)
            {
                Node currentNode = openSet.Pop();
                closedSet.Add(currentNode);

                if (currentNode == targetNode)
                {
                    pathSuccess = true;

                    break;
                }

                foreach (Node neighbour in NodeGrid.GetNeighbours(currentNode))
                {
                    if (!neighbour.Walkable || closedSet.Contains(neighbour))
                    {
                        continue;
                    }

                    int newMovementCostToNeighbor = currentNode.gCost + GetDistance(currentNode, neighbour) + neighbour.MovementPenalty;
                    if (newMovementCostToNeighbor < neighbour.gCost || !openSet.Contains(neighbour))
                    {
                        neighbour.gCost = newMovementCostToNeighbor;
                        neighbour.hCost = GetDistance(neighbour, targetNode);
                        neighbour.Parent = currentNode;
                    }

                    if (!openSet.Contains(neighbour))
                    {
                        openSet.Push(neighbour);
                    }
                    else
                    {
                        openSet.UpdateItem(neighbour);
                    }
                }
            }
        }
        yield return null;
        if (pathSuccess)
        {
            waypoints = RetracePath(startNode, targetNode);
            if(waypoints == null || waypoints.Length == 0)
            {
                waypoints = new Vector3[1];
                waypoints[0] = targetNode.WorldPosition;
            }
        }
        RequestManager.FinishedProcessingPath(waypoints, pathSuccess);
    }