Exemple #1
0
    private Node GetNodeFromNodeClusterAndLocation(Vector3 newLocation, NodeCluster newCluster, bool onlyAvailableNodes = false)
    {
        Vector3 startLocation = newCluster.gridCoordinates;
        Vector3 endLocation   = newCluster.gridCoordinates + new Vector3(newCluster.clusterSize, newCluster.clusterSize, newCluster.clusterSize);

        Node  closestNode = null;
        Grid  newGrid     = newCluster.mainAbstractGrid.mainGrid;
        float closestDist = 100000000;

        for (int i = (int)startLocation.x; i < endLocation.x; i++)
        {
            for (int j = (int)startLocation.z; j < endLocation.z; j++)
            {
                Node tempNode = newGrid.LookUpNode(i, j);
                if (onlyAvailableNodes)
                {
                    if (!tempNode.available)
                    {
                        continue;
                    }
                }
                float tempDist = Vector3.Distance(newLocation, tempNode.sphereCoordinates);
                if (tempDist < closestDist)
                {
                    closestDist = tempDist;
                    closestNode = tempNode;
                }
            }
        }
        return(closestNode);
    }
Exemple #2
0
    public void RemoveNode(Node newNode)
    {
        //Only Remove if Node is NOT ABSTRACT
        if (newNode.IsTemporary())
        {
            NodeCluster newCluster = newNode.clusterParent;
            ManageAbstractNodeList(newNode, false);

            for (int i = 0; i < newCluster.nodeList.Count; i++)
            {
                Node removeNode = null;
                for (int j = 0; j < newCluster.nodeList[i].neighbors.Count; j++)
                {
                    if (newCluster.nodeList[i].neighbors[j] == newNode)
                    {
                        removeNode = newNode;
                    }
                }
                if (removeNode != null)
                {
                    newCluster.nodeList[i].neighbors.Remove(removeNode);
                }
            }
            newCluster.ManageAbstractNodes(newNode, false);
            newCluster.SetAbstractConnections();
        }
    }
Exemple #3
0
    public Node GetClosestNode(Vector3 newLocation, bool onlyAvailableNodes = false)
    {
        Grid        newGrid    = GetGridFromLocation(newLocation);//GetGridFrontLocationOnSphere(newLocation);
        NodeCluster newCluster = GetNodeClusterFromGridAndLocation(newLocation, newGrid);
        Node        newNode    = GetNodeFromNodeClusterAndLocation(newLocation, newCluster, onlyAvailableNodes);

        return(newNode);
    }
    private void SpawnZ(int newX, int newZ)
    {
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newX, newZ);
        int         nodeClusterKey = GetNodeClusterKey(newNodeCluster.xVal, newNodeCluster.zVal);

        nodeClusterDictionary.Add(nodeClusterKey, newNodeCluster);
        nodeClusterCounter++;
    }
Exemple #5
0
    private void SpawnZ(int newX, int newZ)
    {
        Vector3     newLocation    = new Vector3(newX, 0, newZ);
        Node        newNode        = mainGrid.nodeDictionary[newLocation];
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newNode.gridCoordinates, newNode.cubeCoordinates, newNode.sphereCoordinates);

        nodeClusterDictionary.Add(newLocation, newNodeCluster);
        nodeClusterCounter++;
    }
