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

class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
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.GeneratedEntityChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenTimingsCollector;
class="kw">import com.hypixel.hytale.server.worldgen.cache.CoreDataCacheEntry;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.populator.BlockPopulator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.populator.CavePopulator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.populator.PrefabPopulator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.populator.WaterPopulator;
class="kw">import com.hypixel.hytale.server.worldgen.util.BlockFluidEntry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ChunkGeneratorExecution {
   @Nonnull
   class="kw">private class="kw">final ChunkGenerator chunkGenerator;
   class="kw">private class="kw">final GeneratedChunk chunk;
   class="kw">private class="kw">final GeneratedBlockChunk blockChunk;
   class="kw">private class="kw">final GeneratedEntityChunk entityChunk;
   class="kw">private class="kw">final Holder<ChunkStore>[] sections;
   @Nonnull
   class="kw">private class="kw">final BlockPriorityChunk priorityChunk;
   @Nonnull
   class="kw">private class="kw">final HeightThresholdInterpolator interpolator;
   class="kw">private BlockPriorityModifier blockPriorityModifier = BlockPriorityModifier.NONE;

   class="kw">public ChunkGeneratorExecution(int var1, @Nonnull ChunkGenerator var2, GeneratedChunk var3) {
      this.chunkGenerator = var2;
      this.chunk = var3;
      this.blockChunk = var3.getBlockChunk();
      this.entityChunk = var3.getEntityChunk();
      this.sections = var3.getSections();
      this.priorityChunk = ChunkGenerator.getResource().priorityChunk.reset();
      long var4 = -System.nanoTime();
      this.interpolator = new HeightThresholdInterpolator(this).populate(var1);
      var2.getTimings().reportPrepare(var4 + System.nanoTime());
   }

   class="kw">public void execute(int var1) {
      WorldGenTimingsCollector var2 = this.chunkGenerator.getTimings();
      this.generateTintMapping(var1);
      this.generateEnvironmentMapping(var1);
      long var3 = -System.nanoTime();
      BlockPopulator.populate(var1, this);
      var2.reportBlocksGeneration(var3 + System.nanoTime());
      var3 = -System.nanoTime();
      CavePopulator.populate(var1, this);
      var2.reportCaveGeneration(var3 + System.nanoTime());
      var3 = -System.nanoTime();
      PrefabPopulator.populate(var1, this);
      var2.reportPrefabGeneration(var3 + System.nanoTime());
      WaterPopulator.populate(var1, this);
   }

   @Nonnull
   class="kw">public ChunkGenerator getChunkGenerator() {
      class="kw">return this.chunkGenerator;
   }

   class="kw">public GeneratedBlockChunk getChunk() {
      class="kw">return this.blockChunk;
   }

   class="kw">public GeneratedEntityChunk getEntityChunk() {
      class="kw">return this.entityChunk;
   }

   @Nonnull
   class="kw">public BlockPriorityChunk getPriorityChunk() {
      class="kw">return this.priorityChunk;
   }

   @Nonnull
   class="kw">public HeightThresholdInterpolator getInterpolator() {
      class="kw">return this.interpolator;
   }

   class="kw">public Holder<ChunkStore> getSection(int var1) {
      class="kw">return this.sections[var1];
   }

   class="kw">public ZoneBiomeResult zoneBiomeResult(int var1, int var2) {
      class="kw">return this.interpolator.zoneBiomeResult(var1, var2);
   }

   @Nonnull
   class="kw">public CoreDataCacheEntry[] getCoreDataEntries() {
      class="kw">return this.interpolator.getEntries();
   }

   class="kw">public long getIndex() {
      class="kw">return this.blockChunk.getIndex();
   }

   class="kw">public int getX() {
      class="kw">return this.blockChunk.getX();
   }

   class="kw">public int getZ() {
      class="kw">return this.blockChunk.getZ();
   }

   class="kw">public void setPriorityModifier(BlockPriorityModifier var1) {
      this.blockPriorityModifier = var1;
   }

   class="kw">public int getHeight(int var1, int var2, int var3) {
      if (ChunkUtil.isInsideChunk(this.getX(), this.getZ(), var2, var3)) {
         int var4 = var2 & 31;
         int var5 = var3 & 31;
         class="kw">return this.interpolator.tableEntry(var4, var5).height;
      } else {
         class="kw">return this.chunkGenerator.getHeight(var1, var2, var3);
      }
   }

   class="kw">private void generateTintMapping(int var1) {
      int var2 = 4;
      int[] var3 = new int[(32 + var2 * 2) * (32 + var2 * 2)];
      int var4 = 32 + var2;

