Need help to sorting an array in a complicated way c# linq

But I don't know how to make it alternate one after another.

If you sort the array so that all the inactives are at the start, descending and all the actives are at the end, descending..

OrderBy(x => x.active?1:0).ThenBy(x=>-x.d)

then you can take an item from the start, then an item from the end, then from the start + 1, then the end - 1 working your way inwards

public static IEnumerable<Chunk> Interleave(this Chunk[] chunks){
  
    for(int s = 0, e = chunks.Length - 1; s<e;){

        if(!chunks[s].active)
            yield return chunks[s++]; 

        if(chunks[e].active)
            yield return chunks[e--];

    }

}

There's a bit in this so let's unpack it. This is an extension method that acts on an array of chunk. It's a custom enumerator method, so you'd call foreach on it to use it

foreach(var c in chunk.Interleave())

It contains a for loop that tracks two variables, one for the start index and one for the end. The start increments and the end decrements. At some point they'll meet and s will no longer be less than e, which is when we stop:

for(int s = 0, e = chunks.Length - 1; s<e;){

We need to look at the chunk before we return it, if it's an inactive near the start, yield return it and bump the start on by one. s++ increments s, but resolves to the value s was before it incremented. It's thus conceptually like doing chunks[s]; s += 1; but in a one liner

if(!chunks[s].active)
    yield return chunks[s++]; 

Then we look at the chunk near the end, if it's active then return the ending one and bump the end index down

The inactive chunks are tracked by s, and if s reaches an active chunk it stops returning (every pass of the loop it is skipped), which means e will work its way down towards s returning only the actives

Similarly if there are more inactives than actives, e will stop decrementing first and s will work its way up towards e

If you never came across yield return before think of it as a way to allow you to resume from where you left off rather than starting the method over again. It's used with enumerations to provide a way for the enumeration to return an item, then be moved on one and return the next item. It works a bit like saving your game and going doing something else, then coming back, realising your save game and carrying on from where you left off. Asking an enumerator for Next makes it load the game, play a bit, then save and stop.. Then you Next again and the latest save id loaded, play some more, save and stop. This way you gradually get through the game a bit at a time. If you started a new enumeration by calling Interleave again, that's like starting a new game over from the beginning

MSDN will get more detailed on yield return if you want to dig in more

Edit:

You can perform an in-place sort of your Chunk[] by having a custom comparer:

public class InactiveThenDistancedDescending : IComparer
{
   public int Compare(object x, object y)
   {
       var a = (Chunk)x;
       var b = (Chunk)y;
       if(a.Active == b.Active)
         return -a.Distance.CompareTo(b.Distance);
       else
         return a.Active.CompareTo(b.Active);
   }
}

And:

Array.Sort(chunkArray, _someInstanceOfThatComparerAbove);