Exemple #6
0
    /*
     * =============================================================
     *                      Manages Inserted Nodes
     * =============================================================
     */
    public Node InsertNode(Node refNode)
    {
        NodeCluster newCluster = refNode.clusterParent != null ? refNode.clusterParent : GetNodeClusterFromLocation((int)refNode.xVal, (int)refNode.zVal);
        Node        newNode    = new Node(this.mainGrid, refNode.gridCoordinates, NodeType.Temporary, -1);

        newNode.SetClusterParent(newCluster);

        ManageAbstractNodeList(newNode);
        newCluster.ManageAbstractNodes(newNode);
        newCluster.SetAbstractConnections();

        return(newNode);
    }
        static async Task Main(string[] args)
        {
            string url = "chains/main/blocks/head/header";

            List <string> urls = new List <string>()
            {
                "https://rpc.tzkt.io/mainnet/", "https://mainnet-tezos.giganode.io/", "https://mainnet.smartpy.io/"
            };

            string i = null;

            while (Convert.ToInt16(i) != 2)
            {
                Console.WriteLine("Добавить url?");
                i = Console.ReadLine();

                if (Convert.ToInt16(i) != 2)
                {
                    string new_base_url = Console.ReadLine();
                    urls.Add(new_base_url);
                }
                else
                {
                    break;
                }
            }

            NodeCluster nodeCluster = new NodeCluster(urls);


            Head LatestHead = new Head();
            Task task       = Task.Factory.StartNew(async() => LatestHead = await nodeCluster.GetLatestHead(url));

            task.Wait();
            // LatestHead = await Task.Run<Head>(() => nodeCluster.GetLatestHead(url));
            Thread.Sleep(5000);
            Task task_return = Task.Factory.StartNew(() =>
            {
                Console.WriteLine($"Head.Url: {LatestHead.Url}");
                Console.WriteLine($"Head.ChainId: {LatestHead.Chain_id}");
                Console.WriteLine($"Head.Hash: {LatestHead.Hash}");
                Console.WriteLine($"Head.Predecessor: {LatestHead.Predecessor}");
                Console.WriteLine($"Head.Level: {LatestHead.Level}");
                Console.WriteLine($"Head.Timestamp: {LatestHead.Timestamp}");
            });

            task_return.Wait();
            // await Task.WhenAll(new[] { task, task_return });
        }
Exemple #8
0
    private NodeCluster GetNodeClusterFromGridAndLocation(Vector3 newLocation, Grid newGrid)
    {
        NodeCluster closestCluster = null;
        float       closestDist    = 1000000;

        foreach (NodeCluster newCluster in newGrid.abstractGrid.nodeClusterDictionary.Values)
        {
            float tempDist = Vector3.Distance(newLocation, newCluster.centerSphereCoordinates);
            if (tempDist < closestDist)
            {
                closestDist    = tempDist;
                closestCluster = newCluster;
            }
        }
        return(closestCluster);
    }
    private void SpawnX(int newX)
    {
        int         tempZ          = (int)mainGrid.transform.position.z;
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newX, tempZ);
        int         nodeClusterKey = GetNodeClusterKey(newNodeCluster.xVal, newNodeCluster.zVal);

        nodeClusterDictionary.Add(nodeClusterKey, newNodeCluster);
        nodeClusterCounter++;

        int newZ = tempZ + clusterSize;

        for (int i = 0; i < abstractGridSize - 1; ++i)
        {
            SpawnZ(newX, newZ);
            newZ += clusterSize;
        }
    }
Exemple #10
0
    private void SpawnX(int newX)
    {
        int         tempZ          = 0;// (int)mainGrid.transform.position.z;
        Vector3     newLocation    = new Vector3(newX, 0, tempZ);
        Node        newNode        = mainGrid.nodeDictionary[newLocation];
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newNode.gridCoordinates, newNode.cubeCoordinates, newNode.sphereCoordinates);

        nodeClusterDictionary.Add(newLocation, newNodeCluster);
        nodeClusterCounter++;

        int newZ = tempZ + clusterSize;

        for (int i = 0; i < abstractGridSize - 1; ++i)
        {
            SpawnZ(newX, newZ);
            newZ += clusterSize;
        }
    }
Exemple #11
0
    private void BeginLevel()
    {
        //Create Player Base
        Node        newNode    = mainGrid.gridDictionary[Orientation.Front].LookUpNode(25, 25);
        NodeCluster newCluster = newNode.clusterParent;
        Building    p1Base     = SpawnBuilding(newCluster, BuildingType.Base);

        p1Base.Initialize(player01, BuildingType.Base);
        p1BaseHealth = p1Base.gameObject.GetComponent <Health>();
        player01.Initialize(newNode);

        //Create Enemy Base
        newNode    = mainGrid.gridDictionary[Orientation.Back].LookUpNode(25, 25);
        newCluster = newNode.clusterParent;
        Building p2Base = SpawnBuilding(newCluster, BuildingType.Base);

        p2Base.Initialize(player02, BuildingType.Base);
        p2BaseHealth = p2Base.gameObject.GetComponent <Health>();
        player02.Initialize(newNode);
    }
    private void MoveTemporaryBuilding()
    {
        //Placing Building
        NodeCluster newCluster = mainGrid.GetClosestNode(targetPoint).clusterParent;

        if (newCluster.centerNode.available)
        {
            placingBuilding.transform.position = newCluster.centerNode.GetLocation();
            Vector3 upVector = targetPoint - LevelManager.PLANET_CENTER;
            placingBuilding.transform.up = upVector;

            if (Input.GetMouseButtonDown(0))
            {
                Building newBuilding = mainLevelManager.SpawnBuilding(newCluster, BuildingType.Shield);
                newBuilding.Initialize(this, BuildingType.Shield);
                Destroy(placingBuilding);
                placingBuilding = null;
            }
        }
    }
