---

    private List<Vector2> FindVerticalPocketPositions(List<Vector2> hexPositions)
    {
        const float tolerance = 0.01f;

        var pockets = new List<Vector2>();
        Vector2[] verticalOffsets = GetVerticalNeighborOffsets(1f);
        Vector2[] neighborOffsets = GetAllNeighborOffsets(1f);

        for (int i = 0; i < hexPositions.Count; i++)
        {
            Vector2 position = hexPositions[i];
            for (int offsetIndex = 0; offsetIndex < verticalOffsets.Length; offsetIndex++)
            {
                Vector2 candidate = position + verticalOffsets[offsetIndex];
                if (HasPosition(hexPositions, candidate, tolerance) || HasPosition(pockets, candidate, tolerance))
                {
                    continue;
                }

                if (CountNeighboringHexes(hexPositions, candidate, neighborOffsets, tolerance) >= 2)
                {
                    pockets.Add(candidate);
                }
            }
        }

        return pockets;
    }

    private List<Vector2> ToCenteredPlanePositions(List<Vector2> positions, Vector2 center, float radius)
    {
        var centeredPositions = new List<Vector2>(positions.Count);
        for (int i = 0; i < positions.Count; i++)
        {
            centeredPositions.Add((positions[i] - center) * radius);
        }

        return centeredPositions;
    }

    private Vector2[] GetVerticalNeighborOffsets(float radius)
    {
        float xStep = GetColumnStep(radius);
        float rowStep = GetRowStep(radius);
        return new[]
        {
            new Vector2(-xStep * 0.5f, rowStep),
            new Vector2(xStep * 0.5f, rowStep),
            new Vector2(-xStep * 0.5f, -rowStep),
            new Vector2(xStep * 0.5f, -rowStep),
        };
    }

    private Vector2[] GetAllNeighborOffsets(float radius)
    {
        float xStep = GetColumnStep(radius);
        float rowStep = GetRowStep(radius);
        return new[]
        {
            new Vector2(-xStep, 0f),
            new Vector2(xStep, 0f),
            new Vector2(-xStep * 0.5f, rowStep),
            new Vector2(xStep * 0.5f, rowStep),
            new Vector2(-xStep * 0.5f, -rowStep),
            new Vector2(xStep * 0.5f, -rowStep),
        };
    }

    private int CountNeighboringHexes(List<Vector2> hexPositions, Vector2 candidate, Vector2[] neighborOffsets, float tolerance)
    {
        int count = 0;
        for (int i = 0; i < neighborOffsets.Length; i++)
        {
            if (HasPosition(hexPositions, candidate + neighborOffsets[i], tolerance))
            {
                count++;
            }
        }

        return count;
    }

    private bool HasPosition(List<Vector2> positions, Vector2 target, float tolerance)
    {
        float sqrTolerance = tolerance * tolerance;
        for (int i = 0; i < positions.Count; i++)
        {
            if ((positions[i] - target).sqrMagnitude <= sqrTolerance)
            {
                return true;
            }
        }

        return false;
    }