      for (int var5 = -var2; var5 < var4; var5++) {
         for (int var6 = -var2; var6 < var4; var6++) {
            var3[tintIndexLocal(var5, var6)] = this.zoneBiomeResult(var5, var6)
               .getBiome()
               .getTintContainer()
               .getTintColorAt(var1, this.globalX(var5), this.globalZ(var6));
         }
      }

      var4 = var2 * var2;

      for (int var15 = 0; var15 < 32; var15++) {
         for (int var16 = 0; var16 < 32; var16++) {
            int var7 = 0;
            int var8 = 0;
            int var9 = 0;
            int var10 = 0;

            for (int var11 = -var2; var11 <= var2; var11++) {
               for (int var12 = -var2; var12 <= var2; var12++) {
                  if (var11 * var11 + var12 * var12 <= var4) {
                     int var13 = var3[tintIndexLocal(var15 + var11, var16 + var12)];
                     var7 += var13 >> 16 & 0xFF;
                     var8 += var13 >> 8 & 0xFF;
                     var9 += var13 & 0xFF;
                     var10++;
                  }
               }
            }

            if (var10 > 0) {
               var7 /= var10;
               var8 /= var10;
               var9 /= var10;
               this.blockChunk.setTint(var15, var16, 0xFF000000 | var7 << 16 | var8 << 8 | var9);
            } else {
               this.blockChunk.setTint(var15, var16, -65536);
            }
         }
      }
   }

   class="kw">public class="kw">static int tintIndexLocal(int var0, int var1) {
      class="kw">return (var0 + 4) * 40 + var1 + 4;
   }

   class="kw">private void generateEnvironmentMapping(int var1) {
      for (int var2 = 0; var2 < 32; var2++) {
         for (int var3 = 0; var3 < 32; var3++) {
            int var4 = this.zoneBiomeResult(var2, var3).getBiome().getEnvironmentContainer().getEnvironmentAt(var1, this.globalX(var2), this.globalZ(var3));
            this.blockChunk.setEnvironmentColumn(var2, var3, var4);
         }
      }
   }

   class="kw">public int getBlock(int var1, int var2, int var3) {
      class="kw">return this.blockChunk.getBlock(var1, var2, var3);
   }

   class="kw">public int getRotationIndex(int var1, int var2, int var3) {
      class="kw">return this.blockChunk.getRotationIndex(var1, var2, var3);
   }

