class="kw">package com.hypixel.hytale.server.core.universe.world.worldgen.provider;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.procedurallib.logic.GeneralNoise;
class="kw">import com.hypixel.hytale.protocol.Color;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.asset.util.ColorParseUtil;
class="kw">import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabLoadException;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabStore;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.standard.BlockSelection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.ISpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.IndividualSpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedBlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedEntityChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.IWorldGen;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenLoadException;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenTimingsCollector;
class="kw">import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
class="kw">import java.util.Arrays;
class="kw">import java.util.Random;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.LongPredicate;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class CubicTestWorldGenProvider class="kw">implements IWorldGenProvider {
   class="kw">public class="kw">static class="kw">final String ID = "CubicTest";
   class="kw">private class="kw">static class="kw">final boolean PREFAB_PLACE_BLOCK_COMPONENTS = false;
   class="kw">private class="kw">static class="kw">final boolean PREFAB_PLACE_ENTITIES = false;
   class="kw">public class="kw">static class="kw">final Color DEFAULT_TINT = new Color((byte)91, (byte)-98, (byte)40);
   class="kw">public class="kw">static class="kw">final int DEFAULT_PLATFORM_Y = 160;
   class="kw">public class="kw">static class="kw">final int DEFAULT_PLATFORM_HALF_EXTENT = 32;
   class="kw">public class="kw">static class="kw">final int DEFAULT_CLEAR_HEIGHT = 16;
   class="kw">public class="kw">static class="kw">final int DEFAULT_GRID_STRIDE = 16;
   class="kw">public class="kw">static class="kw">final int DEFAULT_PREFAB_CELL_SIZE = 64;
   class="kw">public class="kw">static class="kw">final int DEFAULT_MAX_PREFAB_EXTENT = 32;
   class="kw">public class="kw">static class="kw">final float DEFAULT_PREFAB_DENSITY = 0.4F;
   class="kw">public class="kw">static class="kw">final BuilderCodec<CubicTestWorldGenProvider> CODEC = BuilderCodec.builder(CubicTestWorldGenProvider.class, CubicTestWorldGenProvider::new)
      .documentation("A cubic-aware test generator that produces a flat spawn platform plus an infinite 3D wireframe pattern.")
      .<Color>append(new KeyedCodec<>("Tint", ProtocolCodecs.COLOR), (var0, var1) -> var0.tint = var1, var0 -> var0.tint)
      .documentation("The tint applied to every column.")
      .add()
      .<String>append(new KeyedCodec<>("Environment", Codec.STRING), (var0, var1) -> var0.environment = var1, var0 -> var0.environment)
      .documentation("The environment applied across the legacy column range. Cubic sections do not carry environment data.")
      .addValidator(Environment.VALIDATOR_CACHE.getValidator())
      .add()
      .<String>append(new KeyedCodec<>("PlatformBlockType", Codec.STRING), (var0, var1) -> var0.platformBlockType = var1, var0 -> var0.platformBlockType)
      .documentation("The block type used for the flat spawn platform at PlatformY.")
      .addValidator(Validators.nonNull())
      .addValidator(BlockType.VALIDATOR_CACHE.getValidator())
      .add()
      .<String>append(new KeyedCodec<>("EdgeBlockType", Codec.STRING), (var0, var1) -> var0.edgeBlockType = var1, var0 -> var0.edgeBlockType)
      .documentation("The block type used along the edges of the 3D wireframe grid.")
      .addValidator(Validators.nonNull())
      .addValidator(BlockType.VALIDATOR_CACHE.getValidator())
      .add()
      .<String>append(new KeyedCodec<>("CornerBlockType", Codec.STRING), (var0, var1) -> var0.cornerBlockType = var1, var0 -> var0.cornerBlockType)
      .documentation("The block type used at the corners of the 3D wireframe grid. Falls back to EdgeBlockType if unset.")
      .add()
      .<Integer>append(new KeyedCodec<>("GridStride", Codec.INTEGER), (var0, var1) -> var0.gridStride = var1, var0 -> var0.gridStride)
      .documentation("The spacing in blocks between wireframe lines along each axis. Must be a power of two so chunk boundaries land cleanly on grid lines.")
      .add()
      .<Integer>append(new KeyedCodec<>("PlatformY", Codec.INTEGER), (var0, var1) -> var0.platformY = var1, var0 -> var0.platformY)
      .documentation("The Y coordinate of the flat spawn platform top.")
      .add()
      .<Integer>append(new KeyedCodec<>("PlatformHalfExtent", Codec.INTEGER), (var0, var1) -> var0.platformHalfExtent = var1, var0 -> var0.platformHalfExtent)
      .documentation("Platform spans [-PlatformHalfExtent, PlatformHalfExtent) in both X and Z.")
      .add()
      .<Integer>append(new KeyedCodec<>("ClearHeight", Codec.INTEGER), (var0, var1) -> var0.clearHeight = var1, var0 -> var0.clearHeight)
      .documentation("Vertical extent above and below the platform that is forced to air, so the wireframe never blocks the spawn.")
      .add()
      .<String[]>append(
         new KeyedCodec<>("PrefabPaths", new ArrayCodec<>(Codec.STRING, String[]::new)), (var0, var1) -> var0.prefabPaths = var1, var0 -> var0.prefabPaths
      )
      .documentation("Asset-relative prefab paths (e.g. \"Trees/Oak/Stage_3/Oak_Stage3_001.prefab.json\") to sprinkle deterministically through the world.")
      .add()
      .<Integer>append(new KeyedCodec<>("PrefabCellSize", Codec.INTEGER), (var0, var1) -> var0.prefabCellSize = var1, var0 -> var0.prefabCellSize)
      .documentation("Edge length of the 3D cells used for prefab placement; one cell rolls at most one prefab.")
      .add()
      .<Integer>append(new KeyedCodec<>("MaxPrefabExtent", Codec.INTEGER), (var0, var1) -> var0.maxPrefabExtent = var1, var0 -> var0.maxPrefabExtent)
      .documentation("Maximum half-extent (in blocks) any configured prefab can span from its anchor. Used to bound the cells inspected per section.")
      .add()
      .<Float>append(new KeyedCodec<>("PrefabDensity", Codec.FLOAT), (var0, var1) -> var0.prefabDensity = var1, var0 -> var0.prefabDensity)
      .documentation("Probability [0, 1] that a given spawn cell rolls a prefab.")
      .add()
      .build();
   class="kw">private Color tint = DEFAULT_TINT;
   class="kw">private String environment;
   class="kw">private String platformBlockType;
   class="kw">private String edgeBlockType;
   class="kw">private String cornerBlockType;
   class="kw">private int gridStride = 16;
   class="kw">private int platformY = 160;
   class="kw">private int platformHalfExtent = 32;
   class="kw">private int clearHeight = 16;
   class="kw">private String[] prefabPaths = new String[0];
   class="kw">private int prefabCellSize = 64;
   class="kw">private int maxPrefabExtent = 32;
   class="kw">private float prefabDensity = 0.4F;

