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

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.util.TrigMathUtil;
class="kw">import com.hypixel.hytale.procedurallib.logic.GeneralNoise;
class="kw">import com.hypixel.hytale.procedurallib.supplier.IDoubleRange;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.GeneratedBlockChunk;
class="kw">import com.hypixel.hytale.server.worldgen.cave.Cave;
class="kw">import com.hypixel.hytale.server.worldgen.cave.CaveNodeType;
class="kw">import com.hypixel.hytale.server.worldgen.cave.CaveType;
class="kw">import com.hypixel.hytale.server.worldgen.cave.element.CaveNode;
class="kw">import com.hypixel.hytale.server.worldgen.cave.shape.distorted.AbstractDistortedShape;
class="kw">import com.hypixel.hytale.server.worldgen.cave.shape.distorted.DistortedShape;
class="kw">import com.hypixel.hytale.server.worldgen.cave.shape.distorted.ShapeDistortion;
class="kw">import com.hypixel.hytale.server.worldgen.chunk.ChunkGeneratorExecution;
class="kw">import com.hypixel.hytale.server.worldgen.util.BlockFluidEntry;
class="kw">import com.hypixel.hytale.server.worldgen.util.bounds.IWorldBounds;
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 DistortedCaveNodeShape class="kw">implements CaveNodeShape {
   class="kw">private class="kw">final CaveType caveType;
   class="kw">private class="kw">final DistortedShape shape;
   class="kw">private class="kw">final ShapeDistortion distortion;

   class="kw">public DistortedCaveNodeShape(CaveType var1, DistortedShape var2, ShapeDistortion var3) {
      this.caveType = var1;
      this.shape = var2;
      this.distortion = var3;
   }

   class="kw">public DistortedShape getShape() {
      class="kw">return this.shape;
   }

   @Override
   class="kw">public Vector3d getStart() {
      class="kw">return this.shape.getStart();
   }

   @Override
   class="kw">public Vector3d getEnd() {
      class="kw">return this.shape.getEnd();
   }

   @Override
   class="kw">public Vector3d getAnchor(Vector3d var1, double var2, double var4, double var6) {
      class="kw">return this.shape.getAnchor(var1, var2, var4, var6);
   }

   @Override
   class="kw">public IWorldBounds getBounds() {
      class="kw">return this.shape;
   }

   @Override
   class="kw">public boolean shouldReplace(int var1, double var2, double var4, int var6) {
      double var7 = this.shape.getProjection(var2, var4);
      if (this.shape.isValidProjection(var7)) {
         double var9 = this.shape.getYAt(var7);
         double var11 = this.shape.getHeightAtProjection(var1, var2, var4, var7, var9, this.caveType, this.distortion);
         if (var11 > 0.0) {
            int var13 = this.getBounds().getLowBoundY();
            int var14 = this.getFloor(var1, var2, var4, var9, var11, var13);
            if (var6 < var14) {
               class="kw">return false;
            }

            int var15 = this.getBounds().getHighBoundY();
            int var16 = this.getCeiling(var1, var2, var4, var9, var11, var15);
            class="kw">return var6 <= var16;
         }
      }

      class="kw">return false;
   }

   @Override
   class="kw">public double getFloorPosition(int var1, double var2, double var4) {
      double var6 = this.shape.getProjection(var2, var4);
      if (this.shape.isValidProjection(var6)) {
         double var8 = this.shape.getYAt(var6);
         double var10 = this.shape.getHeightAtProjection(var1, var2, var4, var6, var8, this.caveType, this.distortion);
         if (var10 > 0.0) {
            int var12 = this.getBounds().getLowBoundY();
            class="kw">return this.getFloor(var1, var2, var4, var8, var10, var12) - 1;
         }
      }

      class="kw">return -1.0;
   }

   @Override
   class="kw">public double getCeilingPosition(int var1, double var2, double var4) {
      double var6 = this.shape.getProjection(var2, var4);
      if (this.shape.isValidProjection(var6)) {
         double var8 = this.shape.getYAt(var6);
         double var10 = this.shape.getHeightAtProjection(var1, var2, var4, var6, var8, this.caveType, this.distortion);
         if (var10 > 0.0) {
            int var12 = this.getBounds().getHighBoundY();
            class="kw">return this.getCeiling(var1, var2, var4, var8, var10, var12) + 1;
         }
      }

      class="kw">return -1.0;
   }

   @Override
   class="kw">public void populateChunk(int var1, @Nonnull ChunkGeneratorExecution var2, @Nonnull Cave var3, @Nonnull CaveNode var4, @Nonnull Random var5) {
      GeneratedBlockChunk var6 = var2.getChunk();
      BlockTypeAssetMap var7 = BlockType.getAssetMap();
      CaveType var8 = var3.getCaveType();
      CaveNodeType var9 = var4.getCaveNodeType();
      IWorldBounds var10 = this.getBounds();
      boolean var11 = var3.getCaveType().isSurfaceLimited();
      int var12 = var4.getCaveNodeType().hasEnvironment() ? var4.getCaveNodeType().getEnvironment() : var8.getEnvironment();
      int var13 = ChunkUtil.minBlock(var2.getX());
      int var14 = ChunkUtil.minBlock(var2.getZ());
      int var15 = ChunkUtil.maxBlock(var2.getX());
      int var16 = ChunkUtil.maxBlock(var2.getZ());
      int var17 = Math.max(var13, var10.getLowBoundX());
      int var18 = var10.getLowBoundY();
      int var19 = Math.max(var14, var10.getLowBoundZ());
      int var20 = Math.min(var15, var10.getHighBoundX());
      int var21 = var10.getHighBoundY();
      int var22 = Math.min(var16, var10.getHighBoundZ());

      for (int var23 = var17; var23 <= var20; var23++) {
         int var24 = var23 - var13;

         for (int var25 = var19; var25 <= var22; var25++) {
            int var26 = var25 - var14;
            int var27 = var21;
            boolean var28 = false;
            if (var11) {
               int var29 = var6.getHeight(var24, var26);
               if (var27 >= var29) {
                  var27 = var29;
                  var28 = true;
               }
            }

            int var48 = Integer.MAX_VALUE;
            int var30 = Integer.MAX_VALUE;
            int var31 = Integer.MIN_VALUE;
            int var32 = Integer.MIN_VALUE;
            double var33 = this.shape.getProjection(var23, var25);
            if (this.shape.isValidProjection(var33)) {
               double var35 = this.shape.getYAt(var33);
               double var37 = this.shape.getHeightAtProjection(var1, var23, var25, var33, var35, var8, this.distortion);
               if (!(var37 <= 0.0)) {
                  int var39 = this.getFloor(var1, var23, var25, var35, var37, var18);
                  int var40 = this.getCeiling(var1, var23, var25, var35, var37, var27);
                  if (var39 < var30) {
                     var30 = var39;
                  }

                  if (var40 > var32) {
                     var32 = var40;
                  }

                  for (int var41 = var39; var41 <= var40; var41++) {
                     int var42 = var2.getBlock(var24, var41, var26);
                     int var43 = var2.getFluid(var24, var41, var26);
                     boolean var44 = !var11 || var42 != 0;
                     if (var44) {
                        BlockFluidEntry var45 = CaveNodeShapeUtils.getFillingBlock(var8, var9, var41, var5);
                        if (var8.getBlockMask().eval(var42, var43, var45.blockId(), var45.fluidId())) {
                           if (var2.setBlock(var24, var41, var26, (byte)6, var45, var12)) {
                              if (var41 < var48) {
                                 var48 = var41;
                              }

                              if (var41 > var31) {
                                 var31 = var41;
                              }
                           }

                           if (var2.setFluid(var24, var41, var26, (byte)6, var45.fluidId(), var12)) {
                              if (var41 < var48) {
                                 var48 = var41;
                              }

                              if (var41 > var31) {
                                 var31 = var41;
                              }
                           }
                        }
                     }
                  }

                  CaveNodeType.CaveNodeCoverEntry[] var49 = var9.getCovers();

                  for (CaveNodeType.CaveNodeCoverEntry var55 : var49) {
                     CaveNodeType.CaveNodeCoverEntry.Entry var46 = var55.get(var5);
                     int var47 = CaveNodeShapeUtils.getCoverHeight(var48, var30, var31, var32, var28, var55, var46);
                     if (var47 >= 0
                        && var55.getDensityCondition().eval(var1 + var4.getSeedOffset(), var23, var25)
                        && var55.getHeightCondition().eval(var1, var23, var25, var47, var5)
                        && var55.getMapCondition().eval(var1, var23, var25)
                        && CaveNodeShapeUtils.isCoverMatchingParent(var24, var26, var47, var2, var55)) {
                        var2.setBlock(var24, var47, var26, (byte)5, var46.getEntry(), var12);
                        var2.setFluid(var24, var47, var26, (byte)5, var46.getEntry().fluidId(), var12);
                     }
                  }

                  if (CaveNodeShapeUtils.invalidateCover(var24, var48 - 1, var26, CaveNodeType.CaveNodeCoverType.CEILING, var2, var7)) {
                     BlockFluidEntry var51 = CaveNodeShapeUtils.getFillingBlock(var8, var9, var48 - 1, var5);
                     var2.overrideBlock(var24, var48 - 1, var26, (byte)6, var51);
                     var2.overrideFluid(var24, var48 - 1, var26, (byte)6, var51.fluidId());
                  }

                  if (CaveNodeShapeUtils.invalidateCover(var24, var31 + 1, var26, CaveNodeType.CaveNodeCoverType.FLOOR, var2, var7)) {
                     BlockFluidEntry var52 = CaveNodeShapeUtils.getFillingBlock(var8, var9, var31 + 1, var5);
                     var2.overrideBlock(var24, var31 + 1, var26, (byte)6, var52);
                     var2.overrideFluid(var24, var31 + 1, var26, (byte)6, var52.fluidId());
                  }
               }
            }
         }
      }
   }

   class="kw">private int getFloor(int var1, double var2, double var4, double var6, double var8, int var10) {
      var8 *= this.distortion.getFloorFactor(var1, var2, var4);
      double var11 = this.shape.getFloor(var2, var4, var6, var8);
      class="kw">return Math.max(MathUtil.floor(var11), var10);
   }

   class="kw">private int getCeiling(int var1, double var2, double var4, double var6, double var8, int var10) {
      var8 *= this.distortion.getCeilingFactor(var1, var2, var4);
      double var11 = this.shape.getCeiling(var2, var4, var6, var8);
      class="kw">return Math.min(MathUtil.ceil(var11), var10);
   }

   class="kw">public class="kw">static class DistortedCaveNodeShapeGenerator class="kw">implements CaveNodeShapeEnum.CaveNodeShapeGenerator {
      class="kw">private class="kw">final DistortedShape.Factory shapeFactory;
      class="kw">private class="kw">final IDoubleRange widthRange;
      class="kw">private class="kw">final IDoubleRange midWidthRange;
      class="kw">private class="kw">final IDoubleRange heightRange;
      class="kw">private class="kw">final IDoubleRange midHeightRange;
      class="kw">private class="kw">final IDoubleRange lengthRange;
      class="kw">private class="kw">final ShapeDistortion distortion;
      class="kw">private class="kw">final boolean inheritParentRadius;
      class="kw">private class="kw">final GeneralNoise.InterpolationFunction interpolation;

      class="kw">public DistortedCaveNodeShapeGenerator(
         DistortedShape.Factory var1,
         IDoubleRange var2,
         IDoubleRange var3,
         @Nullable IDoubleRange var4,
         @Nullable IDoubleRange var5,
         @Nullable IDoubleRange var6,
         boolean var7,
         ShapeDistortion var8,
         @Nullable GeneralNoise.InterpolationFunction var9
      ) {
         this.shapeFactory = var1;
         this.widthRange = var2;
         this.heightRange = var3;
         this.midWidthRange = var4;
         this.midHeightRange = var5;
         this.lengthRange = var6;
         this.distortion = var8;
         this.inheritParentRadius = var7;
         this.interpolation = var9;
      }

      @Nonnull
      @Override
      class="kw">public CaveNodeShape generateCaveNodeShape(
         Random var1, CaveType var2, @Nullable CaveNode var3, @Nonnull CaveNodeType.CaveNodeChildEntry var4, @Nonnull Vector3d var5, float var6, float var7
      ) {
         double var8 = getLength(this.lengthRange, var1);
         Vector3d var10 = getOrigin(var5, var3, var4);
         Vector3d var11 = getDirection(var6, var7, var8);
         double var12 = getStartWidth(this.inheritParentRadius, var3, this.widthRange, var1);
         double var14 = getStartHeight(this.inheritParentRadius, var3, this.heightRange, var1);
         double var16 = this.widthRange.getValue(var1);
         double var18 = this.heightRange.getValue(var1);
         double var20 = getMiddleRadius(var12, var16, this.midWidthRange, var1);
         double var22 = getMiddleRadius(var14, var18, this.midHeightRange, var1);
         DistortedShape var24 = this.shapeFactory.create(var10, var11, var8, var12, var14, var20, var22, var16, var18, this.interpolation);
         class="kw">return new DistortedCaveNodeShape(var2, var24, this.distortion);
      }

      @Nonnull
      class="kw">private class="kw">static Vector3d getOrigin(@Nonnull Vector3d var0, @Nullable CaveNode var1, @Nonnull CaveNodeType.CaveNodeChildEntry var2) {
         if (var1 == null) {
            class="kw">return var0;
         }

         Vector3d var3 = CaveNodeShapeUtils.getOffset(var1, var2);
         class="kw">return var0.add(var3);
      }

      class="kw">private class="kw">static double getLength(@Nullable IDoubleRange var0, Random var1) {
         class="kw">return var0 == null ? 0.0 : var0.getValue(var1);
      }

      @Nonnull
      class="kw">private class="kw">static Vector3d getDirection(double var0, double var2, double var4) {
         if (var4 == 0.0) {
            class="kw">return new Vector3d();
         }

         var2 = AbstractDistortedShape.clampPitch(var2);
         class="kw">return new Vector3d(TrigMathUtil.sin(var2) * TrigMathUtil.cos(var0), TrigMathUtil.cos(var2), TrigMathUtil.sin(var2) * TrigMathUtil.sin(var0))
            .mul(var4);
      }

      class="kw">private class="kw">static double getStartWidth(boolean var0, @Nullable CaveNode var1, @Nonnull IDoubleRange var2, Random var3) {
         class="kw">return var0 ? CaveNodeShapeUtils.getEndWidth(var1, var2, var3) : var2.getValue(var3);
      }

      class="kw">private class="kw">static double getStartHeight(boolean var0, @Nullable CaveNode var1, @Nonnull IDoubleRange var2, Random var3) {
         class="kw">return var0 ? CaveNodeShapeUtils.getEndHeight(var1, var2, var3) : var2.getValue(var3);
      }

      class="kw">private class="kw">static double getMiddleRadius(double var0, double var2, @Nullable IDoubleRange var4, Random var5) {
         class="kw">return var4 == null ? (var2 - var0) * 0.5 + var0 : var4.getValue(var5);
      }
   }
}