class="kw">package com.hypixel.hytale.server.core.modules.collision;

class="kw">import com.hypixel.hytale.math.iterator.BoxBlockIterator;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class BlockCollisionProvider class="kw">implements BoxBlockIterator.BoxIterationConsumer {
   class="kw">protected class="kw">final BoxBlockIntersectionEvaluator boxBlockIntersectionEvaluator = new BoxBlockIntersectionEvaluator();
   class="kw">protected class="kw">final MovingBoxBoxCollisionEvaluator movingBoxBoxCollisionEvaluator = new MovingBoxBoxCollisionEvaluator();
   class="kw">protected class="kw">final BlockDataProvider blockData = new BlockDataProvider();
   class="kw">protected class="kw">final Box fluidBox = new Box(Box.UNIT);
   class="kw">protected class="kw">final CollisionTracker damageTracker = new CollisionTracker();
   class="kw">protected class="kw">final CollisionTracker triggerTracker = new CollisionTracker();
   class="kw">protected class="kw">final BlockTracker collisionTracker = new BlockTracker();
   class="kw">protected int requestedCollisionMaterials = 4;
   class="kw">protected boolean reportOverlaps;
   @Nullable
   class="kw">protected IBlockCollisionConsumer collisionConsumer;
   @Nullable
   class="kw">protected IBlockTracker activeTriggers;
   @Nullable
   class="kw">protected Vector3d motion;
   class="kw">protected double relativeStopDistance;
   class="kw">protected IBlockCollisionConsumer.Result collisionState;

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

   class="kw">public void setRequestedCollisionMaterials(int var1) {
      this.requestedCollisionMaterials = var1;
   }

   class="kw">public void setReportOverlaps(boolean var1) {
      this.reportOverlaps = var1;
      this.movingBoxBoxCollisionEvaluator.setComputeOverlaps(var1);
   }

   @Override
   class="kw">public boolean next() {
      class="kw">return this.onSliceFinished();
   }

   @Override
   class="kw">public boolean accept(long var1, long var3, long var5) {
      class="kw">return this.processBlockDynamic((int)var1, (int)var3, (int)var5);
   }

   class="kw">public void cast(
      @Nonnull World var1,
      @Nonnull Box var2,
      @Nonnull Vector3d var3,
      @Nonnull Vector3d var4,
      @Nonnull IBlockCollisionConsumer var5,
      @Nonnull IBlockTracker var6,
      double var7
   ) {
      if (!CollisionModule.get().isDisabled()) {
         this.collisionConsumer = var5;
         this.activeTriggers = var6;
         this.motion = var4;
         this.blockData.initialize(var1);
         boolean var9 = !CollisionModule.isBelowMovementThreshold(var4);
         if (var9) {
            this.castIterative(var2, var3, var4, var7);
         } else {
            this.castShortDistance(var2, var3, var4);
         }

         var5.onCollisionFinished();
         this.blockData.cleanup();
         this.triggerTracker.reset();
         this.damageTracker.reset();
         this.collisionConsumer = null;
         this.activeTriggers = null;
         this.motion = null;
      }
   }

   class="kw">protected void castShortDistance(@Nonnull Box var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3) {
      this.boxBlockIntersectionEvaluator.setBox(var1, var2).offsetPosition(var3);
      var1.forEachBlock(
         var2.x + var3.x, var2.y + var3.y, var2.z + var3.z, 1.0E-5, this, (var0, var1x, var2x, var3x) -> var3x.processBlockStatic(var0, var1x, var2x)
      );
      this.generateTriggerExit();
   }

