/// <summary>
            /// returns the euclidean distance between both input corners
            /// </summary>
            public static float BetweenCornersEuclidean(Vector3Int cornerA, Vector3Int cornerB)
            {
                Vector3 a = HexConverter.CornerCoordToCartesianCoord(cornerA);
                Vector3 b = HexConverter.CornerCoordToCartesianCoord(cornerB);

                return(Vector3.Distance(a, b));
            }
            /// <summary>
            /// returns the shortest path of corners from the origin to the target corner - optionally including the origin
            /// </summary>
            /// ![green = origin , purple = target, blue/purple = result - origin can optionally be included](GetCorners_PathAlongGrid.png)
            public static List <Vector3Int> PathAlongGrid(Vector3Int originCorner, Vector3Int targetCorner, bool includeOrigin, float horizontalNudgeFromOriginCenter = NudgePositive)
            {
                if (originCorner == targetCorner)
                {
                    throw new System.ArgumentException("origin corner and target corner are the same - can't create a Path");
                }

                List <Vector3Int> corners = new List <Vector3Int>();

                if (includeOrigin)
                {
                    corners.Add(originCorner);
                }
                Vector3Int previousCorner = originCorner;

                Vector3 cartesianOrigin = HexConverter.CornerCoordToCartesianCoord(originCorner) + new Vector3(horizontalNudgeFromOriginCenter, 0, 0);
                Vector3 cartesianTarget = HexConverter.CornerCoordToCartesianCoord(targetCorner);

                int dist = GetDistance.BetweenCorners(originCorner, targetCorner);

                for (int i = 1; i <= dist; i++)
                {
                    Vector3 lerped = Vector3.Lerp(cartesianOrigin, cartesianTarget, (1f / dist) * i);

                    Vector3Int tileCoord = HexConverter.CartesianCoordToTileCoord(lerped);

                    List <Vector3Int> cornerCoords = HexGrid.GetCorners.OfTile(tileCoord);
                    cornerCoords.RemoveAll(x => HexGrid.GetDistance.BetweenCorners(previousCorner, x) != 1);

                    Vector3Int closestCorner    = new Vector3Int();
                    float      minDistanceSoFar = float.MaxValue;
                    for (int j = 0; j < cornerCoords.Count; j++)
                    {
                        Vector3 worldPos = HexConverter.CornerCoordToCartesianCoord(cornerCoords[j]);
                        float   distance = Vector3.Distance(worldPos, lerped);
                        if (distance < minDistanceSoFar)
                        {
                            closestCorner    = cornerCoords[j];
                            minDistanceSoFar = distance;
                        }
                    }

                    corners.Add(closestCorner);
                    previousCorner = closestCorner;
                }
                return(corners);
            }
        public static Vector2 CornerCoordToNormalizedPosition(Vector3Int cornerCoordinate, float minX, float maxX, float minZ, float maxZ)
        {
            Vector3 cartesianCoord = HexConverter.CornerCoordToCartesianCoord(cornerCoordinate);

            return(CartesianCoordToNormalizedPosition(cartesianCoord, minX, maxX, minZ, maxZ));
        }