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

class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.spatial.KDTree;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.Rotation;
class="kw">import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
class="kw">import com.hypixel.hytale.server.core.modules.collision.commands.HitboxCommand;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.component.Projectile;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.Config;
class="kw">import java.util.List;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector2d;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;

class="kw">public class CollisionModule class="kw">extends JavaPlugin {
   @Nonnull
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(CollisionModule.class).build();
   class="kw">public class="kw">static class="kw">final int VALIDATE_INVALID = -1;
   class="kw">public class="kw">static class="kw">final int VALIDATE_OK = 0;
   class="kw">public class="kw">static class="kw">final int VALIDATE_ON_GROUND = 1;
   class="kw">public class="kw">static class="kw">final int VALIDATE_TOUCH_CEIL = 2;
   class="kw">private class="kw">static CollisionModule instance;
   class="kw">private ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> tangibleEntitySpatialResourceType;
   class="kw">private double extentMax;
   class="kw">private double minimumThickness;
   @Nonnull
   class="kw">private class="kw">final Config<CollisionModuleConfig> config = this.withConfig("CollisionModule", CollisionModuleConfig.CODEC);

   class="kw">public class="kw">static CollisionModule get() {
      class="kw">return instance;
   }

   class="kw">public CollisionModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Nonnull
   class="kw">public CollisionModuleConfig getConfig() {
      class="kw">return this.config.get();
   }

   @Override
   class="kw">protected void setup() {
      this.getCommandRegistry().registerCommand(new HitboxCommand());
      this.getEventRegistry().register(LoadedAssetsEvent.class, BlockBoundingBoxes.class, this::onLoadedAssetsEvent);
      this.tangibleEntitySpatialResourceType = this.getEntityStoreRegistry().registerSpatialResource(() -> new KDTree<>(Ref::isValid));
   }

   class="kw">public ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> getTangibleEntitySpatialResourceType() {
      class="kw">return this.tangibleEntitySpatialResourceType;
   }

   class="kw">private void onLoadedAssetsEvent(@Nonnull LoadedAssetsEvent<String, BlockBoundingBoxes, IndexedLookupTableAssetMap<String, BlockBoundingBoxes>> var1) {
      if (var1.isInitial()) {
         this.extentMax = 0.0;
         this.minimumThickness = Double.MAX_VALUE;
      }

      for (BlockBoundingBoxes var3 : var1.getLoadedAssets().values()) {
         this.handleLoadedHitbox(var3);
      }

      CollisionModuleConfig var4 = this.config.get();
      if (var4.hasMinimumThickness()) {
         this.minimumThickness = var4.getMinimumThickness();
      }

      this.getLogger().at(Level.INFO).log("Block extents for CollisionSystem is Max=%g, Min=%g", this.extentMax, this.minimumThickness);
   }

   class="kw">private void handleLoadedHitbox(@Nonnull BlockBoundingBoxes var1) {
      BlockBoundingBoxes.RotatedVariantBoxes var2 = var1.get(Rotation.None, Rotation.None, Rotation.None);
      double var3 = var2.getBoundingBox().getMaximumExtent();
      double var5 = 0.0;
      if (var3 > var5) {
         var5 = var3;
      }

      if (var5 > 1.0) {
         this.getLogger()
            .at(Level.FINE)
            .log("Block Hitbox %s protrudes more than 1 unit (%s units) out of standard block and degrades performance", var1.getId(), var5);
      }

      if (var5 > this.extentMax) {
         this.extentMax = var5;
      }

      double var7;
      if (var2.hasDetailBoxes()) {
         var7 = Double.MAX_VALUE;

         for (Box var12 : var2.getDetailBoxes()) {
            var7 = Math.min(var7, var12.getThickness());
         }
      } else {
         var7 = var2.getBoundingBox().getThickness();
      }

      if (var7 < 0.0) {
         this.getLogger().at(Level.SEVERE).log("Hitbox for %s has a negative size!", var1.getId());
      } else {
         if (var7 < this.minimumThickness) {
            this.minimumThickness = var7;
         }
      }
   }