   class="kw">public void setEnvironment(int var1, int var2, int var3, int var4) {
      if (var4 != Integer.MIN_VALUE) {
         this.blockChunk.setEnvironment(var1, var2, var3, var4);
      }
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, int var5) {
      class="kw">return this.setBlock(var1, var2, var3, var4, var5, null);
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, BlockFluidEntry var5) {
      class="kw">return this.setBlock(var1, var2, var3, var4, var5.blockId(), null, -1, var5.rotation(), 0);
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, int var5, int var6) {
      if (this.setBlock(var1, var2, var3, var4, var5, null)) {
         this.setEnvironment(var1, var2, var3, var6);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, BlockFluidEntry var5, int var6) {
      if (this.setBlock(var1, var2, var3, var4, var5.blockId(), null, -1, var5.rotation(), 0)) {
         this.setEnvironment(var1, var2, var3, var6);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, int var5, Holder<ChunkStore> var6) {
      class="kw">return this.setBlock(var1, var2, var3, var4, var5, var6, -1, 0, 0);
   }

   class="kw">public boolean setBlock(int var1, int var2, int var3, byte var4, int var5, @Nullable Holder<ChunkStore> var6, int var7, int var8, int var9) {
      if (var2 >= 0 && var2 < 320) {
         byte var10 = (byte)(var4 & 31);
         byte var11 = (byte)(var4 & -32);
         byte var12 = this.priorityChunk.get(var1, var2, var3);
         byte var13 = this.blockPriorityModifier.modifyCurrent(var12, var10);
         if (var4 == -1) {
            var10 = var13;
         }

         if (var10 < var13) {
            class="kw">return false;
         }

         var10 = (byte)(this.blockPriorityModifier.modifyTarget(var12, var10) | var11);
         this.priorityChunk.set(var1, var2, var3, var10);
         this.blockChunk.setBlock(var1, var2, var3, var5, var8, var9);
         this.chunk.setState(var1, var2, var3, var6);
         Holder var14 = this.getSection(ChunkUtil.chunkCoordinate(var2));
         if (var7 >= 0) {
            BlockPhysics.setSupportValue(var14, var1, var2, var3, var7);
         } else {
            BlockType var15 = BlockType.getAssetMap().getAsset(var5);
            if (var15 != null && var15.hasSupport()) {
               BlockPhysics.reset(var14, var1, var2, var3);
            } else {
               BlockPhysics.clear(var14, var1, var2, var3);
            }
         }

         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setFluid(int var1, int var2, int var3, byte var4, int var5, int var6) {
      if (this.setFluid(var1, var2, var3, var4, var5)) {
         this.setEnvironment(var1, var2, var3, var6);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setFluid(int var1, int var2, int var3, byte var4, int var5) {
      class="kw">return this.setFluid(var1, var2, var3, var4, var5, (byte)Fluid.getAssetMap().getAssetOrDefault(var5, Fluid.EMPTY).getMaxFluidLevel());
   }

   class="kw">public boolean setFluid(int var1, int var2, int var3, byte var4, int var5, byte var6) {
      if (var2 >= 0 && var2 < 320) {
         byte var7 = (byte)(var4 & 31);
         byte var8 = (byte)(var4 & -32);
         byte var9 = this.priorityChunk.get(var1, var2, var3);
         byte var10 = this.blockPriorityModifier.modifyCurrent(var9, var7);
         if (var4 == -1) {
            var7 = var10;
         }

         if (var7 >= var10) {
            var7 = (byte)(this.blockPriorityModifier.modifyTarget(var9, var7) | var8);
            this.priorityChunk.set(var1, var2, var3, var7);
            Holder var11 = this.getSection(ChunkUtil.chunkCoordinate(var2));
            FluidSection var12 = var11.getComponent(FluidSection.getComponentType());
            if (var12 == null) {
               var12 = var11.ensureAndGetComponent(FluidSection.getComponentType());
            }

            var12.setFluid(var1, var2, var3, var5, var6);
            class="kw">return true;
         } else {
            class="kw">return false;
         }
      } else {
         class="kw">return false;
      }
   }

   class="kw">public int getFluid(int var1, int var2, int var3) {
      if (var2 >= 0 && var2 < 320) {
         Holder var4 = this.getSection(ChunkUtil.chunkCoordinate(var2));
         FluidSection var5 = var4.ensureAndGetComponent(FluidSection.getComponentType());
         class="kw">return var5.getFluidId(var1, var2, var3);
      } else {
         class="kw">return Integer.MIN_VALUE;
      }
   }

   class="kw">public void overrideBlock(int var1, int var2, int var3, byte var4, int var5) {
      this.overrideBlock(var1, var2, var3, var4, var5, null);
   }

   class="kw">public void overrideBlock(int var1, int var2, int var3, byte var4, int var5, Holder<ChunkStore> var6) {
      this.overrideBlock(var1, var2, var3, var4, var5, var6, 0, 0);
   }

   class="kw">public void overrideBlock(int var1, int var2, int var3, byte var4, BlockFluidEntry var5) {
      this.overrideBlock(var1, var2, var3, var4, var5.blockId(), null, var5.rotation(), 0);
   }

   class="kw">public void overrideBlock(int var1, int var2, int var3, byte var4, int var5, Holder<ChunkStore> var6, int var7, int var8) {
      this.priorityChunk.set(var1, var2, var3, var4);
      this.blockChunk.setBlock(var1, var2, var3, var5, var7, var8);
      this.chunk.setState(var1, var2, var3, var6);
      Holder var9 = this.getSection(ChunkUtil.chunkCoordinate(var2));
      BlockType var10 = BlockType.getAssetMap().getAsset(var5);
      if (var10 != null && var10.hasSupport()) {
         BlockPhysics.reset(var9, var1, var2, var3);
      } else {
         BlockPhysics.clear(var9, var1, var2, var3);
      }
   }

   class="kw">public void overrideFluid(int var1, int var2, int var3, byte var4, int var5) {
      if (var2 >= 0 && var2 < 320) {
         this.priorityChunk.set(var1, var2, var3, var4);
         Holder var6 = this.getSection(ChunkUtil.chunkCoordinate(var2));
         FluidSection var7 = var6.ensureAndGetComponent(FluidSection.getComponentType());
         var7.setFluid(var1, var2, var3, var5, (byte)Fluid.getAssetMap().getAsset(var5).getMaxFluidLevel());
      }
   }

   class="kw">protected int localX(int var1) {
      class="kw">return var1 - this.blockChunk.getX() * 32;
   }

   class="kw">protected int localZ(int var1) {
      class="kw">return var1 - this.blockChunk.getZ() * 32;
   }

   class="kw">public int globalX(int var1) {
      class="kw">return ChunkUtil.minBlock(this.blockChunk.getX()) + var1;
   }

   class="kw">public int globalZ(int var1) {
      class="kw">return ChunkUtil.minBlock(this.blockChunk.getZ()) + var1;
   }
}