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

class="kw">import com.hypixel.hytale.math.util.FastRandom;
class="kw">import com.hypixel.hytale.math.util.HashUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.procedurallib.condition.ConstantIntCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.DefaultCoordinateCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.ICoordinateCondition;
class="kw">import com.hypixel.hytale.procedurallib.condition.IIntCondition;
class="kw">import com.hypixel.hytale.procedurallib.supplier.IDoubleRange;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.worldgen.cave.element.CaveNode;
class="kw">import com.hypixel.hytale.server.worldgen.cave.element.CavePrefab;
class="kw">import com.hypixel.hytale.server.worldgen.cave.prefab.CavePrefabContainer;
class="kw">import com.hypixel.hytale.server.worldgen.cave.shape.CaveNodeShape;
class="kw">import com.hypixel.hytale.server.worldgen.cave.shape.PrefabCaveNodeShape;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGenerator;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ZoneBiomeResult;
class="kw">import com.hypixel.hytale.server.worldgen.loader.WorldGenPrefabSupplier;
class="kw">import com.hypixel.hytale.server.worldgen.util.ArrayUtli;
class="kw">import com.hypixel.hytale.server.worldgen.util.condition.flag.Int2FlagsCondition;
class="kw">import java.util.Random;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class CaveGenerator {
   class="kw">private class="kw">final CaveType[] caveTypes;

   class="kw">public CaveGenerator(CaveType[] var1) {
      this.caveTypes = var1;
   }

   class="kw">public CaveType[] getCaveTypes() {
      class="kw">return this.caveTypes;
   }

   @Nonnull
   class="kw">public Cave generate(int var1, @Nonnull ChunkGenerator var2, @Nonnull CaveType var3, int var4, int var5, int var6) {
      int var7 = (int)HashUtil.rehash(var1, var4, var5, var6);
      Random var8 = new FastRandom(var7);
      Cave var9 = this.newCave(var3);
      Vector3d var10 = new Vector3d(var4, var5, var6);
      var10.y = var3.getModifiedStartHeight(var1 + var7, var4, var5, var6, var8);
      this.startCave(var1, var2, var9, var10, var8);
      var9.compile();
      class="kw">return var9;
   }

   @Nonnull
   class="kw">protected Cave newCave(CaveType var1) {
      class="kw">return new Cave(var1);
   }

   class="kw">protected void startCave(int var1, @Nonnull ChunkGenerator var2, @Nonnull Cave var3, @Nonnull Vector3d var4, @Nonnull Random var5) {
      Int2FlagsCondition var6 = var3.getCaveType().getBiomeMask();
      int var7 = this.getBiomeMaskResult(var1, var2, var6, var4);
      if (CaveBiomeMaskFlags.canGenerate(var7)) {
         CaveType var8 = var3.getCaveType();
         int var9 = var8.getStartDepth(var5);
         CaveNodeType var10 = var8.getEntryNode();
         float var11 = var8.getStartYaw(var5);
         float var12 = var8.getStartPitch(var5);
         int var13 = var5.nextInt();
         CaveNodeShape var14 = var10.generateCaveNodeShape(var5, var8, null, null, var4, var11, var12);
         int var15 = this.getBiomeMaskResult(var1, var2, var6, var14.getEnd());
         if (CaveBiomeMaskFlags.canGenerate(var15)) {
            CaveNode var16 = new CaveNode(var1 + var13, var10, var14, var11, var12);
            if (var14.hasGeometry() && CaveBiomeMaskFlags.canPopulate(var7) && CaveBiomeMaskFlags.canPopulate(var15)) {
               var3.addNode(var16);
            }

            this.continueNode(var1, var2, var3, var16, var9, var5);
         }
      }
   }

