RandomChunkColumnIterator.java

package com.hypixel.hytale.server.spawning.util;

import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
import java.util.Random;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class RandomChunkColumnIterator {
   @Nonnull
   private final ChunkColumnMask availablePositions = new ChunkColumnMask();
   @Nullable
   private final ChunkColumnMask initialPositions;
   @Nonnull
   private final Random random = new Random();
   private final long seed;
   private int currentIndex;
   private int lastSavedIteratorPosition;

   public RandomChunkColumnIterator() {
      this.initialPositions = null;
      this.seed = .random.nextLong();
   }

     {
      .initialPositions = initialPositions;
       (initialPositions.isEmpty()) {
           ();
      }  {
         .seed = .random.nextLong();
      }
   }

     {
      .initialPositions = initialPositions;
      .seed = (()chunk.getX() *  + ()chunk.getZ()) * ;
   }

      {
       .currentIndex;
   }

      {
       ChunkUtil.xFromColumn(.currentIndex);
   }

      {
       ChunkUtil.zFromColumn(.currentIndex);
   }

   
    ChunkColumnMask  {
       .initialPositions;
   }

      {
       (.availablePositions.isEmpty()) {
         .reset();
      }

         .random.nextInt();
         .availablePositions.nextSetBit(start);
       (index == -) {
         index = .availablePositions.previousSetBit(start);
      }

       .nextPosition(index);
   }

      {
       (.availablePositions.isEmpty()) {
         .reset();
      }

         .random.nextInt();
       start;
       end;
       (.availablePositions.get(index)) {
         start = .availablePositions.previousClearBit(index) + ;
         end = .availablePositions.nextClearBit(index) - ;
      }  {
         end = .availablePositions.previousSetBit(index);
         start = .availablePositions.nextSetBit(index);
          (end != - && (start == - || index - end <= start - index)) {
            start = .availablePositions.previousClearBit(end) + ;
         }  {
            end = .availablePositions.nextClearBit(start) - ;
         }
      }

         end - start + ;
       (range > ) {
         start +=  + .random.nextInt(range - );
      }   (range > ) {
         start += .random.nextInt(range);
      }

       (!.availablePositions.get(start)) {
           ();
      }  {
          .nextPosition(start);
      }
   }

      {
      .lastSavedIteratorPosition = .positionsLeft();
   }

      {
       .positionsLeft() == .lastSavedIteratorPosition;
   }

      {
       .availablePositions.cardinality();
   }

      {
      .availablePositions.clear(index);
   }

      {
      .markPositionVisited(.currentIndex);
   }

      {
      .random.setSeed(.seed);
       (.initialPositions == ) {
         .availablePositions.set();
      }  {
          (.initialPositions.isEmpty()) {
              ();
         }

         .availablePositions.copyFrom(.initialPositions);
      }

   }

      {
       (index == -) {
           ();
      }  {
         .markPositionVisited(index);
          .currentIndex = index;
      }
   }
}