public Vector3[] GenerateNodeSpiralLocations(SpiralGraphProperties spiralGraphProperties, out int[][] edges)
    {
        if (spiralGraphProperties.FloorsNodesCounts == null)
        {
            int[] floorNodesCounts = GraphGeneratorHelper.GenerateFloorNodesCounts(spiralGraphProperties.FloorsCount, -1,
                                                                                   spiralGraphProperties.FloorsCount);
            spiralGraphProperties.FloorsNodesCounts = floorNodesCounts;
        }
        int nodesCount = spiralGraphProperties.FloorsNodesCounts.Sum(a => a);

        connections = new Edge[nodesCount, nodesCount];
        Vector3[] nodesLocations = _spiralGraphGenerator.GenerateGraph(spiralGraphProperties, out edges);
        return(nodesLocations);
    }
    public Vector3[] GenerateGraph(IGraphProperties graphProperties, out int[][] edges)
    {
        List <Vector3> nodes     = new List <Vector3>();
        List <int[]>   edgesList = new List <int[]>();

        Vector3[]             lastNodesFloor        = null;
        Vector3[]             currentNodesFloor     = null;
        SpiralGraphProperties spiralGraphProperties = graphProperties as SpiralGraphProperties;

        float topY        = spiralGraphProperties.Location.y + spiralGraphProperties.Height;
        float floorHeight = spiralGraphProperties.Height / (spiralGraphProperties.FloorsCount - 1);

        for (int floorNo = 0; floorNo < spiralGraphProperties.FloorsCount; floorNo++)
        {
            float floorY        = spiralGraphProperties.Location.y + floorNo * floorHeight;
            float newConeHeight = topY - floorY;
            float floorRadius   = spiralGraphProperties.BaseRadius * newConeHeight / spiralGraphProperties.Height;

            if (floorNo > 0)
            {
                lastNodesFloor = new Vector3[currentNodesFloor.Length];
                currentNodesFloor.CopyTo(lastNodesFloor, 0);
            }

            Vector3 partSize    = new Vector3(floorRadius / 2, floorHeight, floorRadius / 2);
            Vector3 floorOrigin = new Vector3(spiralGraphProperties.Location.x, floorY, spiralGraphProperties.Location.z);

            currentNodesFloor = GraphGeneratorHelper.GenerateNodeLocationsOnCircle(floorOrigin, floorRadius,
                                                                                   spiralGraphProperties.FloorsNodesCounts[floorNo], spiralGraphProperties.RandomizationPercentage, partSize);
            nodes.AddRange(currentNodesFloor);

            edgesList.AddRange(GraphGeneratorHelper.GetEdgesInCircle(currentNodesFloor, nodes, true));

            if (floorNo > 0)
            {
                edgesList.Add(new[]
                {
                    nodes.IndexOf(lastNodesFloor[lastNodesFloor.Length - 1]),
                    nodes.IndexOf(currentNodesFloor[0])
                });
                edgesList.AddRange(GraphGeneratorHelper.GetEdgesBetweenTwoSetsAllToAll(lastNodesFloor, currentNodesFloor,
                                                                                       nodes, spiralGraphProperties.EdgesProbability));
            }
        }

        edges = edgesList.ToArray();
        return(nodes.ToArray());
    }
    public void Generate(GraphType graphType, IGraphProperties properties = null, int[][] powerDotLocations = null)
    {
        int[][]   edges          = null;
        Vector3[] nodesLocations = null;

        switch (graphType)
        {
        case GraphType.Conic:
        {
            ConicGraphProperties conicGraphProperties = (ConicGraphProperties)properties ?? new ConicGraphProperties
            {
                Location = transform.position,
                RandomizationPercentage = RandomizationPercentage,
                Height      = ConeHeight,
                FloorsCount = ConeFloorCount,
                BaseRadius  = ConeRadius
            };
            nodesLocations = GenerateNodeConicLocations(conicGraphProperties, out edges);
            break;
        }

        case GraphType.Cubic:
        {
            CubicGraphProperties cubicGraphProperties = (CubicGraphProperties)properties ?? new CubicGraphProperties
            {
                RandomizationPercentage = RandomizationPercentage,
                Location   = transform.position,
                PartsCount = CubePartsCount,
                Size       = CubeSize
            };
            nodesLocations = GenerateNodeCubicLocations(cubicGraphProperties, out edges);
            break;
        }

        case GraphType.Random:
        {
            RandomGraphProperties randomGraphProperties = (RandomGraphProperties)properties ?? new RandomGraphProperties
            {
                Location         = transform.position,
                NodesCount       = RandomNodesCount,
                EdgesProbability = RandomEdgesProbability,
                Size             = RandomCubeSize
            };
            nodesLocations = GenenerateNodeRandomLocations(randomGraphProperties, out edges);
            break;
        }

        case GraphType.Spheric:
        {
            SphericGraphProperties sphericGraphProperties = (SphericGraphProperties)properties ??
                                                            new SphericGraphProperties
            {
                RandomizationPercentage = RandomizationPercentage,
                Location         = transform.position,
                FloorsCount      = SphereFloorsCount,
                EdgesProbability = SphereEdgesProbability,
                Radius           = SphereRadius
            };
            nodesLocations = GenerateNodeSphericLocations(sphericGraphProperties, out edges);
            break;
        }

        case GraphType.Spiral:
        {
            SpiralGraphProperties spiralGraphProperties = (SpiralGraphProperties)properties ??
                                                          new SpiralGraphProperties
            {
                Location = transform.position,
                RandomizationPercentage = RandomizationPercentage,
                Height           = SpiralHeight,
                FloorsCount      = SpiralFloorCount,
                BaseRadius       = SpiralRadius,
                EdgesProbability = SpiralEdgesProbability
            };
            nodesLocations = GenerateNodeSpiralLocations(spiralGraphProperties, out edges);
            break;
        }
        }

        InitializeNodes(nodesLocations);
        InitializeEdges(this.Nodes, edges, powerDotLocations);
    }