   class="kw">public CubicTestWorldGenProvider() {
   }

   @Nonnull
   @Override
   class="kw">public IWorldGen getGenerator() class="kw">throws WorldGenLoadException {
      int var1 = ColorParseUtil.colorToARGBInt(this.tint);
      int var2;
      if (this.environment != null) {
         int var3 = Environment.getAssetMap().getIndex(this.environment);
         if (var3 == Integer.MIN_VALUE) {
            throw new WorldGenLoadException("Unknown environment: " + this.environment);
         }

         var2 = var3;
      } else {
         var2 = 0;
      }

      int var10 = resolveBlock(this.platformBlockType, "PlatformBlockType");
      int var4 = resolveBlock(this.edgeBlockType, "EdgeBlockType");
      int var5 = this.cornerBlockType != null ? resolveBlock(this.cornerBlockType, "CornerBlockType") : var4;
      if (this.gridStride <= 0 || Integer.bitCount(this.gridStride) != 1) {
         throw new WorldGenLoadException("GridStride must be a positive power of two, got " + this.gridStride);
      } else if (this.platformHalfExtent < 0) {
         throw new WorldGenLoadException("PlatformHalfExtent must be non-negative, got " + this.platformHalfExtent);
      } else if (this.clearHeight < 0) {
         throw new WorldGenLoadException("ClearHeight must be non-negative, got " + this.clearHeight);
      } else if (this.prefabCellSize <= 0) {
         throw new WorldGenLoadException("PrefabCellSize must be positive, got " + this.prefabCellSize);
      } else if (this.maxPrefabExtent < 0) {
         throw new WorldGenLoadException("MaxPrefabExtent must be non-negative, got " + this.maxPrefabExtent);
      } else if (!(this.prefabDensity < 0.0F) && !(this.prefabDensity > 1.0F)) {
         BlockSelection[] var6 = this.loadPrefabs();
         int var7 = this.platformHalfExtent + this.maxPrefabExtent;
         int var8 = this.platformY - this.clearHeight - this.maxPrefabExtent;
         int var9 = this.platformY + this.clearHeight + this.maxPrefabExtent;
         class="kw">return new CubicTestWorldGenProvider.CubicTestWorldGen(
            var1,
            var2,
            var10,
            var4,
            var5,
            this.gridStride,
            this.platformY,
            this.platformHalfExtent,
            this.clearHeight,
            var6,
            this.prefabPaths,
            this.prefabCellSize,
            this.maxPrefabExtent,
            this.prefabDensity,
            var7,
            var8,
            var9
         );
      } else {
         throw new WorldGenLoadException("PrefabDensity must be in [0, 1], got " + this.prefabDensity);
      }
   }

