C# Heap.size方法代码示例

    public List<Portal> FindPath()
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        bool success = false;
        CreateStartNode(startPos);
        CreateEndNode(targetPos);
        if (startPortal == null || endPortal == null)
            return null;

        Heap<Portal> frontier = new Heap<Portal>(portals.Count+2);
        HashSet<Portal> visited = new HashSet<Portal>();
        frontier.Add(startPortal);

        while(frontier.size() > 0){
            Portal current = frontier.RemoveFirst();
            visited.Add(current);

            if (current == endPortal){
                sw.Stop();
                success = true;
                print("Path found in: "+ sw.ElapsedMilliseconds + " ms");
                break;
            }

            foreach(KeyValuePair<Portal, int> nb in current.GetNeighbours()){
                if (visited.Contains(nb.Key)){
                    continue;
                }

                int newDistance = current.gCost + nb.Value;
                if (newDistance < nb.Key.gCost || !frontier.Contains(nb.Key)){
                    nb.Key.gCost = newDistance;
                    nb.Key.hCost = CalcDistance(nb.Key);
                    nb.Key.SetParent(current);

                    if (!frontier.Contains(nb.Key)){
                        frontier.Add(nb.Key);
                    }
                }
            }
        }
        if (success){
            return RetracePath();
        }
        else return null;
    }

    /// <summary>
    /// Finds the connections.
    /// </summary>
    /// <param name="start">Start.</param>
    public void FindConnections(Node start)
    {
        Tile startTile = TileFromPosition (start.center);
        Dictionary<Tile, Node> targets = new Dictionary<Tile, Node> ();
        foreach (KeyValuePair<Vector3, Node> kv in nodes) {
            if (kv.Value != start)
                targets.Add (TileFromPosition (kv.Key), kv.Value);
        }

        if (startTile.cost == 255)
            return;

        Heap<Tile> frontier = new Heap<Tile> (sizeX * sizeY);
        HashSet<Tile> visited = new HashSet<Tile> ();
        frontier.Add (startTile);

        while (frontier.size () > 0) {
            Tile current = frontier.RemoveFirst ();
            visited.Add (current);

            Node intranode = null;
            targets.TryGetValue (current, out intranode);
            if (intranode != null && !intranode.ConnectedTo (start)) {
                Node.Connect (start, intranode, current.distance);
            }

            foreach (Tile neighbour in GetNeighbours(current)) {
                if (neighbour == null || neighbour.cost == 255 || visited.Contains (neighbour)) {
                    continue;
                }
                neighbour.distance = current.distance + 1;
                if (!frontier.Contains (neighbour))
                    frontier.Add (neighbour);
            }
        }
    }

    void FindConnections(Portal portal, Cluster cluster, bool oriented)
    {
        Heap<Tile> queue = new Heap<Tile> (Cluster.size * Cluster.size);
        HashSet<Tile> visited = new HashSet<Tile> ();
        int pcount = cluster.GetPortals ().Count - 1;

        foreach (Tile t in portal.GetPortalTiles()) {
            t.distance = 0;
            queue.Add (t);
        }

        while (queue.size () > 0 && pcount > 0) {
            Tile current = queue.RemoveFirst ();
            visited.Add (current);

            Portal newPortal = current.GetPortal ();
            if (newPortal != null && newPortal != portal) {
                if (!portal.ConnectedTo (newPortal) && current.distance>0) {
                    if (!oriented) {
                        Portal.Connect (portal, newPortal, current.distance);
                    } else {
                        portal.AddNeighbour (newPortal, current.distance);
                    }
                    pcount--;
                }
            }

            foreach (Tile nb in cluster.GetNeighbours(current)) {
                if (nb == null || nb.cost == 255 || visited.Contains (nb))
                    continue;

                nb.distance = current.distance + 1;
                if (!queue.Contains (nb))
                    queue.Add (nb);
            }
        }
    }

    /// <summary>
    /// Generate the distance values and the relative flow vector.
    /// </summary>
    /// <param name="start">Start.</param>
    public void FloodFill(Vector3 start)
    {
        for (int x = 0; x < sizeX; x++) {
            for (int y = 0; y < sizeY; y++) {
                grid [x, y].distance = int.MaxValue;
            }
        }

        Tile startTile = TileFromPosition (start);
        if (startTile.cost == 255)
            return;

        startTile.distance = 0;
        Heap<Tile> queue = new Heap<Tile> (sizeX * sizeY);
        HashSet<Tile> visited = new HashSet<Tile> ();

        queue.Add (startTile);

        while (queue.size () > 0) {
            Tile t = queue.RemoveFirst ();
            visited.Add (t);

            Tile[] neighbours = GetNeighbours (t);
            foreach (Tile nb in neighbours) {
                if (nb == null || nb.cost == 255 || visited.Contains (nb))
                    continue;

                nb.distance = t.distance + 1;
                if (!queue.Contains (nb))
                    queue.Add (nb);
            }

            for (int i = 0; i < 4; i++) {
                if (neighbours [i] == null || neighbours [i].cost == 255)
                    neighbours [i] = t;
            }
            float flowx = neighbours [2].distance - neighbours [3].distance;
            float flowy = neighbours [0].distance - neighbours [1].distance;
            t.flow = new Vector2 (flowx, flowy).normalized;
        }
    }