/// <summary>
        /// Loops through positions in the <paramref name="endpoint"/> to find which position is closest to <paramref name="point"/>
        /// </summary>
        /// <param name="endpoint">Endpoint which contains a closest position</param>
        /// <param name="point">Point to check distance to</param>
        /// <param name="skipUsedSpots">Should used spots be skipped</param>
        /// <returns>The closest position</returns>
        private float3 GetClosestPoint(EdgeEndpoint endpoint, float3 point, bool skipUsedSpots = true)
        {
            var closestDist = float.MaxValue;
            var closest     = new float3(float.MaxValue, float.MaxValue, float.MaxValue);

            // Loop through the four sides
            for (var i = 0; i < 4; i++)
            {
                var p    = endpoint.Tile.BottomRectangle.CenterFromIndex(i);
                var dist = math.distance(p, point);
                if (dist > closestDist)
                {
                    continue;
                }
                if (skipUsedSpots && endpoint.UsedCenters.Contains(p))
                {
                    continue;
                }

                closestDist = dist;
                closest     = p;
            }

            if (skipUsedSpots)
            {
                endpoint.UsedCenters.Add(closest);
            }

            return(closest);
        }
        private List <Edge> CreateEdges(Edge edge, float3 closestStart, float3 closestEnd)
        {
            var edges = new List <Edge>();

            var start = edge.Start;
            var end   = edge.End;

            var startPoint = new EdgeEndpoint(closestStart, start.Tile);
            var endPoint   = new EdgeEndpoint(closestEnd, end.Tile);

            var corners = CreateCorners(closestStart, closestEnd, out var skipCorner);

            if (skipCorner)
            {
                edges.Add(new Edge(startPoint, endPoint));
                return(edges);
            }

            var horizontal = MeetsHorizontalRequirements(closestStart, closestEnd, minLengthForCorner);

            if (horizontal)
            {
                var cornerPoint = new EdgeEndpoint(corners[0]);
                edges.Add(new Edge(startPoint, cornerPoint));

                var vertical = MeetsVerticalRequirements(closestStart, closestEnd, corners, minLengthForCorner);
                if (!vertical)
                {
                    edges.Add(new Edge(cornerPoint, endPoint));
                    return(edges);
                }

                // Only add a secondary point for the corner if the vertical requirements are met
                var secondaryPoint = new EdgeEndpoint(corners[1]);

                // Recheck which point is closer from the newest point
                end.UsedCenters.Remove(closestEnd);
                closestEnd = GetClosestPoint(end, corners[1]);
                // Reassign positions
                endPoint = new EdgeEndpoint(closestEnd, end.Tile);

                edges.Add(new Edge(cornerPoint, secondaryPoint));
                edges.Add(new Edge(secondaryPoint, endPoint));
                return(edges);
            }
            edges.Add(new Edge(startPoint, endPoint));
            return(edges);
        }