   class="kw">public class="kw">static boolean findCollisions(
      @Nonnull Box var0, @Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull CollisionResult var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      class="kw">return findCollisions(var0, var1, var2, true, var3, var4);
   }

   class="kw">public class="kw">static boolean findCollisions(
      @Nonnull Box var0,
      @Nonnull Vector3d var1,
      @Nonnull Vector3d var2,
      boolean var3,
      @Nonnull CollisionResult var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      World var6 = var5.getExternalData().getWorld();
      var4.reset();
      boolean var7 = !isBelowMovementThreshold(var2);
      if (var7) {
         findBlockCollisionsIterative(var6, var0, var1, var2, var3, var4);
      } else {
         findBlockCollisionsShortDistance(var6, var0, var1, var2, var4);
      }

      if (var4.isCheckingForCharacterCollisions()) {
         findCharacterCollisions(var0, var1, var2, var4, var5);
      }

      var4.process();
      class="kw">return var7;
   }

   class="kw">public class="kw">static void findBlockCollisionsIterative(
      @Nonnull World var0, @Nonnull Box var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, boolean var4, @Nonnull CollisionResult var5
   ) {
      if (var5.shouldLog()) {
         var5.getLogger()
            .at(Level.INFO)
            .log(
               "eid=%d >>>>>> Start findBlockCollisionIterative collider=[%s] pos=%s dir=%s",
               var5.getDebugEntityId(),
               var1,
               Vector3dUtil.formatShortString(var2),
               Vector3dUtil.formatShortString(var3)
            );
      }

      CollisionConfig var6 = var5.getConfig();
      var6.setWorld(var0);
      var5.getMovingBoxBoxCollision().setCollider(var1).setMove(var2, var3);
      if (var5.shouldLog()) {
         var5.getLogger().at(Level.INFO).log("eid=%d >>>>>> Start collider=[%s] + offset[%s]", var5.getDebugEntityId(), var1, var3);
      }

      var5.acquireCollisionModule();
      var1.forEachBlock(var2, 1.0E-5, var5, (var0x, var1x, var2x, var3x) -> var3x.accept(var0x, var1x, var2x));
      if (var5.shouldLog()) {
         var5.getLogger()
            .at(Level.INFO)
            .log("eid=%d >>>> line collider=[%s] dir=%s len=%s", var5.getDebugEntityId(), var1, Vector3dUtil.formatShortString(var3), var3.length());
      }

      var5.iterateBlocks(var1, var2, var3, var3.length(), var4, 1.0E-5);
      var6.clear();
   }