Exemple #13
0
    public Building SpawnBuilding(NodeCluster newCluster, BuildingType type)
    {
        Node newNode = newCluster.centerNode;
        int range = 3;
        for (int j = (int)newNode.gridCoordinates.x - range; j <= newNode.gridCoordinates.x + range; j++)
        {
            for (int k = (int)newNode.gridCoordinates.z - range; k <= newNode.gridCoordinates.z + range; k++)
            {
                Node currentNode = newNode.gridParent.LookUpNode(j, k);
                currentNode.ToggleAvailable(false);
                newCluster.RefreshPaths();
            }
        }

        GameObject buildingPrefab = (type == BuildingType.Base) ? basePrefab : shieldPrefab;
        GameObject newBuildingPrefab = Instantiate(buildingPrefab, newNode.sphereCoordinates, Quaternion.identity) as GameObject;
        Vector3 lookVector = (newNode.GetLocation()-PLANET_CENTER);
        newBuildingPrefab.transform.up = lookVector;
        Building buildingComponent = newBuildingPrefab.GetComponent<Building>();
        return buildingComponent;
    }
Exemple #14
0
    public void SetClusterParents(Dictionary <Vector3, Node> nodeDictionary)
    {
        foreach (Node newNode in nodeDictionary.Values)
        {
            int minX = 0; // (int)mainGrid.transform.position.x;
            int minZ = 0; // (int)mainGrid.transform.position.z;

            Vector2 currentMin = new Vector2(minX, minZ);
            Vector2 currentMax = new Vector2(minX + (clusterSize - 1), minZ + (clusterSize - 1));

            bool clusterFound = false;
            for (int i = 0; i < mainGrid.gridSize / clusterSize; i++)
            {
                currentMin.x = minX + (clusterSize * i);
                currentMax.x = currentMin.x + (clusterSize - 1);

                for (int j = 0; j < mainGrid.gridSize / clusterSize; j++)
                {
                    currentMin.y = minZ + (clusterSize * j);
                    currentMax.y = currentMin.y + (clusterSize - 1);

                    if (newNode.xVal >= currentMin.x && newNode.xVal <= currentMax.x && newNode.zVal >= currentMin.y && newNode.zVal <= currentMax.y)
                    {
                        clusterFound = true;
                        break;
                    }
                }
                if (clusterFound)
                {
                    break;
                }
            }
            if (clusterFound)
            {
                NodeCluster newCluster = LookUpNodeCluster((int)currentMin.x, (int)currentMin.y);
                newNode.SetClusterParent(newCluster);
            }
        }
    }