   class="kw">protected boolean processBlockStatic(int var1, int var2, int var3) {
      this.blockData.read(var1, var2, var3);
      BlockBoundingBoxes var4 = this.blockData.getBlockBoundingBoxes();
      int var5 = this.blockData.originX(var1);
      int var6 = this.blockData.originY(var2);
      int var7 = this.blockData.originZ(var3);
      boolean var8 = this.blockData.isTrigger() && !this.triggerTracker.isTracked(var5, var6, var7);
      int var9 = this.blockData.getBlockDamage();
      boolean var10 = this.canCollide();
      Box[] var11 = var4.get(this.blockData.rotation).getDetailBoxes();
      this.boxBlockIntersectionEvaluator.setDamageAndSubmerged(var9, false);
      if (this.blockData.getBlockType().getMaterial() != BlockMaterial.Empty
         || this.blockData.getBlockType().getMaterial() == BlockMaterial.Empty && this.blockData.getFluidId() == 0) {
         if (var9 != 0 && var4.protrudesUnitBox()) {
            if (this.damageTracker.isTracked(var5, var6, var7)) {
               var9 = 0;
            } else {
               this.damageTracker.trackNew(var5, var6, var7);
            }
         }

         if (var10 && var4.protrudesUnitBox()) {
            if (this.collisionTracker.isTracked(var5, var6, var7)) {
               var10 = false;
            } else {
               this.collisionTracker.trackNew(var5, var6, var7);
            }
         }

         for (int var16 = 0; (var10 || var8 || var9 > 0) && var16 < var11.length; var16++) {
            Box var18 = var11[var16];
            if (!CollisionMath.isDisjoint(this.boxBlockIntersectionEvaluator.intersectBoxComputeTouch(var18, var5, var6, var7))) {
               if (var10 || this.boxBlockIntersectionEvaluator.isOverlapping() && this.reportOverlaps) {
                  this.collisionConsumer.onCollision(var5, var6, var7, this.motion, this.boxBlockIntersectionEvaluator, this.blockData, var18);
                  var10 = false;
               }

               if (var8) {
                  if (!this.activeTriggers.isTracked(var5, var6, var7)) {
                     this.activeTriggers.trackNew(var5, var6, var7);
                  }

                  this.triggerTracker.trackNew(var5, var6, var7);
                  var8 = false;
               }

               if (var9 != 0) {
                  this.collisionConsumer.onCollisionDamage(var5, var6, var7, this.motion, this.boxBlockIntersectionEvaluator, this.blockData);
                  var9 = 0;
               }
            }
         }

         Fluid var17 = this.blockData.getFluid();
         if (var17 != null && this.blockData.getFluidId() != 0) {
            this.processBlockStaticFluid(var1, var2, var3, var17, true);
         }

         class="kw">return true;
      } else {
         if (var8) {
            this.boxBlockIntersectionEvaluator.setDamageAndSubmerged(var9, false);

            for (Box var15 : var11) {
               if (!CollisionMath.isDisjoint(this.boxBlockIntersectionEvaluator.intersectBoxComputeTouch(var15, var5, var6, var7))) {
                  this.triggerTracker.trackNew(var5, var6, var7);
                  break;
               }
            }
         }

         this.processBlockStaticFluid(var1, var2, var3, this.blockData.getFluid(), false);
         class="kw">return true;
      }
   }

   class="kw">protected void processBlockStaticFluid(int var1, int var2, int var3, @Nonnull Fluid var4, boolean var5) {
      boolean var6 = var4.getDamageToEntities() != 0;
      boolean var7 = this.canCollide(2);
      if (var6 || var7) {
         this.fluidBox.max.y = this.blockData.getFillHeight();
         if (!CollisionMath.isDisjoint(this.boxBlockIntersectionEvaluator.intersectBoxComputeTouch(this.fluidBox, var1, var2, var3))) {
            this.boxBlockIntersectionEvaluator.setDamageAndSubmerged(var4.getDamageToEntities(), var5);
            if (var7) {
               this.collisionConsumer.onCollision(var1, var2, var3, this.motion, this.boxBlockIntersectionEvaluator, this.blockData, this.fluidBox);
            }

            if (var6) {
               this.collisionConsumer.onCollisionDamage(var1, var2, var3, this.motion, this.boxBlockIntersectionEvaluator, this.blockData);
            }
         }
      }
   }

   class="kw">protected boolean canCollide() {
      class="kw">return this.canCollide(this.blockData.getCollisionMaterials());
   }

   class="kw">protected boolean canCollide(int var1) {
      class="kw">return (var1 & this.requestedCollisionMaterials) != 0;
   }

   class="kw">protected void castIterative(@Nonnull Box var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, double var4) {
      this.relativeStopDistance = MathUtil.clamp(var4, 0.0, 1.0);
      this.collisionState = IBlockCollisionConsumer.Result.CONTINUE;
      this.movingBoxBoxCollisionEvaluator.setCollider(var1).setMove(var2, var3);
      var1.forEachBlock(var2, 1.0E-5, this, (var0, var1x, var2x, var3x) -> var3x.processBlockDynamic(var0, var1x, var2x));
      BoxBlockIterator.iterate(var1, var2, var3, var3.length(), this);
      int var6 = this.damageTracker.getCount();