   class="kw">protected void continueNode(int var1, @Nonnull ChunkGenerator var2, @Nonnull Cave var3, @Nonnull CaveNode var4, int var5, @Nonnull Random var6) {
      if (var5 > 0) {
         Int2FlagsCondition var7 = var3.getCaveType().getBiomeMask();
         CaveNodeType.CaveNodeChildEntry[] var8 = this.getChildEntriesRandomized(var4.getCaveNodeType(), var6);
         int var9 = this.getChildrenCount(var4.getCaveNodeType(), var6);
         int var10 = 0;

         for (CaveNodeType.CaveNodeChildEntry var14 : var8) {
            int var15 = this.getRepeatCounter(var14, var6);

            for (int var16 = 0; var16 < var15; var16++) {
               if (this.shouldGenerateChild(var14, var6)) {
                  if (var10 >= var9) {
                     class="kw">return;
                  }

                  PrefabRotation var17 = this.getRotation(var4);
                  Vector3d var18 = this.getChildOrigin(var4, var17, var14);
                  CaveNodeType var19 = var14.getTypes().get(var6);
                  if (this.isMatchingHeight(var1, var18, var19.getHeightCondition())) {
                     float var20 = this.getChildYaw(var4, var17, var14, var6);
                     float var21 = var14.getPitchModifier().calc(var4.getPitch(), var6);
                     int var22 = var6.nextInt();
                     CaveNodeShape var23 = var19.generateCaveNodeShape(var6, var3.getCaveType(), var4, var14, var18, var20, var21);
                     if (this.isMatchingHeight(var1, var23.getEnd(), var19.getHeightCondition())) {
                        int var24 = this.getBiomeMaskResult(var1, var2, var7, var23.getEnd());
                        if (!CaveBiomeMaskFlags.canGenerate(var24)) {
                           if (!CaveBiomeMaskFlags.canContinue(var24)) {
                              break;
                           }
                        } else {
                           CaveNode var25 = new CaveNode(var22, var19, var23, var20, var21);
                           if (var23.hasGeometry() && CaveBiomeMaskFlags.canPopulate(var24)) {
                              this.generatePrefabs(var1, var2, var4, var25);
                              var3.addNode(var25);
                           }

                           int var26 = this.getNextDepth(var14, var5, var6);
                           this.continueNode(var1, var2, var3, var25, var26, var6);
                           var10++;
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">protected int getChildrenCount(@Nonnull CaveNodeType var1, Random var2) {
      IDoubleRange var3 = var1.getChildrenCountBounds();
      class="kw">return var3 == null ? Integer.MAX_VALUE : MathUtil.floor(var3.getValue(var2));
   }

   @Nonnull
   class="kw">protected CaveNodeType.CaveNodeChildEntry[] getChildEntriesRandomized(@Nonnull CaveNodeType var1, @Nonnull Random var2) {
      CaveNodeType.CaveNodeChildEntry[] var3 = var1.getChildren();
      if (var1.getChildrenCountBounds() != null && var3.length != 0) {
         CaveNodeType.CaveNodeChildEntry[] var4 = new CaveNodeType.CaveNodeChildEntry[var3.length];
         System.arraycopy(var3, 0, var4, 0, var4.length);
         ArrayUtli.shuffleArray(var4, var2);
         class="kw">return var4;
      } else {
         class="kw">return var3;
      }
   }

   class="kw">protected int getRepeatCounter(@Nonnull CaveNodeType.CaveNodeChildEntry var1, Random var2) {
      class="kw">return MathUtil.floor(var1.getRepeat().getValue(var2));
   }

   @Nullable
   class="kw">protected PrefabRotation getRotation(@Nonnull CaveNode var1) {
      CaveNodeShape var2 = var1.getShape();
      class="kw">return var2 class="kw">instanceof PrefabCaveNodeShape ? ((PrefabCaveNodeShape)var2).getPrefabRotation() : null;
   }

   class="kw">protected Vector3d getChildOrigin(@Nonnull CaveNode var1, @Nullable PrefabRotation var2, @Nonnull CaveNodeType.CaveNodeChildEntry var3) {
      Vector3d var4 = var1.getEnd();
      Vector3d var5 = var3.getAnchor();
      if (var5.equals(Vector3dUtil.ZERO)) {
         class="kw">return var4;
      }

      var4.set(var5);
      if (var2 != null && var2 != PrefabRotation.ROTATION_0) {
         var4.sub(0.5, 0.5, 0.5);
         var2.rotate(var4);
         var4.add(0.5, 0.5, 0.5);
      }

      class="kw">return var1.getShape().getAnchor(var4, var4.x, var4.y, var4.z);
   }

   class="kw">protected float getChildYaw(@Nonnull CaveNode var1, @Nullable PrefabRotation var2, @Nonnull CaveNodeType.CaveNodeChildEntry var3, Random var4) {
      float var5 = var3.getYawMode().combine(var1.getYaw(), var2);
      class="kw">return var3.getYawModifier().calc(var5, var4);
   }

   class="kw">protected boolean shouldGenerateChild(@Nonnull CaveNodeType.CaveNodeChildEntry var1, @Nonnull Random var2) {
      class="kw">return var2.nextDouble() < var1.getChance();
   }

   class="kw">protected boolean isMatchingHeight(int var1, @Nonnull Vector3d var2, @Nonnull ICoordinateCondition var3) {
      if (var3 == DefaultCoordinateCondition.DEFAULT_TRUE) {
         class="kw">return true;
      }

      if (var3 == DefaultCoordinateCondition.DEFAULT_FALSE) {
         class="kw">return false;
      }

      int var4 = MathUtil.floor(var2.x);
      int var5 = MathUtil.floor(var2.y);
      int var6 = MathUtil.floor(var2.z);
      class="kw">return var3.eval(var1, var4, var5, var6);
   }

   class="kw">protected int getNextDepth(@Nonnull CaveNodeType.CaveNodeChildEntry var1, int var2, Random var3) {
      int var4 = var2 - 1;
      if (var1.getChildrenLimit() != null) {
         int var5 = MathUtil.floor(var1.getChildrenLimit().getValue(var3));
         if (var5 < var4) {
            class="kw">return var5;
         }
      }

      class="kw">return var4;
   }

   class="kw">protected void generatePrefabs(int var1, @Nonnull ChunkGenerator var2, CaveNode var3, @Nonnull CaveNode var4) {
      Random var5 = ChunkGenerator.getResource().getRandom();
      var5.setSeed(var1 + var4.getSeedOffset());
      CavePrefabContainer var6 = var4.getCaveNodeType().getPrefabContainer();
      if (var6 != null) {
         for (CavePrefabContainer.CavePrefabEntry var10 : var6.getEntries()) {
            this.generatePrefab(var1, var2, var3, var4, var10, var5);
         }
      }
   }

   class="kw">protected void generatePrefab(
      int var1,
      @Nonnull ChunkGenerator var2,
      @Nullable CaveNode var3,
      @Nonnull CaveNode var4,
      @Nonnull CavePrefabContainer.CavePrefabEntry var5,
      @Nonnull Random var6
   ) {
      assert var4.getShape().hasGeometry() : "Cannot generate cave-prefab inside an invalid shape";
      CavePrefabContainer.CavePrefabEntry.CavePrefabConfig var7 = var5.getConfig();
      int var8 = var7.getIterations(var6.nextDouble());

      for (int var9 = 0; var9 < var8; var9++) {
         int var10 = var4.getBounds().randomX(var6);
         int var11 = var4.getBounds().randomZ(var6);
         if (this.isMatchingBiome(var1, var2, var7.getBiomeMask(), var10, var11) && var7.isMatchingNoiseDensity(var1, var10, var11)) {
            int var12 = var7.getHeight(var1, var10, var11, var4);
            if (var12 != -1
               && var7.isMatchingHeight(var1, var10, var12, var11, var6)
               && (var3 == null || !var3.getShape().shouldReplace(var1, var10, var11, var12))) {
               WorldGenPrefabSupplier var13 = var5.getPrefab(var6.nextDouble());
               PrefabRotation var14 = var7.getRotation(var6);
               CavePrefab var15 = new CavePrefab(var13, var14, var7.getBiomeMask(), var7.getBlockMask(), var10, var12, var11);
               var4.addPrefab(var15);
            }
         }
      }
   }

   class="kw">protected boolean isMatchingBiome(int var1, @Nonnull ChunkGenerator var2, @Nonnull IIntCondition var3, int var4, int var5) {
      if (var3 == ConstantIntCondition.DEFAULT_TRUE) {
         class="kw">return true;
      }

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

      ZoneBiomeResult var6 = var2.getZoneBiomeResultAt(var1, var4, var5);
      class="kw">return var3.eval(var6.getBiome().getId());
   }

   class="kw">protected int getBiomeMaskResult(int var1, @Nonnull ChunkGenerator var2, @Nonnull Int2FlagsCondition var3, @Nonnull Vector3d var4) {
      if (var3 == CaveBiomeMaskFlags.DEFAULT_ALLOW) {
         class="kw">return 7;
      }

      if (var3 == CaveBiomeMaskFlags.DEFAULT_DENY) {
         class="kw">return 0;
      }

      int var5 = MathUtil.floor(var4.x());
      int var6 = MathUtil.floor(var4.z());
      ZoneBiomeResult var7 = var2.getZoneBiomeResultAt(var1, var5, var6);
      class="kw">return var3.eval(var7.getBiome().getId());
   }
}