class="kw">package com.hypixel.hytale.server.worldgen.chunk.populator;

class="kw">import com.hypixel.hytale.math.util.FastRandom;
class="kw">import com.hypixel.hytale.math.util.HashUtil;
class="kw">import com.hypixel.hytale.procedurallib.condition.ConstantIntCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.IBlockFluidCondition;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedBlockChunk;
class="kw">import com.hypixel.hytale.server.worldgen.biome.Biome;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGenerator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGeneratorExecution;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.HeightThresholdInterpolator;
class="kw">import com.hypixel.hytale.server.worldgen.container.CoverContainer;
class="kw">import com.hypixel.hytale.server.worldgen.container.LayerContainer;
class="kw">import com.hypixel.hytale.server.worldgen.container.WaterContainer;
class="kw">import com.hypixel.hytale.server.worldgen.util.BlockFluidEntry;
class="kw">import com.hypixel.hytale.server.worldgen.util.NoiseBlockArray;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
class="kw">import java.util.Random;
class="kw">import javax.annotation.Nonnull;

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

   class="kw">public class="kw">static void populate(int var0, @Nonnull ChunkGeneratorExecution var1) {
      Random var2 = new FastRandom(HashUtil.hash(var0, var1.getX(), var1.getZ(), 5647422603192711886L));

      for (int var3 = 0; var3 < 32; var3++) {
         for (int var4 = 0; var4 < 32; var4++) {
            generateBlockColumn(var0, var1, var3, var4, var2);
         }
      }
   }

   class="kw">private class="kw">static void generateBlockColumn(int var0, @Nonnull ChunkGeneratorExecution var1, int var2, int var3, @Nonnull Random var4) {
      HeightThresholdInterpolator var5 = var1.getInterpolator();
      IntList var6 = ChunkGenerator.getResource().coverArray;
      Biome var7 = var1.zoneBiomeResult(var2, var3).getBiome();
      LayerContainer var8 = var7.getLayerContainer();
      int var9 = var1.globalX(var2);
      int var10 = var1.globalZ(var3);
      double var11 = var5.getHeightNoise(var2, var3);
      BlockFluidEntry var13 = var8.getFilling();
      int var14 = var8.getFillingEnvironment();
      int var15 = 0;
      int var16 = var5.getLowestNonOne(var2, var3);
      int var17 = var5.getHighestNonZero(var2, var3);
      boolean var18 = true;

      while (var17 >= var16) {
         double var19 = var5.getHeightThreshold(var0, var9, var10, var17);
         if (!(var19 > var11) && var19 != 1.0) {
            var18 = true;
         } else {
            if (var17 > var15) {
               var15 = var17;
            }

            var1.setBlock(var2, var17, var3, (byte)1, var13, var14);
            if (var18) {
               var6.add(var17);
               var18 = false;
            }
         }

         var17--;
      }

      if (var18) {
         var6.add(var17);
      }

      if (var17 > var15) {
         var15 = var17;
      }

      while (var17 >= 0) {
         var1.setBlock(var2, var17, var3, (byte)1, var13);
         var17--;
      }

      var1.getChunkGenerator().putHeight(var0, var9, var10, var15);
      BlockPopulator.LayerPopulator.generateLayers(var0, var1, var2, var3, var9, var10, var7, var6);
      generateCovers(var0, var1, var2, var3, var9, var10, var4, var7, var6);
      var6.clear();
   }

   class="kw">private class="kw">static void generateCovers(
      int var0, @Nonnull ChunkGeneratorExecution var1, int var2, int var3, int var4, int var5, @Nonnull Random var6, @Nonnull Biome var7, @Nonnull IntList var8
   ) {
      CoverContainer var9 = var7.getCoverContainer();
      int var10 = var8.size();
      if (var10 != 0) {
         for (WaterContainer.Entry var14 : var7.getWaterContainer().getEntries()) {
            for (CoverContainer.CoverContainerEntry var18 : var9.getEntries()) {
               if (var18.isOnWater() && isMatchingCoverColumn(var0, var18, var6, var4, var5)) {
                  int var19 = var14.getMax(var0, var4, var5) + 1;
                  if (isMatchingCoverHeight(var0, var18, var6, var4, var19, var5)
                     && isMatchingParentCover(var1, var18, var2, var3, var19, var14.getBlock(), var14.getFluid())) {
                     CoverContainer.CoverContainerEntry.CoverContainerEntryPart var20 = var18.get(var6);
                     var1.setBlock(var2, var19 + var20.getOffset(), var3, (byte)3, var20.getEntry());
                     var1.setFluid(var2, var19 + var20.getOffset(), var3, (byte)3, var20.getEntry().fluidId());
                  }
               }
            }
         }

         for (int var21 = 0; var21 < var10; var21++) {
            int var22 = var8.getInt(var21) + 1;

            for (CoverContainer.CoverContainerEntry var26 : var9.getEntries()) {
               if (!var26.isOnWater()
                  && isMatchingParentCover(var1, var26, var2, var3, var22, 0, 0)
                  && isMatchingCoverColumn(var0, var26, var6, var4, var5)
                  && isMatchingCoverHeight(var0, var26, var6, var4, var22, var5)) {
                  CoverContainer.CoverContainerEntry.CoverContainerEntryPart var27 = var26.get(var6);
                  var1.setBlock(var2, var22 + var27.getOffset(), var3, (byte)3, var27.getEntry());
                  var1.setFluid(var2, var22 + var27.getOffset(), var3, (byte)3, var27.getEntry().fluidId());
               }
            }
         }
      }
   }

   class="kw">private class="kw">static boolean isMatchingParentCover(
      @Nonnull ChunkGeneratorExecution var0, @Nonnull CoverContainer.CoverContainerEntry var1, int var2, int var3, int var4, int var5, int var6
   ) {
      if (var4 > 0 && var4 < 320) {
         IBlockFluidCondition var7 = var1.getParentCondition();
         if (var7 == ConstantIntCondition.DEFAULT_TRUE) {
            class="kw">return true;
         }

         if (var7 == ConstantIntCondition.DEFAULT_FALSE) {
            class="kw">return false;
         }

         GeneratedBlockChunk var8 = var0.getChunk();
         int var9 = var8.getBlock(var2, var4 - 1, var3);
         if (var9 == 0) {
            var9 = var5;
         }

         int var10 = var0.getFluid(var2, var4 - 1, var3);
         if (var10 == 0) {
            var10 = var6;
         }

         class="kw">return var7.eval(var9, var10);
      } else {
         class="kw">return false;
      }
   }

   class="kw">private class="kw">static boolean isMatchingCoverColumn(int var0, @Nonnull CoverContainer.CoverContainerEntry var1, @Nonnull Random var2, int var3, int var4) {
      class="kw">return var2.nextDouble() < var1.getCoverDensity() && var1.getMapCondition().eval(var0, var3, var4);
   }

   class="kw">private class="kw">static boolean isMatchingCoverHeight(int var0, @Nonnull CoverContainer.CoverContainerEntry var1, Random var2, int var3, int var4, int var5) {
      class="kw">return var1.getHeightCondition().eval(var0, var3, var5, var4, var2);
   }

   class="kw">private class="kw">static class LayerPopulator {
      class="kw">private LayerPopulator() {
      }

      class="kw">static void generateLayers(
         int var0, @Nonnull ChunkGeneratorExecution var1, int var2, int var3, int var4, int var5, @Nonnull Biome var6, @Nonnull IntList var7
      ) {
         generateStaticLayers(var0, var1, var2, var3, var4, var5, var6);
         generateDynamicLayers(var0, var1, var2, var3, var4, var5, var6, var7);
      }

      class="kw">private class="kw">static void generateDynamicLayers(
         int var0, @Nonnull ChunkGeneratorExecution var1, int var2, int var3, int var4, int var5, @Nonnull Biome var6, @Nonnull IntList var7
      ) {
         LayerContainer var8 = var6.getLayerContainer();
         int var9 = 0;

         for (int var10 = var7.size(); var9 < var10; var9++) {
            int var11 = var7.getInt(var9);
            int var12 = var11;
            int var13 = var11;

            label47:
            for (LayerContainer.DynamicLayer var17 : var8.getDynamicLayers()) {
               LayerContainer.DynamicLayerEntry var18 = var17.getActiveEntry(var0, var4, var5);
               if (var18 != null) {
                  int var19 = var17.getEnvironmentId();
                  var12 += var17.getOffset(var0, var4, var5);
                  var13 = Math.max(var13, var12);
                  NoiseBlockArray var20 = var18.getBlockArray();

                  for (NoiseBlockArray.Entry var24 : var20.getEntries()) {
                     int var25 = var24.getRepetitions(var0, var4, var5);

                     for (int var26 = 0; var26 < var25; var26++) {
                        if (var12 <= var11 && var1.getBlock(var2, var12, var3) == 0) {
                           break label47;
                        }

                        var1.setBlock(var2, var12, var3, (byte)2, var24.getBlockEntry(), var19);
                        var1.setFluid(var2, var12, var3, (byte)2, var24.getBlockEntry().fluidId(), var19);
                        var12--;
                     }
                  }
               }
            }

            if (var13 > var11) {
               var7.set(var9, var13);
            }
         }
      }

      class="kw">private class="kw">static void generateStaticLayers(int var0, @Nonnull ChunkGeneratorExecution var1, int var2, int var3, int var4, int var5, @Nonnull Biome var6) {
         LayerContainer var7 = var6.getLayerContainer();

         for (LayerContainer.StaticLayer var11 : var7.getStaticLayers()) {
            LayerContainer.StaticLayerEntry var12 = var11.getActiveEntry(var0, var4, var5);
            if (var12 != null) {
               int var13 = var11.getEnvironmentId();
               NoiseBlockArray.Entry[] var14 = var12.getBlockArray().getEntries();
               int var15 = Math.max(var12.getMinInt(var0, var4, var5), 0);
               int var16 = Math.min(var12.getMaxInt(var0, var4, var5), 320);
               int var17 = var12.getMaxInt(var0, var4, var5);
               BlockFluidEntry var18 = null;

               for (NoiseBlockArray.Entry var22 : var14) {
                  int var23 = var22.getRepetitions(var0, var4, var5);
                  if (var23 > 0) {
                     BlockFluidEntry var24 = var22.getBlockEntry();
                     var18 = var24;

                     for (int var25 = 0; var25 < var23; var25++) {
                        int var26 = var1.getBlock(var2, --var17, var3);
                        if (var26 != 0) {
                           var1.setBlock(var2, var17, var3, (byte)2, var24, var13);
                           var1.setFluid(var2, var17, var3, (byte)2, var24.fluidId(), var13);
                        }

                        if (var17 <= var15) {
                           class="kw">return;
                        }
                     }
                  }
               }

               if (var14.length == 0 && var13 != Integer.MIN_VALUE) {
                  for (int var27 = var16 - 1; var27 >= var15; var27--) {
                     var1.setEnvironment(var2, var27, var3, var13);
                  }
               }

               if (var18 != null) {
                  while (var17 > var15) {
                     int var28 = var1.getBlock(var2, --var17, var3);
                     if (var28 != 0) {
                        var1.setBlock(var2, var17, var3, (byte)2, var18);
                        var1.setFluid(var2, var17, var3, (byte)2, var18.fluidId());
                     }
                  }
               }
            }
         }
      }
   }
}