      for (int var7 = 0; var7 < var6; var7++) {
         BlockContactData var8 = this.damageTracker.getContactData(var7);
         if (var8.getCollisionStart() <= this.relativeStopDistance) {
            Vector3i var9 = this.damageTracker.getPosition(var7);
            this.collisionConsumer.onCollisionDamage(var9.x, var9.y, var9.z, this.motion, var8, this.damageTracker.getBlockData(var7));
         }
      }

      this.generateTriggerExit();
      var6 = this.triggerTracker.getCount();

      for (int var14 = 0; var14 < var6; var14++) {
         BlockContactData var15 = this.triggerTracker.getContactData(var14);
         if (var15.getCollisionStart() <= this.relativeStopDistance) {
            Vector3i var16 = this.triggerTracker.getPosition(var14);
            int var10 = var16.x;
            int var11 = var16.y;
            int var12 = var16.z;
            if (!this.activeTriggers.isTracked(var10, var11, var12)) {
               this.activeTriggers.trackNew(var10, var11, var12);
            }
         }
      }
   }

   class="kw">protected boolean onSliceFinished() {
      IBlockCollisionConsumer.Result var1 = this.collisionConsumer.onCollisionSliceFinished();
      if (var1 != null && this.collisionState.ordinal() < var1.ordinal()) {
         this.collisionState = var1;
      }

      class="kw">return this.collisionState == IBlockCollisionConsumer.Result.CONTINUE;
   }

   class="kw">protected boolean processBlockDynamic(int var1, int var2, int var3) {
      this.blockData.read(var1, var2, var3);
      int var4 = this.blockData.originX(var1);
      int var5 = this.blockData.originY(var2);
      int var6 = this.blockData.originZ(var3);
      BlockBoundingBoxes var7 = this.blockData.getBlockBoundingBoxes();
      Box[] var8 = var7.get(this.blockData.rotation).getDetailBoxes();
      boolean var9 = this.canCollide();
      int var10 = this.blockData.getBlockDamage();
      boolean var11 = this.blockData.isTrigger();
      this.movingBoxBoxCollisionEvaluator.setDamageAndSubmerged(var10, false);
      BlockContactData var12 = null;
      BlockContactData var13 = null;
      if (var11) {
         var12 = this.triggerTracker.getContactData(var4, var5, var6);
         if (var12 != null) {
            var11 = false;
         }
      }

      if (var10 != 0 && var7.protrudesUnitBox()) {
         var13 = this.damageTracker.getContactData(var4, var5, var6);
         if (var13 != null) {
            var10 = 0;
         }
      }

      if (this.blockData.getBlockType().getMaterial() != BlockMaterial.Empty
         || this.blockData.getBlockType().getMaterial() == BlockMaterial.Empty && this.blockData.getFluidId() == 0) {
         for (Box var23 : var8) {
            if (this.movingBoxBoxCollisionEvaluator.isBoundingBoxColliding(var23, var4, var5, var6)) {
               if (this.movingBoxBoxCollisionEvaluator.getCollisionStart() > this.relativeStopDistance) {
                  if (this.movingBoxBoxCollisionEvaluator.isOverlapping() && this.reportOverlaps) {
                     IBlockCollisionConsumer.Result var18 = this.collisionConsumer
                        .onCollision(var4, var5, var6, this.motion, this.movingBoxBoxCollisionEvaluator, this.blockData, var23);
                     this.updateStopDistance(var18);
                  }
               } else {
                  if (var9 || this.movingBoxBoxCollisionEvaluator.isOverlapping() && this.reportOverlaps) {
                     IBlockCollisionConsumer.Result var24 = this.collisionConsumer
                        .onCollision(var4, var5, var6, this.motion, this.movingBoxBoxCollisionEvaluator, this.blockData, var23);
                     this.updateStopDistance(var24);
                  }

                  if (var11) {
                     var12 = this.processTriggerDynamic(var4, var5, var6, var12);
                  }

                  if (var10 != 0) {
                     var13 = this.processDamageDynamic(var4, var5, var6, var13);
                  }
               }
            }
         }

         Fluid var20 = this.blockData.getFluid();
         if (var20 != null && this.blockData.getFluidId() != 0) {
            this.processBlockDynamicFluid(var1, var2, var3, var20, var13, true);
         }

         class="kw">return this.collisionState != IBlockCollisionConsumer.Result.STOP_NOW;
      } else {
         if (var11) {
            for (Box var17 : var8) {
               if (this.movingBoxBoxCollisionEvaluator.isBoundingBoxColliding(var17, var4, var5, var6)
                  && this.movingBoxBoxCollisionEvaluator.getCollisionStart() <= this.relativeStopDistance) {
                  var12 = this.processTriggerDynamic(var4, var5, var6, var12);
               }
            }
         }

         this.processBlockDynamicFluid(var1, var2, var3, this.blockData.getFluid(), var13, false);
         class="kw">return this.collisionState != IBlockCollisionConsumer.Result.STOP_NOW;
      }
   }