   class="kw">public class="kw">static void findCharacterCollisions(
      @Nonnull Box var0, @Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull CollisionResult var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      if (!isBelowMovementThreshold(var2)) {
         Vector3d var5 = new Vector3d();
         Vector2d var6 = new Vector2d();
         Box var7 = new Box();
         List var8 = var3.getCollisionEntities();

         for (int var9 = 0; var9 < var8.size(); var9++) {
            Ref var10 = var8.get(var9);
            if (var10.isValid()) {
               Archetype var11 = var4.getArchetype(var10);
               boolean var12 = var11.contains(Projectile.getComponentType()) || var11.contains(ProjectileComponent.getComponentType());
               if (!var12 && !var11.contains(DeathComponent.getComponentType())) {
                  TransformComponent var13 = var4.getComponent(var10, TransformComponent.getComponentType());
                  if (var13 != null) {
                     BoundingBox var14 = var4.getComponent(var10, BoundingBox.getComponentType());
                     if (var14 != null) {
                        Vector3d var15 = var13.getPosition();
                        Box var16 = var14.getBoundingBox();
                        if (CollisionMath.intersectSweptAABBs(var1, var2, var0, var15, var16, var6, var7) && var6.x <= 1.0) {
                           boolean var17 = var4.getComponent(var10, PlayerRef.getComponentType()) != null;
                           var5.set(var1).fma(var6.x, var2);
                           var3.allocCharacterCollision().assign(var5, var15, var6.x, var10, var17);
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static void findBlockCollisionsShortDistance(
      @Nonnull World var0, @Nonnull Box var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, @Nonnull CollisionResult var4
   ) {
      var4.reset();
      var4.getConfig().setWorld(var0);
      var4.getConfig().extraData1 = var2;
      BoxBlockIntersectionEvaluator var5 = var4.getBoxBlockIntersection();
      var5.setBox(var1, var2).offsetPosition(var3);
      var1.forEachBlock(
         var2.x + var3.x,
         var2.y + var3.y,
         var2.z + var3.z,
         1.0E-5,
         var4,
         (var0x, var1x, var2x, var3x) -> {
            CollisionConfig var4 = var3x.getConfig();
            if (!var4.canCollide(var0x, var1x, var2x)) {
               if (var3x.shouldLog()) {
                  String var14 = var4.blockType != null ? var4.blockType.getId().toString() : "null";
                  var3x.getLogger()
                     .at(Level.INFO)
                     .log("eid=%d -- Short: Ignoring block at %s/%s/%s blockType=%s", var3x.getDebugEntityId(), var0x, var1x, var2x, var14);
               }

               class="kw">return true;
            } else {
               Vector3d var5 = (Vector3d)var4.extraData1;
               if (var4.blockId == Integer.MIN_VALUE) {
                  addImmediateCollision(var5, var3x, var4, 0);
                  if (var3x.shouldLog()) {
                     var3x.getLogger()
                        .at(Level.INFO)
                        .log("eid=%d -- Short: Stopping with invalid block at %s/%s/%s blockType=<invalid>", var3x.getDebugEntityId(), var0x, var1x, var2x);
                  }

                  class="kw">return true;
               } else {
                  int var6 = var0x + var4.getBoundingBoxOffsetX();
                  int var7 = var1x + var4.getBoundingBoxOffsetY();
                  int var8 = var2x + var4.getBoundingBoxOffsetZ();
                  int var9 = var4.getDetailCount();
                  BoxBlockIntersectionEvaluator var10 = var3x.getBoxBlockIntersection();
                  int var11 = var10.intersectBoxComputeTouch(var4.getBoundingBox(), var6, var7, var8);
                  boolean var12 = !CollisionMath.isDisjoint(var11);
                  if (var3x.shouldLog()) {
                     String var13 = var4.blockType != null ? var4.blockType.getId().toString() : "null";
                     var3x.getLogger()
                        .at(Level.INFO)
                        .log(
                           "eid=%d ?? Block Test at %s/%s/%s numDet=%d haveColl=%s overlap=%s blockType=%s",
                           var3x.getDebugEntityId(),
                           var0x,
                           var1x,
                           var2x,
                           var9,
                           var12,
                           var3x.getBoxBlockIntersection().isOverlapping(),
                           var13
                        );
                  }

                  if (var9 <= 1) {
                     processCollision(var3x, var5, var10, var12, 0);
                  } else {
                     for (int var17 = 0; var17 < var9; var17++) {
                        var11 = var10.intersectBoxComputeTouch(var4.getBoundingBox(var17), var6, var7, var8);
                        var12 = !CollisionMath.isDisjoint(var11);
                        processCollision(var3x, var5, var10, var12, var17);
                     }
                  }

                  class="kw">return true;
               }
            }
         }
      );
      var4.getConfig().clear();
   }

   class="kw">protected class="kw">static void processCollision(
      @Nonnull CollisionResult var0, @Nonnull Vector3d var1, @Nonnull BoxBlockIntersectionEvaluator var2, boolean var3, int var4
   ) {
      CollisionConfig var5 = var0.getConfig();
      Predicate var6 = var5.getBlockCollisionPredicate();
      if (var0.shouldLog()) {
         var0.getLogger()
            .at(Level.INFO)
            .log(
               "eid=%d ?? Short: Further testing block haveCol=%s hitBoxIndex=%s onGround=%s touching=%s canCollide=%s canTrigger=%s",
               var0.getDebugEntityId(),
               var3,
               var4,
               var2.isOnGround(),
               var2.isTouching(),
               var5.blockCanCollide,
               var5.blockCanTrigger
            );
      }

      if (var2.isOnGround() && var5.blockCanCollide) {
         var3 = var5.blockType == null || !var6.test(var5);
         if (!var3) {
            var0.addSlide(var2, var4);
            if (var5.blockCanTrigger) {
               var0.addTrigger(var2, var4);
            }

            if (var0.shouldLog()) {
               var0.getLogger()
                  .at(Level.INFO)
                  .log(
                     "eid=%d ++ Short: Sliding block start=%s end=%s normal=%s",
                     var0.getDebugEntityId(),
                     var2.getCollisionStart(),
                     var2.getCollisionEnd(),
                     Vector3dUtil.formatShortString(var2.getCollisionNormal())
                  );
            }

            class="kw">return;
         }

         if (var0.shouldLog()) {
            var0.getLogger()
               .at(Level.INFO)
               .log(
                  "eid=%d ?? Short: Sliding block is unwalkable start=%s end=%s normal=%s",
                  var0.getDebugEntityId(),
                  var2.getCollisionStart(),
                  var2.getCollisionEnd(),
                  Vector3dUtil.formatShortString(var2.getCollisionNormal())
               );
         }
      }

      if (var3 && var5.blockCanCollide) {
         addImmediateCollision(var1, var0, var5, var4);
         if (var0.shouldLog()) {
            var0.getLogger()
               .at(Level.INFO)
               .log(
                  "eid=%d ++ Short: Collision with block start=%s end=%s normal=%s",
                  var0.getDebugEntityId(),
                  var2.getCollisionStart(),
                  var2.getCollisionEnd(),
                  Vector3dUtil.formatShortString(var2.getCollisionNormal())
               );
         }
      }

      if (var5.blockCanTrigger && (var3 || var2.isTouching())) {
         if (var0.shouldLog()) {
            var0.getLogger()
               .at(Level.INFO)
               .log(
                  "eid=%d ++ Short: Trigger block start=%s end=%s normal=%s",
                  var0.getDebugEntityId(),
                  var2.getCollisionStart(),
                  var2.getCollisionEnd(),
                  Vector3dUtil.formatShortString(var2.getCollisionNormal())
               );
         }

         var0.addTrigger(var2, var4);
      }
   }

   class="kw">public void findIntersections(@Nonnull World var1, @Nonnull Box var2, @Nonnull Vector3d var3, @Nonnull CollisionResult var4, boolean var5, boolean var6) {
      if (!this.isDisabled()) {
         var4.reset();
         var4.getConfig().setWorld(var1);
         var4.getConfig().extraData1 = var5;
         var4.getConfig().extraData2 = var6;
         var4.getBoxBlockIntersection().setBox(var2, var3).expandBox(0.01);
         var4.getBoxBlockIntersection().box.forEachBlock(var3, 1.0E-5, var4, (var0, var1x, var2x, var3x) -> {
            CollisionConfig var4 = var3x.getConfig();
            if (!var4.canCollide(var0, var1x, var2x)) {
               class="kw">return true;
            }

            int var5 = var0 + var4.getBoundingBoxOffsetX();
            int var6 = var1x + var4.getBoundingBoxOffsetY();
            int var7 = var2x + var4.getBoundingBoxOffsetZ();
            if (!var3x.getBoxBlockIntersection().isBoxIntersecting(var4.getBoundingBox(), var5, var6, var7)) {
               class="kw">return true;
            }

            boolean var8 = (Boolean)var4.extraData1;
            boolean var9 = (Boolean)var4.extraData2;
            int var10 = var4.getDetailCount();
            if (var10 <= 1) {
               if (var8 && var4.blockCanTrigger) {
                  var3x.addTrigger(var3x.getBoxBlockIntersection(), 0);
               }

               if (var9) {
                  var3x.addCollision(var3x.getBoxBlockIntersection(), 0);
               }
            } else {
               for (int var11 = 0; var11 < var10; var11++) {
                  if (var3x.getBoxBlockIntersection().isBoxIntersecting(var4.getBoundingBox(var11), var5, var6, var7)) {
                     if (var8 && var4.blockCanTrigger) {
                        var3x.addTrigger(var3x.getBoxBlockIntersection(), var11);
                     }

                     if (var9) {
                        var3x.addCollision(var3x.getBoxBlockIntersection(), var11);
                     }
                  }
               }
            }

            class="kw">return true;
         });
         var4.getConfig().clear();
      }
   }

   class="kw">public int validatePosition(@Nonnull World var1, @Nonnull Box var2, @Nonnull Vector3dc var3, @Nonnull CollisionResult var4) {
      class="kw">return this.isDisabled() ? 0 : this.validatePosition(var1, var2, var3, null, (var0, var1x, var2x, var3x) -> true, false, var4);
   }

   class="kw">public <T> int validatePosition(
      @Nonnull World var1,
      @Nonnull Box var2,
      @Nonnull Vector3dc var3,
      int var4,
      @Nullable T var5,
      @Nonnull CollisionFilter<BoxBlockIntersectionEvaluator, T> var6,
      @Nonnull CollisionResult var7
   ) {
      if (this.isDisabled()) {
         class="kw">return 0;
      }

      int var8 = var7.getCollisionByMaterial();
      var7.setCollisionByMaterial(var4);
      int var9 = this.validatePosition(var1, var2, var3, var5, var6, (var4 & 16) == 0, var7);
      var7.setCollisionByMaterial(var8);
      class="kw">return var9;
   }

   class="kw">private <T> int validatePosition(
      @Nonnull World var1,
      @Nonnull Box var2,
      @Nonnull Vector3dc var3,
      @Nullable T var4,
      @Nullable CollisionFilter<BoxBlockIntersectionEvaluator, T> var5,
      boolean var6,
      @Nonnull CollisionResult var7
   ) {
      CollisionModuleConfig var8 = this.config.get();
      var7.getConfig().setWorld(var1);
      var7.getConfig().dumpInvalidBlocks = var8.isDumpInvalidBlocks();
      var7.getConfig().dumpNonOverlappingBlocks = var8.isDumpNonOverlappingBlocks();
      var7.getConfig().extraData1 = var4;
      var7.getConfig().extraData2 = var5;
      var7.getBoxBlockIntersection().setBox(var2, var3);
      boolean var9 = var7.isCheckingTriggerBlocks();
      boolean var10 = var7.isCheckingDamageBlocks();
      var7.disableTriggerBlocks();
      if (var6) {
         var7.disableDamageBlocks();
      }

      var7.validate = 0;
      var2.forEachBlock(var3, 1.0E-5, var7, (var0, var1x, var2x, var3x) -> {
         CollisionConfig var4 = var3x.getConfig();
         if (!var4.canCollide(var0, var1x, var2x)) {
            class="kw">return true;
         }

         BoxBlockIntersectionEvaluator var5 = var3x.getBoxBlockIntersection();
         int var6 = var0 + var4.getBoundingBoxOffsetX();
         int var7 = var1x + var4.getBoundingBoxOffsetY();
         int var8 = var2x + var4.getBoundingBoxOffsetZ();
         int var9 = var5.intersectBoxComputeOnGround(var4.getBoundingBox(), var6, var7, var8);
         if (var4.blockId == Integer.MIN_VALUE) {
            if (CollisionMath.isOverlapping(var9)) {
               var3x.validate = -1;
               class="kw">return false;
            } else {
               class="kw">return true;
            }
         } else {
            if (CollisionMath.isDisjoint(var9)) {
               class="kw">return true;
            }

            Box var10 = var5.box;
            Vector3d var11 = var5.collisionPoint;
            Object var12 = var4.extraData1;
            CollisionFilter var13 = (CollisionFilter<BoxBlockIntersectionEvaluator, Object>)var4.extraData2;
            int var14 = var4.getDetailCount();
            if (var14 <= 1) {
               if (!var13.test(var12, var9, var5, var4)) {
                  class="kw">return true;
               }

               if (CollisionMath.isOverlapping(var9)) {
                  if (var4.dumpInvalidBlocks) {
                     logOverlap(var3x.getDebugEntityId(), var11, var10, var4, var4.getBoundingBox(), var0, var1x, var2x, 0, var9, true);
                  }

                  var3x.validate = -1;
                  class="kw">return false;
               }

               if (var4.dumpNonOverlappingBlocks) {
                  logOverlap(var3x.getDebugEntityId(), var11, var10, var4, var4.getBoundingBox(), var0, var1x, var2x, 0, var9, false);
               }

               if (var5.isOnGround()) {
                  var3x.validate |= 1;
               }

               if (var5.touchesCeil()) {
                  var3x.validate |= 2;
               }
            } else {
               for (int var15 = 0; var15 < var14; var15++) {
                  var9 = var5.intersectBoxComputeOnGround(var4.getBoundingBox(var15), var6, var7, var8);
                  if (!CollisionMath.isDisjoint(var9) && var13.test(var12, var9, var5, var4)) {
                     if (CollisionMath.isOverlapping(var9)) {
                        if (var4.dumpInvalidBlocks) {
                           logOverlap(var3x.getDebugEntityId(), var11, var10, var4, var4.getBoundingBox(var15), var0, var1x, var2x, var15, var9, true);
                        }

                        var3x.validate = -1;
                        class="kw">return false;
                     }

                     if (var4.dumpNonOverlappingBlocks) {
                        logOverlap(var3x.getDebugEntityId(), var11, var10, var4, var4.getBoundingBox(var15), var0, var1x, var2x, var15, var9, false);
                     }

                     if (var5.isOnGround()) {
                        var3x.validate |= 1;
                     }

                     if (var5.touchesCeil()) {
                        var3x.validate |= 2;
                     }
                  }
               }
            }

            class="kw">return true;
         }
      });
      if (var9) {
         var7.enableTriggerBlocks();
      }

      if (var10) {
         var7.enableDamageBlocks();
      }

      var7.getConfig().clear();
      class="kw">return var7.validate;
   }

   class="kw">private class="kw">static void addImmediateCollision(@Nonnull Vector3d var0, @Nonnull CollisionResult var1, @Nonnull CollisionConfig var2, int var3) {
      BlockCollisionData var4 = var1.newCollision();
      var4.setStart(var0, 0.0);
      var4.setEnd(1.0, var1.getBoxBlockIntersection().getCollisionNormal());
      var4.setBlockData(var2);
      var4.setDetailBoxIndex(var3);
      var4.setTouchingOverlapping(false, true);
   }

   class="kw">public class="kw">static boolean isBelowMovementThreshold(@Nonnull Vector3d var0) {
      class="kw">return var0.lengthSquared() < 1.0000000000000002E-10;
   }

   class="kw">private class="kw">static void logOverlap(
      int var0,
      @Nonnull Vector3d var1,
      @Nonnull Box var2,
      @Nonnull CollisionConfig var3,
      @Nonnull Box var4,
      int var5,
      int var6,
      int var7,
      int var8,
      int var9,
      boolean var10
   ) {
      get()
         .getLogger()
         .at(Level.WARNING)
         .log(
            "eid=%d %sOverlapping blocks - code=%s%s%s index=%s pos=%s loc=%s/%s/%s id=%s mat=%s name=%s box=%s|%s hitbox=%s|%s",
            var0,
            var10 ? "" : "Non-",
            (var9 & 8) != 0 ? "X" : "",
            (var9 & 16) != 0 ? "Y" : "",
            (var9 & 32) != 0 ? "Z" : "",
            var8,
            Vector3dUtil.formatShortString(var1),
            var5 + var3.getBoundingBoxOffsetX(),
            var6 + var3.getBoundingBoxOffsetY(),
            var7 + var3.getBoundingBoxOffsetZ(),
            new Object[]{
               var3.blockId,
               var3.blockMaterial != null ? var3.blockMaterial.name() : "none",
               var3.blockType != null ? var3.blockType.getId() : "none",
               Vector3dUtil.formatShortString(var2.getMin()),
               Vector3dUtil.formatShortString(var2.getMax()),
               Vector3dUtil.formatShortString(var4.min),
               Vector3dUtil.formatShortString(var4.max)
            }
         );
   }
}