Exemple #15
0
    public Building SpawnBuilding(NodeCluster newCluster, BuildingType type)
    {
        Node newNode = newCluster.centerNode;
        int  range   = 3;

        for (int j = (int)newNode.gridCoordinates.x - range; j <= newNode.gridCoordinates.x + range; j++)
        {
            for (int k = (int)newNode.gridCoordinates.z - range; k <= newNode.gridCoordinates.z + range; k++)
            {
                Node currentNode = newNode.gridParent.LookUpNode(j, k);
                currentNode.ToggleAvailable(false);
                newCluster.RefreshPaths();
            }
        }

        GameObject buildingPrefab    = (type == BuildingType.Base) ? basePrefab : shieldPrefab;
        GameObject newBuildingPrefab = Instantiate(buildingPrefab, newNode.sphereCoordinates, Quaternion.identity) as GameObject;
        Vector3    lookVector        = (newNode.GetLocation() - PLANET_CENTER);

        newBuildingPrefab.transform.up = lookVector;
        Building buildingComponent = newBuildingPrefab.GetComponent <Building>();

        return(buildingComponent);
    }
    private Node GetNodeFromNodeClusterAndLocation(Vector3 newLocation, NodeCluster newCluster)
    {
        Vector3 startLocation = newCluster.gridCoordinates;
        Vector3 endLocation = newCluster.gridCoordinates + new Vector3(newCluster.clusterSize, newCluster.clusterSize, newCluster.clusterSize);

        Node closestNode = null;
        Grid newGrid = newCluster.mainAbstractGrid.mainGrid;
        float closestDist = 100000000;
        for (int i = (int)startLocation.x; i < endLocation.x; i++)
        {
            for (int j = (int)startLocation.z; j < endLocation.z; j++)
            {
                Node tempNode = newGrid.LookUpNode(i, j);
                float tempDist = Vector3.Distance(newLocation, tempNode.sphereCoordinates);
                if (tempDist < closestDist)
                {
                    closestDist = tempDist;
                    closestNode = tempNode;
                }
            }
        }
        return closestNode;
    }
 private void SpawnZ(int newX, int newZ)
 {
     NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newX, newZ);
     int nodeClusterKey = GetNodeClusterKey(newNodeCluster.xVal, newNodeCluster.zVal);
     nodeClusterDictionary.Add(nodeClusterKey, newNodeCluster);
     nodeClusterCounter++;
 }
    private void SpawnX(int newX)
    {
        int tempZ = (int)mainGrid.transform.position.z;
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newX, tempZ);
        int nodeClusterKey = GetNodeClusterKey(newNodeCluster.xVal, newNodeCluster.zVal);
        nodeClusterDictionary.Add(nodeClusterKey, newNodeCluster);
        nodeClusterCounter++;

        int newZ = tempZ + clusterSize;
        for (int i = 0; i < abstractGridSize - 1; ++i)
        {
            SpawnZ(newX, newZ);
            newZ += clusterSize;
        }
    }