   class="kw">protected void processBlockDynamicFluid(int var1, int var2, int var3, @Nonnull Fluid var4, BlockContactData var5, boolean var6) {
      boolean var7 = var4.getDamageToEntities() != 0;
      boolean var8 = this.canCollide(2);
      if (var7 || var8) {
         this.fluidBox.max.y = this.blockData.getFillHeight();
         if (this.movingBoxBoxCollisionEvaluator.isBoundingBoxColliding(this.fluidBox, var1, var2, var3)
            && this.movingBoxBoxCollisionEvaluator.getCollisionStart() <= this.relativeStopDistance) {
            this.movingBoxBoxCollisionEvaluator.setDamageAndSubmerged(var4.getDamageToEntities(), var6);
            if (var8) {
               IBlockCollisionConsumer.Result var9 = this.collisionConsumer
                  .onCollision(var1, var2, var3, this.motion, this.movingBoxBoxCollisionEvaluator, this.blockData, this.fluidBox);
               this.updateStopDistance(var9);
            }

            if (var7) {
               this.processDamageDynamic(var1, var2, var3, var5);
            }
         }
      }
   }

   @Nonnull
   class="kw">protected BlockContactData processTriggerDynamic(int var1, int var2, int var3, @Nullable BlockContactData var4) {
      if (var4 == null) {
         class="kw">return this.triggerTracker.trackNew(var1, var2, var3, this.movingBoxBoxCollisionEvaluator, this.blockData);
      }

      double var5 = Math.max(var4.collisionEnd, this.movingBoxBoxCollisionEvaluator.getCollisionEnd());
      if (this.movingBoxBoxCollisionEvaluator.getCollisionStart() < var4.collisionStart) {
         var4.assign(this.movingBoxBoxCollisionEvaluator);
      }

      var4.collisionEnd = var5;
      class="kw">return var4;
   }

   @Nonnull
   class="kw">protected BlockContactData processDamageDynamic(int var1, int var2, int var3, @Nullable BlockContactData var4) {
      IBlockCollisionConsumer.Result var5 = this.collisionConsumer
         .probeCollisionDamage(var1, var2, var3, this.motion, this.movingBoxBoxCollisionEvaluator, this.blockData);
      this.updateStopDistance(var5);
      if (var4 == null) {
         class="kw">return this.damageTracker.trackNew(var1, var2, var3, this.movingBoxBoxCollisionEvaluator, this.blockData);
      }

      if (this.movingBoxBoxCollisionEvaluator.getCollisionStart() < var4.collisionStart) {
         var4.assign(this.movingBoxBoxCollisionEvaluator);
      }

      class="kw">return var4;
   }

   class="kw">protected void updateStopDistance(@Nullable IBlockCollisionConsumer.Result var1) {
      if (var1 != null && var1 != IBlockCollisionConsumer.Result.CONTINUE) {
         if (this.movingBoxBoxCollisionEvaluator.collisionStart < this.relativeStopDistance) {
            this.relativeStopDistance = this.movingBoxBoxCollisionEvaluator.collisionStart;
         }

         if (var1.ordinal() > this.collisionState.ordinal()) {
            this.collisionState = var1;
         }
      }
   }

   class="kw">protected void generateTriggerExit() {
      for (int var1 = this.activeTriggers.getCount() - 1; var1 >= 0; var1--) {
         Vector3i var2 = this.activeTriggers.getPosition(var1);
         if (!this.triggerTracker.isTracked(var2.x, var2.y, var2.z)) {
            this.activeTriggers.untrack(var2.x, var2.y, var2.z);
         }
      }
   }
}