   class="kw">private BlockSelection[] loadPrefabs() class="kw">throws WorldGenLoadException {
      if (this.prefabPaths.length == 0) {
         class="kw">return new BlockSelection[0];
      }

      BlockSelection[] var1 = new BlockSelection[this.prefabPaths.length];

      for (int var2 = 0; var2 < this.prefabPaths.length; var2++) {
         try {
            var1[var2] = PrefabStore.get().getAssetPrefab(this.prefabPaths[var2]);
         } catch (PrefabLoadException var4) {
            throw new WorldGenLoadException("Failed to load prefab " + this.prefabPaths[var2], var4);
         }
      }

      class="kw">return var1;
   }

   class="kw">private class="kw">static int resolveBlock(@Nullable String var0, @Nonnull String var1) class="kw">throws WorldGenLoadException {
      if (var0 == null) {
         throw new WorldGenLoadException(var1 + " must be set.");
      } else {
         int var2 = BlockType.getAssetMap().getIndex(var0);
         if (var2 == Integer.MIN_VALUE) {
            throw new WorldGenLoadException("Unknown " + var1 + ": " + var0);
         } else {
            class="kw">return var2;
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "CubicTestWorldGenProvider{tint="
         + this.tint
         + ", environment='"
         + this.environment
         + "', platformBlockType='"
         + this.platformBlockType
         + "', edgeBlockType='"
         + this.edgeBlockType
         + "', cornerBlockType='"
         + this.cornerBlockType
         + "', gridStride="
         + this.gridStride
         + ", platformY="
         + this.platformY
         + ", platformHalfExtent="
         + this.platformHalfExtent
         + ", clearHeight="
         + this.clearHeight
         + ", prefabPaths="
         + Arrays.toString(this.prefabPaths)
         + ", prefabCellSize="
         + this.prefabCellSize
         + ", maxPrefabExtent="
         + this.maxPrefabExtent
         + ", prefabDensity="
         + this.prefabDensity
         + "}";
   }

   @FunctionalInterface
   class="kw">private class="kw">interface BlockSink {
      void put(int var1, int var2, int var3, int var4, int var5, int var6);
   }

   class="kw">private class="kw">static class CubicTestWorldGen class="kw">implements IWorldGen.Cubic {
      class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
      class="kw">private class="kw">final int tintId;
      class="kw">private class="kw">final int environmentId;
      class="kw">private class="kw">final int platformBlockId;
      class="kw">private class="kw">final int edgeBlockId;
      class="kw">private class="kw">final int cornerBlockId;
      class="kw">private class="kw">final int gridStride;
      class="kw">private class="kw">final int gridStrideMask;
      class="kw">private class="kw">final int platformY;
      class="kw">private class="kw">final int platformHalfExtent;
      class="kw">private class="kw">final int clearHeight;
      class="kw">private class="kw">final BlockSelection[] prefabs;
      class="kw">private class="kw">final String[] prefabPaths;
      class="kw">private class="kw">final int prefabCellSize;
      class="kw">private class="kw">final int maxPrefabExtent;
      class="kw">private class="kw">final float prefabDensity;
      class="kw">private class="kw">final int spawnSuppressXZ;
      class="kw">private class="kw">final int spawnSuppressYMin;
      class="kw">private class="kw">final int spawnSuppressYMax;

      CubicTestWorldGen(
         int var1,
         int var2,
         int var3,
         int var4,
         int var5,
         int var6,
         int var7,
         int var8,
         int var9,
         @Nonnull BlockSelection[] var10,
         @Nonnull String[] var11,
         int var12,
         int var13,
         float var14,
         int var15,
         int var16,
         int var17
      ) {
         this.tintId = var1;
         this.environmentId = var2;
         this.platformBlockId = var3;
         this.edgeBlockId = var4;
         this.cornerBlockId = var5;
         this.gridStride = var6;
         this.gridStrideMask = var6 - 1;
         this.platformY = var7;
         this.platformHalfExtent = var8;
         this.clearHeight = var9;
         this.prefabs = var10;
         this.prefabPaths = var11;
         this.prefabCellSize = var12;
         this.maxPrefabExtent = var13;
         this.prefabDensity = var14;
         this.spawnSuppressXZ = var15;
         this.spawnSuppressYMin = var16;
         this.spawnSuppressYMax = var17;
      }

      @Nullable
      @Override
      class="kw">public WorldGenTimingsCollector getTimings() {
         class="kw">return null;
      }

      @Nonnull
      @Override
      class="kw">public Transform[] getSpawnPoints(int var1) {
         class="kw">return new Transform[]{new Transform(0.5, this.platformY + 1.0F, 0.5)};
      }

      @Nonnull
      @Override
      class="kw">public ISpawnProvider getDefaultSpawnProvider(int var1) {
         class="kw">return new IndividualSpawnProvider(this.getSpawnPoints(var1));
      }

      @Nonnull
      @Override
      class="kw">public CompletableFuture<GeneratedChunk> generate(int var1, long var2, int var4, int var5, LongPredicate var6, Long2FloatFunction var7) {
         GeneratedBlockChunk var8 = new GeneratedBlockChunk(var2, var4, var5);
         Holder[] var9 = GeneratedChunk.makeSections();

         for (int var10 = 0; var10 < 32; var10++) {
            for (int var11 = 0; var11 < 32; var11++) {
               var8.setTint(var10, var11, this.tintId);
               if (this.environmentId != 0) {
                  var8.setEnvironmentColumn(var10, var11, this.environmentId);
               }
            }
         }

         int var19 = var4 << 5;
         int var20 = var5 << 5;

         for (int var12 = 0; var12 < 32; var12++) {
            int var13 = var19 + var12;

            for (int var14 = 0; var14 < 32; var14++) {
               int var15 = var20 + var14;
               boolean var16 = this.inPlatformXZ(var13, var15);

               for (int var17 = 0; var17 < 320; var17++) {
                  int var18 = this.blockAt(var13, var17, var15, var16);
                  if (var18 != 0) {
                     var8.setBlock(var12, var17, var14, var18, 0, 0);
                  }
               }
            }
         }

         this.applyPrefabs(
            var1,
            var19,
            0,
            var20,
            var19 + 32,
            320,
            var20 + 32,
            (var3, var4x, var5x, var6x, var7x, var8x) -> var8.setBlock(var3 - var19, var4x, var5x - var20, var6x, var7x, var8x),
            (var3, var4x, var5x, var6x, var7x) -> {
               int var8 = ChunkUtil.indexSection(var4x);
               int var9 = var4x & 31;
               FluidSection var10 = var9[var8].ensureAndGetComponent(FluidSection.getComponentType());
               var10.setFluid(var3 - var19, var9, var5x - var20, var6x, var7x);
            }
         );
         class="kw">return CompletableFuture.completedFuture(new GeneratedChunk(var8, new GeneratedEntityChunk(), var9));
      }

      @Nonnull
      @Override
      class="kw">public CompletableFuture<Holder<ChunkStore>> generate(
         int var1, int var2, int var3, int var4, IWorldGen.StillNeededSection var5, IWorldGen.SectionPriority var6
      ) {
         GeneratedChunkSection var7 = new GeneratedChunkSection();
         int var8 = var2 << 5;
         int var9 = var3 << 5;
         int var10 = var4 << 5;

         for (int var11 = 0; var11 < 32; var11++) {
            int var12 = var9 + var11;

            for (int var13 = 0; var13 < 32; var13++) {
               int var14 = var10 + var13;

               for (int var15 = 0; var15 < 32; var15++) {
                  int var16 = var8 + var15;
                  int var17 = this.wireframeAt(var16, var12, var14);
                  if (var17 != 0) {
                     var7.setBlock(var15, var11, var13, var17, 0, 0);
                  }
               }
            }
         }

         Holder var18 = ChunkStore.REGISTRY.newHolder();
         this.applyPrefabs(
            var1,
            var8,
            var9,
            var10,
            var8 + 32,
            var9 + 32,
            var10 + 32,
            (var4x, var5x, var6x, var7x, var8x, var9x) -> var7.setBlock(var4x - var8, var5x - var9, var6x - var10, var7x, var8x, var9x),
            (var4x, var5x, var6x, var7x, var8x) -> {
               FluidSection var9 = var18.ensureAndGetComponent(FluidSection.getComponentType());
               var9.setFluid(var4x - var8, var5x - var9, var6x - var10, var7x, var8x);
            }
         );
         var18.putComponent(BlockSection.getComponentType(), var7.toChunkSection());
         class="kw">return CompletableFuture.completedFuture(var18);
      }

      class="kw">private int blockAt(int var1, int var2, int var3, boolean var4) {
         if (var4) {
            if (var2 == this.platformY) {
               class="kw">return this.platformBlockId;
            }

            if (var2 > this.platformY - this.clearHeight && var2 < this.platformY + this.clearHeight) {
               class="kw">return 0;
            }
         }

         class="kw">return this.wireframeAt(var1, var2, var3);
      }

      class="kw">private int wireframeAt(int var1, int var2, int var3) {
         int var4 = (var1 & this.gridStrideMask) == 0 ? 1 : 0;
         int var5 = (var2 & this.gridStrideMask) == 0 ? 1 : 0;
         int var6 = (var3 & this.gridStrideMask) == 0 ? 1 : 0;
         int var7 = var4 + var5 + var6;
         if (var7 == 3) {
            class="kw">return this.cornerBlockId;
         } else {
            class="kw">return var7 == 2 ? this.edgeBlockId : 0;
         }
      }

      class="kw">private boolean inPlatformXZ(int var1, int var2) {
         class="kw">return var1 >= -this.platformHalfExtent && var1 < this.platformHalfExtent && var2 >= -this.platformHalfExtent && var2 < this.platformHalfExtent;
      }

      class="kw">private void applyPrefabs(
         int var1,
         int var2,
         int var3,
         int var4,
         int var5,
         int var6,
         int var7,
         @Nonnull CubicTestWorldGenProvider.BlockSink var8,
         @Nonnull CubicTestWorldGenProvider.FluidSink var9
      ) {
         if (this.prefabs.length != 0) {
            int var10 = Math.floorDiv(var2 - this.maxPrefabExtent, this.prefabCellSize);
            int var11 = Math.floorDiv(var5 + this.maxPrefabExtent - 1, this.prefabCellSize);
            int var12 = Math.floorDiv(var3 - this.maxPrefabExtent, this.prefabCellSize);
            int var13 = Math.floorDiv(var6 + this.maxPrefabExtent - 1, this.prefabCellSize);
            int var14 = Math.floorDiv(var4 - this.maxPrefabExtent, this.prefabCellSize);
            int var15 = Math.floorDiv(var7 + this.maxPrefabExtent - 1, this.prefabCellSize);

            for (int var16 = var10; var16 <= var11; var16++) {
               for (int var17 = var12; var17 <= var13; var17++) {
                  for (int var18 = var14; var18 <= var15; var18++) {
                     this.applyPrefabCell(var1, var16, var17, var18, var2, var3, var4, var5, var6, var7, var8, var9);
                  }
               }
            }
         }
      }

      class="kw">private void applyPrefabCell(
         int var1,
         int var2,
         int var3,
         int var4,
         int var5,
         int var6,
         int var7,
         int var8,
         int var9,
         int var10,
         @Nonnull CubicTestWorldGenProvider.BlockSink var11,
         @Nonnull CubicTestWorldGenProvider.FluidSink var12
      ) {
         int var13 = GeneralNoise.hash3D(var1, var2, var3, var4);
         Random var14 = new Random(var13);
         if (!(var14.nextFloat() >= this.prefabDensity)) {
            int var15 = var14.nextInt(this.prefabs.length);
            int var16 = var2 * this.prefabCellSize + var14.nextInt(this.prefabCellSize);
            int var17 = var3 * this.prefabCellSize + var14.nextInt(this.prefabCellSize);
            int var18 = var4 * this.prefabCellSize + var14.nextInt(this.prefabCellSize);
            if (!this.isInSpawnKeepOut(var16, var17, var18)) {
               BlockSelection var19 = this.prefabs[var15];
               int var20 = var16 - var19.getAnchorX();
               int var21 = var17 - var19.getAnchorY();
               int var22 = var18 - var19.getAnchorZ();
               var19.forEachBlock(
                  (var15x, var16x, var17x, var18x) -> {
                     int var19 = var15x + var20;
                     int var20 = var16x + var21;
                     int var21 = var17x + var22;
                     if (var19 >= var5 && var19 < var8 && var20 >= var6 && var20 < var9 && var21 >= var7 && var21 < var10) {
                        if (Math.abs(var19 - var16) > this.maxPrefabExtent
                           || Math.abs(var20 - var17) > this.maxPrefabExtent
                           || Math.abs(var21 - var18) > this.maxPrefabExtent) {
                           LOGGER.at(Level.WARNING)
                              .log(
                                 "Prefab %s contains a block at offset (%d, %d, %d) beyond MaxPrefabExtent=%d; bump MaxPrefabExtent to render it correctly.",
                                 this.prefabPaths[var15],
                                 var19 - var16,
                                 var20 - var17,
                                 var21 - var18,
                                 this.maxPrefabExtent
                              );
                        } else if (var18x.blockId() != 0) {
                           var11.put(var19, var20, var21, var18x.blockId(), var18x.rotation(), var18x.filler());
                        }
                     }
                  }
               );
               var19.forEachFluid(
                  (var14x, var15x, var16x, var17x, var18x) -> {
                     if (var18x != 0) {
                        int var19 = var14x + var20;
                        int var20 = var15x + var21;
                        int var21 = var16x + var22;
                        if (var19 >= var5 && var19 < var8 && var20 >= var6 && var20 < var9 && var21 >= var7 && var21 < var10) {
                           if (Math.abs(var19 - var16) <= this.maxPrefabExtent
                              && Math.abs(var20 - var17) <= this.maxPrefabExtent
                              && Math.abs(var21 - var18) <= this.maxPrefabExtent) {
                              var12.put(var19, var20, var21, var17x, var18x);
                           }
                        }
                     }
                  }
               );
            }
         }
      }

      class="kw">private boolean isInSpawnKeepOut(int var1, int var2, int var3) {
         class="kw">return var1 >= -this.spawnSuppressXZ
            && var1 < this.spawnSuppressXZ
            && var3 >= -this.spawnSuppressXZ
            && var3 < this.spawnSuppressXZ
            && var2 >= this.spawnSuppressYMin
            && var2 < this.spawnSuppressYMax;
      }
   }

   @FunctionalInterface
   class="kw">private class="kw">interface FluidSink {
      void put(int var1, int var2, int var3, int var4, byte var5);
   }
}