Exemple #19
0
        static void Main(string[] args)
        {
            Console.Title = "Node";

            var configBuilder = new ClusterConfigBuilder();
            var seeds         = "0.0.0.0:7001,0.0.0.0:7002";

            var clusterEvents = new Subject <Shared.Messages.ClusterEvent>();
            var cache         = new AssetsCache();

            clusterEvents.Subscribe((m) =>
            {
                Console.WriteLine($"1\t{m.Type.ToString()}\t{m.NodeId}");
                if (m.Type == ClusterEventType.Up)
                {
                    cache.SetNodeId(m.NodeId);
                }
                else if (m.Type == ClusterEventType.MemberUp)
                {
                    cache.AddNode(m.NodeId);
                }
                else if (m.Type == ClusterEventType.MemberDown)
                {
                    cache.RemoveNode(m.NodeId);
                }
                else if (m.Type == ClusterEventType.SeedDown)
                {
                    cache.Stop();
                }
            });
            var cluster = new NodeCluster(clusterEvents, configBuilder.Build(Roles.Node, 6001, seeds));

            var clusterEvents2 = new Subject <Shared.Messages.ClusterEvent>();
            var cache2         = new AssetsCache();

            clusterEvents2.Subscribe((m) =>
            {
                Console.WriteLine($"2\t{m.Type.ToString()}\t{m.NodeId}");
                if (m.Type == ClusterEventType.Up)
                {
                    cache2.SetNodeId(m.NodeId);
                }
                else if (m.Type == ClusterEventType.MemberUp)
                {
                    cache2.AddNode(m.NodeId);
                }
                else if (m.Type == ClusterEventType.MemberDown)
                {
                    cache2.RemoveNode(m.NodeId);
                }
                else if (m.Type == ClusterEventType.SeedDown)
                {
                    cache2.Stop();
                }
            });
            var cluster2 = new NodeCluster(clusterEvents2, configBuilder.Build(Roles.Node, 6002, seeds));

            cluster.Start();
            var firstStarted = true;

            cluster2.Start();
            var secondStarted = true;

            Console.WriteLine("Press 0 to exit");
            Console.WriteLine("Press 1 to start\\stop first node");
            Console.WriteLine("Press 2 to start\\stop first node");
            Console.WriteLine("Press a to print first cache");
            Console.WriteLine("Press b to print second cache");

            while (true)
            {
                var num  = Console.ReadKey();
                var exit = false;
                switch (num.KeyChar)
                {
                case '1':
                    if (firstStarted)
                    {
                        cluster.Stop();
                        firstStarted = false;
                        Console.WriteLine("\tEND");
                        cache.Stop();
                    }
                    else
                    {
                        cache.Stop();
                        cluster.Start();
                        firstStarted = true;
                        Console.WriteLine("\tSTART");
                    }
                    break;

                case '2':
                    if (secondStarted)
                    {
                        cluster2.Stop();
                        secondStarted = false;
                        Console.WriteLine("\tEND");
                        cache2.Stop();
                    }
                    else
                    {
                        cache2.Stop();
                        cluster2.Start();
                        secondStarted = true;
                        Console.WriteLine("\tSTART");
                    }
                    break;

                case '0':
                    exit = true;
                    break;

                case 'a':
                    cache.Print();
                    break;

                case 'b':
                    cache2.Print();
                    break;

                default:
                    Console.WriteLine("\tNoop");
                    break;
                }

                if (exit)
                {
                    break;
                }
            }

            cluster.Stop();
            cluster2.Stop();
        }
 //Used for Nodes in the ConnectionGrid
 public void SetClusterParent(NodeCluster newNodeCluster)
 {
     clusterParent = newNodeCluster;
 }
    public List <Node> FindComplexPath(Node startNode, Node endNode)
    {
        if (startNode.available != true || endNode.available != true)
        {
            return(null);
        }

        List <Node> newAbstractPath;

        if (startNode.gridParent != endNode.gridParent)
        {
            newAbstractPath = startNode.gridParent.abstractGrid.FindMultiAbstractGridPath(startNode, endNode);
        }
        else
        {
            newAbstractPath = startNode.gridParent.abstractGrid.FindAbstractPath(startNode, endNode);
        }

        List <Node> tempList = new List <Node>();
        List <Node> outList  = new List <Node>();

        if (newAbstractPath == null)
        {
            //Debug.Log("Abstract Path is Null");
            return(null);
        }

        for (int i = 0; i < newAbstractPath.Count - 1; i++)
        {
            Node sNode = newAbstractPath[i];
            Node eNode = newAbstractPath[i + 1];

            if (sNode.clusterParent == eNode.clusterParent)
            {
                NodeCluster newCluster = sNode.clusterParent;
                //Nodes are NOT Temporary, Use Precomputed Path
                if (!sNode.IsTemporary() && !eNode.IsTemporary())
                {
                    List <Node> storedPath = sNode.clusterParent.GetStoredPath(sNode, eNode);
                    if (storedPath == null)
                    {
                        Debug.Log("Stored Path is NULL");
                        Debug.Log("Start Node:(" + sNode.xVal + "," + sNode.zVal + ") End Node:(" + eNode.xVal + "," + eNode.zVal + ")");
                        return(null);
                    }

                    bool direction = (sNode.xVal == storedPath[0].xVal && sNode.zVal == storedPath[0].zVal);
                    if (!direction)
                    {
                        storedPath.Reverse();
                    }

                    if (outList.Count > 0)
                    {
                        if (outList[outList.Count - 1] == sNode)
                        {
                            outList.RemoveAt(outList.Count - 1);
                        }
                    }
                    outList.AddRange(storedPath);
                }
                //At least one of the Nodes have been Inserted.  Compute a new path
                else
                {
                    Node s = sNode.gridParent.LookUpNode(sNode.xVal, sNode.zVal);
                    Node e = eNode.gridParent.LookUpNode(eNode.xVal, eNode.zVal);
                    tempList = sNode.gridParent.FindPath(s, e);
                    outList.AddRange(tempList);

                    tempList.Clear();
                }
            }
            else
            {
                if ((i + 2) < newAbstractPath.Count)
                {
                    if (newAbstractPath[i + 2].IsAbstract())
                    {
                        outList.Add(eNode);
                    }
                }
            }
        }
        return(outList);
    }
