I have an ICollection<MapNode>. Each MapNode has a Position attribute, which is a Point. I want to sort these points first by Y value, then by X value, and put them in a multidimensional array (MapNode[,]).

The collection would look something like this:

(30, 20)
(20, 20)
(20, 30)
(30, 10)
(30, 30)
(20, 10)

And the final product:

(20, 10)    (20, 20)    (20, 30)
(30, 10)    (30, 20)    (30, 30)

Here is the code I have come up with to do it. Is this hideously unreadable? I feel like it's more hacky than it needs to be.

    private Map createWorldPathNodes()
    {
        ICollection<MapNode> points = new HashSet<MapNode>();
        Rectangle worldBounds = WorldQueryUtils.WorldBounds();

        for (float x = worldBounds.Left; x < worldBounds.Right; x += PATH_NODE_CHUNK_SIZE)
        {
            for (float y = worldBounds.Y; y > worldBounds.Height; y -= PATH_NODE_CHUNK_SIZE)
            {
                // default is that everywhere is navigable;
                // a different function is responsible for determining the real value
                points.Add(new MapNode(true, new Point((int)x, (int)y))); 
            }
        }

        int distinctXValues = points.Select(node => node.Position.X).Distinct().Count();
        int distinctYValues = points.Select(node => node.Position.Y).Distinct().Count();

        IList<MapNode[]> mapNodeRowsToAdd = new List<MapNode[]>();

        while (points.Count > 0) // every iteration will take a row out of points
        {
            // get all the nodes with the greatest Y value currently in the collection
            int currentMaxY = points.Select(node => node.Position.Y).Max();
            ICollection<MapNode> ythRow = points.Where(node => node.Position.Y == currentMaxY).ToList();

            // remove these nodes from the pool we're picking from
            points = points.Where(node => ! ythRow.Contains(node)).ToList(); // ToList() is just so it is still a collection

            // put the nodes with max y value in the array, sorting by X value
            mapNodeRowsToAdd.Add(ythRow.OrderByDescending(node => node.Position.X).ToArray());
        }

        MapNode[,] mapNodes = new MapNode[distinctXValues, distinctYValues];

        int xValuesAdded = 0;
        int yValuesAdded = 0;
        foreach (MapNode[] mapNodeRow in mapNodeRowsToAdd)
        {
            xValuesAdded = 0;
            foreach (MapNode node in mapNodeRow)
            {
                // [y, x] may seem backwards, but mapNodes[y] == the yth row
                mapNodes[yValuesAdded, xValuesAdded] = node; 
                xValuesAdded++;
            }
            yValuesAdded++;
        }

        return pathNodes;
    }

The above function seems to work pretty well, but it hasn't been subjected to bulletproof testing yet.