/// <summary>
            /// returns all corners of the input tiles which are adjacent to 1 or 2 tiles not belonging to the input set.
            /// </summary>
            /// ![green = input tiles , blue = result](GetCorners_TileBorders.png)
            public static List <Vector3Int> TileBorders(IEnumerable <Vector3Int> tiles)
            {
                List <Vector3Int>            corners = new List <Vector3Int>();
                Dictionary <Vector3Int, int> numberOfAdjacentTilesByCorner = new Dictionary <Vector3Int, int>();

                foreach (var tile in tiles)
                {
                    List <Vector3Int> cornerCoordsOfCell = GetCorners.OfTile(tile);
                    foreach (var c in cornerCoordsOfCell)
                    {
                        if (numberOfAdjacentTilesByCorner.Keys.Contains(c))
                        {
                            numberOfAdjacentTilesByCorner[c] += 1;
                        }
                        else
                        {
                            numberOfAdjacentTilesByCorner.Add(c, 1);
                        };
                    }
                }

                foreach (var kvp in numberOfAdjacentTilesByCorner)
                {
                    if (kvp.Value < 3)
                    {
                        corners.Add(kvp.Key);
                    }
                }

                return(corners);
            }
            /// <summary>
            /// returns all corners within distance of the input corner - optionally including that corner.
            /// </summary>
            /// ![green = input corner , blue = result](GetCorners_WithinDistance.png)
            public static List <Vector3Int> WithinDistance(Vector3Int centerCorner, int maxDistance, bool includeCenter)
            {
                //there might be smarter ways but this should work.
                HashSet <Vector3Int> corners     = new HashSet <Vector3Int>();
                HashSet <Vector3Int> openCorners = new HashSet <Vector3Int>();

                openCorners.Add(centerCorner);

                for (int i = 0; i <= maxDistance; i++)
                {
                    HashSet <Vector3Int> cornersWithDistanceI = new HashSet <Vector3Int>();
                    foreach (var corner in openCorners)
                    {
                        corners.Add(corner);
                        var adjacent = GetCorners.AdjacentToCorner(corner);
                        foreach (var adj in adjacent)
                        {
                            if (!corners.Contains(adj))
                            {
                                cornersWithDistanceI.Add(adj);
                            }
                        }
                    }
                    openCorners = cornersWithDistanceI;
                }

                if (!includeCenter)
                {
                    corners.Remove(centerCorner);
                }

                return(corners.ToList());
            }
            /// <summary>
            /// returns the shortest path of edges from origin to target corner
            /// </summary>
            /// ![green = origin corner , purple = target corner, blue = result](GetEdges_PathBetweenCorners.png)
            public static List <Vector3Int> PathBetweenCorners(Vector3Int originCorner, Vector3Int targetCorner, float horizontalNudgeFromOriginCenter = NudgePositive)
            {
                List <Vector3Int> corners = GetCorners.PathAlongGrid(originCorner, targetCorner, true, horizontalNudgeFromOriginCenter);
                List <Vector3Int> edges   = new List <Vector3Int>();

                for (int i = 0; i < corners.Count - 1; i++)
                {
                    edges.Add(HexGrid.GetEdge.BetweenCorners(corners[i], corners[i + 1]));
                }

                return(edges);
            }