Exemple #22
0
    private void SpawnX(int newX)
    {
        int tempZ = 0;// (int)mainGrid.transform.position.z;
        Vector3 newLocation = new Vector3(newX, 0, tempZ);
        Node newNode = mainGrid.nodeDictionary[newLocation];
        NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newNode.gridCoordinates,newNode.cubeCoordinates,newNode.sphereCoordinates);
        nodeClusterDictionary.Add(newLocation, newNodeCluster);
        nodeClusterCounter++;

        int newZ = tempZ + clusterSize;
        for (int i = 0; i < abstractGridSize - 1; ++i)
        {
            SpawnZ(newX, newZ);
            newZ += clusterSize;
        }
    }
Exemple #23
0
 private void SpawnZ(int newX, int newZ)
 {
     Vector3 newLocation = new Vector3(newX, 0, newZ);
     Node newNode = mainGrid.nodeDictionary[newLocation];
     NodeCluster newNodeCluster = new NodeCluster(this, clusterSize, newNode.gridCoordinates, newNode.cubeCoordinates, newNode.sphereCoordinates);
     nodeClusterDictionary.Add(newLocation, newNodeCluster);
     nodeClusterCounter++;
 }
Exemple #24
0
    private void Initialize()
    {
        int x_01 = (int)connection_01.position.x;
        int z_01 = (int)connection_01.position.z;

        Node        tempNode    = abstractGrid_01.mainGrid.LookUpNode(x_01, z_01);
        NodeCluster tempCluster = tempNode.clusterParent;
        Node        closestNode = tempCluster.nodeList[0];
        float       closestDist = 1000000;

        for (int i = 0; i < tempCluster.nodeList.Count; i++)
        {
            float tempDist = Vector3.Distance(tempNode.GetLocation(), tempCluster.nodeList[i].GetLocation());
            if (tempDist < closestDist)
            {
                closestDist = tempDist;
                closestNode = tempCluster.nodeList[i];
            }
        }
        node_01 = closestNode;

        /*NodeCluster nc_01 = abstractGrid_01.GetNodeClusterFromLocation(x_01, z_01);
         * Node closestNode = nc_01.nodeList[0];
         * float closestDistance = 100000000;
         * for (int i = 0; i < nc_01.nodeList.Count; i++)
         * {
         *  float tempDist = Vector3.Distance(connection_01.position, nc_01.nodeList[i].GetLocation());
         *  if (tempDist < closestDistance)
         *  {
         *      closestDistance = tempDist;
         *      closestNode = nc_01.nodeList[i];
         *  }
         * }
         * node_01 = closestNode;*/

        int x_02 = (int)connection_02.position.x;
        int z_02 = (int)connection_02.position.z;

        Node        tempNode2    = abstractGrid_02.mainGrid.LookUpNode(x_02, z_02);
        NodeCluster tempCluster2 = tempNode2.clusterParent;
        Node        closestNode2 = tempCluster2.nodeList[0];
        float       closestDist2 = 1000000;

        for (int i = 0; i < tempCluster2.nodeList.Count; i++)
        {
            float tempDist = Vector3.Distance(tempNode2.GetLocation(), tempCluster2.nodeList[i].GetLocation());
            if (tempDist < closestDist2)
            {
                closestDist2 = tempDist;
                closestNode2 = tempCluster2.nodeList[i];
            }
        }
        node_02 = closestNode2;

        /*NodeCluster nc_02 = abstractGrid_02.GetNodeClusterFromLocation(x_02, z_02);
         * closestNode = nc_02.nodeList[0];
         * closestDistance = 100000000;
         * for (int i = 0; i < nc_02.nodeList.Count; i++)
         * {
         *  float tempDist = Vector3.Distance(connection_02.position, nc_02.nodeList[i].GetLocation());
         *  if (tempDist < closestDistance)
         *  {
         *      closestDistance = tempDist;
         *      closestNode = nc_02.nodeList[i];
         *  }
         * }
         * node_02 = closestNode;*/

        node_01.SetConnection(node_02);
        node_02.SetConnection(node_01);

        node_01.gridParent.ManageConnectionNodes(node_01);
        node_02.gridParent.ManageConnectionNodes(node_02);

        connectionGrid.ManageNodeList(node_01);
        connectionGrid.ManageNodeList(node_02);
    }