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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.data.Int3OpenHashSet;
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.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
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.entity.Entity;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionChain;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.entity.LivingEntity;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
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.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Comparator;
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.Vector3d;

class="kw">public class CollisionResult class="kw">implements BoxBlockIterator.BoxIterationConsumer {
   class="kw">public class="kw">static class="kw">final Comparator<BlockCollisionData> BLOCK_COLLISION_DATA_COMPARATOR = Comparator.<BlockCollisionData>comparingDouble(
         var0 -> var0.collisionStart
      )
      .thenComparingDouble(var0 -> var0.collisionEnd);
   @Nonnull
   class="kw">private class="kw">final CollisionConfig collisionConfig;
   @Nonnull
   class="kw">private class="kw">final CollisionDataArray<BlockCollisionData> blockCollisions;
   @Nonnull
   class="kw">private class="kw">final CollisionDataArray<BlockCollisionData> blockSlides;
   @Nonnull
   class="kw">private class="kw">final CollisionDataArray<BlockCollisionData> blockTriggers;
   @Nonnull
   class="kw">private class="kw">final CollisionDataArray<BlockCollisionData> passThroughBlocks;
   @Nonnull
   class="kw">private class="kw">final CollisionDataArray<CharacterCollisionData> characterCollisions;
   @Nonnull
   class="kw">private class="kw">final MovingBoxBoxCollisionEvaluator movingBoxBoxCollision;
   @Nonnull
   class="kw">private class="kw">final BoxBlockIntersectionEvaluator boxBlockIntersection;
   class="kw">public List<Ref<EntityStore>> collisionEntities;
   class="kw">private boolean continueAfterCollision = true;
   class="kw">private boolean haveNoCollision = true;
   class="kw">private HytaleLogger logger;
   class="kw">private int debugEntityId = -1;
   class="kw">public double slideStart;
   class="kw">public double slideEnd;
   class="kw">public boolean isSliding;
   class="kw">public int validate;
   class="kw">private boolean checkForCharacterCollisions;
   class="kw">private boolean recordPassThrough;
   class="kw">private int walkableMaterialMask;
   class="kw">public Predicate<CollisionConfig> isNonWalkable;
   class="kw">private Int3OpenHashSet lastTriggers = new Int3OpenHashSet();
   class="kw">private Int3OpenHashSet newTriggers = new Int3OpenHashSet();

   class="kw">public CollisionResult() {
      this(true, false);
   }

   class="kw">public CollisionResult(boolean var1, boolean var2) {
      ObjectArrayList var3 = new ObjectArrayList();
      ObjectArrayList var4 = new ObjectArrayList();
      this.blockCollisions = new CollisionDataArray<>(BlockCollisionData::new, BlockCollisionData::clear, var3);
      this.blockSlides = new CollisionDataArray<>(BlockCollisionData::new, BlockCollisionData::clear, var3);
      this.blockTriggers = new CollisionDataArray<>(BlockCollisionData::new, BlockCollisionData::clear, var3);
      this.passThroughBlocks = new CollisionDataArray<>(BlockCollisionData::new, BlockCollisionData::clear, var3);
      this.characterCollisions = new CollisionDataArray<>(CharacterCollisionData::new, null, var4);
      this.collisionConfig = new CollisionConfig();
      this.collisionConfig.setDefaultCollisionBehaviour();
      this.movingBoxBoxCollision = new MovingBoxBoxCollisionEvaluator();
      this.movingBoxBoxCollision.setCheckForOnGround(var1);
      this.boxBlockIntersection = new BoxBlockIntersectionEvaluator();
      this.checkForCharacterCollisions = var2;
      this.setDefaultWalkableBehaviour();
   }

   @Nonnull
   class="kw">public CollisionConfig getConfig() {
      class="kw">return this.collisionConfig;
   }

   class="kw">public List<Ref<EntityStore>> getCollisionEntities() {
      class="kw">return this.collisionEntities;
   }

   class="kw">public void setCollisionEntities(List<Ref<EntityStore>> var1) {
      this.collisionEntities = var1;
   }

   @Nonnull
   class="kw">public BoxBlockIntersectionEvaluator getBoxBlockIntersection() {
      class="kw">return this.boxBlockIntersection;
   }

   @Nonnull
   class="kw">public MovingBoxBoxCollisionEvaluator getMovingBoxBoxCollision() {
      class="kw">return this.movingBoxBoxCollision;
   }

   class="kw">public CharacterCollisionData allocCharacterCollision() {
      class="kw">return this.characterCollisions.alloc();
   }

   class="kw">public void addCollision(@Nonnull IBlockCollisionEvaluator var1, int var2) {
      if (!(var1.getCollisionStart() > 1.0)) {
         var1.setCollisionData(this.newCollision(), this.collisionConfig, var2);
      }
   }

   class="kw">public BlockCollisionData newCollision() {
      class="kw">return this.blockCollisions.alloc();
   }

   class="kw">public void addSlide(@Nonnull IBlockCollisionEvaluator var1, int var2) {
      if (!(var1.getCollisionStart() > 1.0)) {
         var1.setCollisionData(this.newSlide(), this.collisionConfig, var2);
      }
   }

   class="kw">public BlockCollisionData newSlide() {
      class="kw">return this.blockSlides.alloc();
   }

   class="kw">public void addTrigger(@Nonnull IBlockCollisionEvaluator var1, int var2) {
      if (!(var1.getCollisionStart() > 1.0)) {
         var1.setCollisionData(this.newTrigger(), this.collisionConfig, var2);
      }
   }

   class="kw">public BlockCollisionData newTrigger() {
      class="kw">return this.blockTriggers.alloc();
   }

   class="kw">public void addPassThrough(@Nonnull IBlockCollisionEvaluator var1, int var2) {
      if (!(var1.getCollisionStart() > 1.0)) {
         var1.setCollisionData(this.newPassThrough(), this.collisionConfig, var2);
      }
   }

   class="kw">public BlockCollisionData newPassThrough() {
      class="kw">return this.passThroughBlocks.alloc();
   }

   class="kw">public void reset() {
      this.blockCollisions.reset();
      this.blockSlides.reset();
      this.blockTriggers.reset();
      this.passThroughBlocks.reset();
      this.characterCollisions.reset();
   }

   class="kw">public void process() {
      this.blockCollisions.sort(BasicCollisionData.COLLISION_START_COMPARATOR);
      this.blockTriggers.sort(BasicCollisionData.COLLISION_START_COMPARATOR);
      this.passThroughBlocks.sort(BasicCollisionData.COLLISION_START_COMPARATOR);
      this.characterCollisions.sort(BasicCollisionData.COLLISION_START_COMPARATOR);
      if (this.blockSlides.getCount() > 0) {
         this.blockSlides.sort(BLOCK_COLLISION_DATA_COMPARATOR);
         BlockCollisionData var1 = this.blockSlides.get(0);
         this.slideStart = var1.collisionStart;
         this.slideEnd = var1.collisionEnd;

         for (int var2 = 1; var2 < this.blockSlides.getCount(); var2++) {
            var1 = this.blockSlides.get(var2);
            if (var1.collisionStart <= this.slideEnd && var1.collisionEnd > this.slideEnd) {
               this.slideEnd = var1.collisionEnd;
            }
         }

         this.isSliding = this.slideStart <= 0.0;
         if (this.slideEnd > 1.0) {
            this.slideEnd = 1.0;
         }
      } else {
         this.isSliding = false;
      }
   }

   class="kw">public int getBlockCollisionCount() {
      class="kw">return this.blockCollisions.getCount();
   }

   class="kw">public BlockCollisionData getBlockCollision(int var1) {
      class="kw">return this.blockCollisions.get(var1);
   }

   @Nullable
   class="kw">public BlockCollisionData getFirstBlockCollision() {
      class="kw">return this.blockCollisions.getFirst();
   }

   @Nullable
   class="kw">public BlockCollisionData forgetFirstBlockCollision() {
      class="kw">return this.blockCollisions.forgetFirst();
   }

   class="kw">public int getCharacterCollisionCount() {
      class="kw">return this.characterCollisions.getCount();
   }

   class="kw">public CharacterCollisionData getCharacterCollision(int var1) {
      class="kw">return this.characterCollisions.get(var1);
   }

   @Nullable
   class="kw">public CharacterCollisionData getFirstCharacterCollision() {
      class="kw">return this.characterCollisions.getFirst();
   }

   @Nullable
   class="kw">public CharacterCollisionData forgetFirstCharacterCollision() {
      class="kw">return this.characterCollisions.forgetFirst();
   }

   class="kw">public int getPassThroughCount() {
      class="kw">return this.passThroughBlocks.getCount();
   }

   class="kw">public BlockCollisionData getPassThrough(int var1) {
      class="kw">return this.passThroughBlocks.get(var1);
   }

   class="kw">public void pruneTriggerBlocks(double var1) {
      for (int var3 = this.blockTriggers.size() - 1; var3 >= 0; var3--) {
         BlockCollisionData var4 = this.blockTriggers.get(var3);
         if (var4.collisionStart <= var1) {
            break;
         }

         this.blockTriggers.remove(var3);
      }
   }

   @Nonnull
   class="kw">public CollisionDataArray<BlockCollisionData> getTriggerBlocks() {
      class="kw">return this.blockTriggers;
   }

   class="kw">public int defaultTriggerBlocksProcessing(
      @Nonnull InteractionManager var1, @Nonnull Entity var2, @Nonnull Ref<EntityStore> var3, boolean var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      ChunkStore var6 = var5.getExternalData().getWorld().getChunkStore();
      Int3OpenHashSet var7 = this.lastTriggers;
      this.lastTriggers = this.newTriggers;
      this.newTriggers = var7;
      this.newTriggers.clear();
      int var8 = 0;
      CollisionDataArray var9 = this.getTriggerBlocks();
      int var10 = 0;

      for (int var11 = var9.size(); var10 < var11; var10++) {
         BlockCollisionData var12 = var9.get(var10);
         if (var12.blockType != null) {
            int var13 = Math.max(var12.blockType.getDamageToEntities(), var12.fluid.getDamageToEntities());
            if (var13 > var8) {
               var8 = var13;
            }
         }

         if (var4 && var2 class="kw">instanceof LivingEntity) {
            Ref var25 = var6.getChunkSectionReferenceAtBlock(var12.x, var12.y, var12.z);
            if (var25 != null && var25.isValid()) {
               BlockSection var14 = var6.getStore().getComponent(var25, BlockSection.getComponentType());
               if (var14 != null) {
                  FluidSection var15 = var6.getStore().getComponent(var25, FluidSection.getComponentType());
                  BlockType var16 = BlockType.getAssetMap().getAsset(var14.get(var12.x, var12.y, var12.z));
                  Fluid var17 = Fluid.getAssetMap().getAsset(var15 != null ? var15.getFluidId(var12.x, var12.y, var12.z) : 0);
                  String var18 = var16.getInteractions().get(InteractionType.CollisionEnter);
                  if (var18 == null) {
                     var18 = var17.getInteractions().get(InteractionType.CollisionEnter);
                  }

                  String var19 = var16.getInteractions().get(InteractionType.Collision);
                  if (var19 == null) {
                     var19 = var17.getInteractions().get(InteractionType.Collision);
                  }

                  if (var18 != null || var19 != null) {
                     int var20 = var14.getFiller(var12.x, var12.y, var12.z);
                     int var21 = var12.x;
                     int var22 = var12.y;
                     int var23 = var12.z;
                     if (var20 != 0) {
                        var21 -= FillerBlockUtil.unpackX(var20);
                        var22 -= FillerBlockUtil.unpackY(var20);
                        var23 -= FillerBlockUtil.unpackZ(var20);
                     }

                     if (this.newTriggers.add(var21, var22, var23)) {
                        if (!this.lastTriggers.remove(var21, var22, var23) && var18 != null) {
                           BlockPosition var24 = new BlockPosition(var21, var22, var23);
                           this.doCollisionInteraction(var1, InteractionType.CollisionEnter, var3, var18, var24, var5);
                        }

                        if (var19 != null) {
                           BlockPosition var26 = new BlockPosition(var21, var22, var23);
                           this.doCollisionInteraction(var1, InteractionType.Collision, var3, var19, var26, var5);
                        }
                     }
                  }
               }
            }
         }
      }

      if (var4 && var2 class="kw">instanceof LivingEntity && !this.lastTriggers.isEmpty()) {
         this.lastTriggers.forEach((var5x, var6x, var7x) -> {
            Ref var8 = var6.getChunkSectionReferenceAtBlock(var5x, var6x, var7x);
            if (var8 != null && var8.isValid()) {
               BlockSection var9 = var6.getStore().getComponent(var8, BlockSection.getComponentType());
               if (var9 != null) {
                  FluidSection var10 = var6.getStore().getComponent(var8, FluidSection.getComponentType());
                  BlockType var11 = BlockType.getAssetMap().getAsset(var9.get(var5x, var6x, var7x));
                  Fluid var12 = Fluid.getAssetMap().getAsset(var10 != null ? var10.getFluidId(var5x, var6x, var7x) : 0);
                  String var13 = var11.getInteractions().get(InteractionType.CollisionLeave);
                  if (var13 == null) {
                     var13 = var12.getInteractions().get(InteractionType.CollisionLeave);
                  }

                  if (var13 != null) {
                     this.doCollisionInteraction(var1, InteractionType.CollisionLeave, var3, var13, new BlockPosition(var5x, var6x, var7x), var5);
                  }
               }
            }
         });
      }

      class="kw">return var8;
   }

   class="kw">private void doCollisionInteraction(
      @Nonnull InteractionManager var1,
      @Nonnull InteractionType var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull String var4,
      @Nonnull BlockPosition var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      RootInteraction var7 = RootInteraction.getRootInteractionOrUnknown(var4);
      InteractionContext var8 = InteractionContext.forInteraction(var1, var3, var2, var6);
      var8.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK_RAW, var5);
      var8.getMetaStore().putMetaObject(Interaction.TARGET_BLOCK, var5);
      InteractionChain var9 = var1.initChain(var2, var8, var7, -1, var5, false);
      var1.queueExecuteChain(var9);
   }

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

   @Override
   class="kw">public boolean accept(long var1, long var3, long var5) {
      if (this.collisionConfig.canCollide((int)var1, (int)var3, (int)var5)) {
         var1 += this.collisionConfig.getBoundingBoxOffsetX();
         var3 += this.collisionConfig.getBoundingBoxOffsetY();
         var5 += this.collisionConfig.getBoundingBoxOffsetZ();
         int var7 = this.collisionConfig.getDetailCount();
         boolean var8 = this.movingBoxBoxCollision.isBoundingBoxColliding(this.collisionConfig.getBoundingBox(), var1, var3, var5);
         if (this.logger != null) {
            Object var9 = this.collisionConfig.blockType != null ? this.collisionConfig.blockType.getId() : "null";
            this.logger
               .at(Level.INFO)
               .log(
                  "?? Block Test at %s/%s/%s numDet=%d haveColl=%s overlap=%s blockType=%s",
                  var1,
                  var3,
                  var5,
                  var7,
                  var8,
                  this.movingBoxBoxCollision.isOverlapping(),
                  var9
               );
         }

         if (var7 <= 1) {
            this.processCollisionResult(var8, 0);
         } else if (var8 || this.movingBoxBoxCollision.isOverlapping() || this.movingBoxBoxCollision.isTouching()) {
            for (int var21 = 0; var21 < var7; var21++) {
               var8 = this.movingBoxBoxCollision.isBoundingBoxColliding(this.collisionConfig.getBoundingBox(var21), var1, var3, var5);
               this.processCollisionResult(var8, var21);
            }
         }
      } else if (this.recordPassThrough && this.collisionConfig.blockFilteredOut) {
         var1 += this.collisionConfig.getBoundingBoxOffsetX();
         var3 += this.collisionConfig.getBoundingBoxOffsetY();
         var5 += this.collisionConfig.getBoundingBoxOffsetZ();
         int var17 = this.collisionConfig.getDetailCount();
         boolean var19 = this.movingBoxBoxCollision.isBoundingBoxColliding(this.collisionConfig.getBoundingBox(), var1, var3, var5);
         if (var17 <= 1) {
            if (var19) {
               this.addPassThrough(this.movingBoxBoxCollision, 0);
            }
         } else if (var19 || this.movingBoxBoxCollision.isOverlapping() || this.movingBoxBoxCollision.isTouching()) {
            for (int var22 = 0; var22 < var17; var22++) {
               var19 = this.movingBoxBoxCollision.isBoundingBoxColliding(this.collisionConfig.getBoundingBox(var22), var1, var3, var5);
               if (var19) {
                  this.addPassThrough(this.movingBoxBoxCollision, var22);
               }
            }
         }
      } else if (this.logger != null) {
         Object var16 = this.collisionConfig.blockType != null ? this.collisionConfig.blockType.getId() : "null";
         this.logger.at(Level.INFO).log("-- Ignoring block at %s/%s/%s blockType=%s", var1, var3, var5, var16);
      }

      class="kw">return true;
   }

   class="kw">private void processCollisionResult(boolean var1, int var2) {
      if (this.logger != null) {
         this.logger
            .at(Level.INFO)
            .log(
               "?? Further testing block haveCol=%s hitBoxIndex=%s onGround=%s touching=%s canCollide=%s canTrigger=%s",
               var1,
               var2,
               this.movingBoxBoxCollision.isOnGround(),
               this.movingBoxBoxCollision.isTouching(),
               this.collisionConfig.blockCanCollide,
               this.collisionConfig.blockCanTrigger
            );
      }

      if (this.collisionConfig.blockCanCollide) {
         boolean var3 = true;
         if (this.movingBoxBoxCollision.onGround) {
            var1 = this.collisionConfig.blockType == null || this.isNonWalkable.test(this.collisionConfig);
            if (!var1) {
               this.addSlide(this.movingBoxBoxCollision, var2);
               if (this.collisionConfig.blockCanTrigger) {
                  this.addTrigger(this.movingBoxBoxCollision, var2);
               }

               if (this.logger != null) {
                  this.logger
                     .at(Level.INFO)
                     .log(
                        "++ Sliding block start=%s end=%s normal=%s",
                        this.movingBoxBoxCollision.getCollisionStart(),
                        this.movingBoxBoxCollision.getCollisionEnd(),
                        Vector3dUtil.formatShortString(this.movingBoxBoxCollision.getCollisionNormal())
                     );
               }

               class="kw">return;
            }

            var3 = false;
            if (this.logger != null) {
               this.logger
                  .at(Level.INFO)
                  .log(
                     "?? Sliding block is unwalkable start=%s end=%s normal=%s",
                     this.movingBoxBoxCollision.getCollisionStart(),
                     this.movingBoxBoxCollision.getCollisionEnd(),
                     Vector3dUtil.formatShortString(this.movingBoxBoxCollision.getCollisionNormal())
                  );
            }
         }

         if (var1) {
            this.addCollision(this.movingBoxBoxCollision, var2);
            if (var3) {
               this.haveNoCollision = false;
            }

            if (this.logger != null) {
               this.logger
                  .at(Level.INFO)
                  .log(
                     "++ Collision with block start=%s end=%s normal=%s",
                     this.movingBoxBoxCollision.collisionStart,
                     this.movingBoxBoxCollision.collisionEnd,
                     Vector3dUtil.formatShortString(this.movingBoxBoxCollision.collisionNormal)
                  );
            }
         }
      }

      if (this.collisionConfig.blockCanTrigger && (var1 || this.movingBoxBoxCollision.isTouching())) {
         if (this.logger != null) {
            this.logger
               .at(Level.INFO)
               .log(
                  "++ Trigger block start=%s end=%s normal=%s",
                  this.movingBoxBoxCollision.getCollisionStart(),
                  this.movingBoxBoxCollision.getCollisionEnd(),
                  Vector3dUtil.formatShortString(this.movingBoxBoxCollision.getCollisionNormal())
               );
         }

         this.addTrigger(this.movingBoxBoxCollision, var2);
      }
   }

   class="kw">public void iterateBlocks(@Nonnull Box var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, double var4, boolean var6, double var7) {
      this.continueAfterCollision = !var6;
      Vector3d var9 = var1.getMin();
      Vector3d var10 = var1.getMax();
      BoxBlockIterator.iterate(
         var9.x - var7,
         var9.y - var7,
         var9.z - var7,
         var10.x + var7,
         var10.y + var7,
         var10.z + var7,
         var2.x,
         var2.y,
         var2.z,
         var3.x,
         var3.y,
         var3.z,
         var4,
         this
      );
   }

   class="kw">public void acquireCollisionModule() {
      this.haveNoCollision = true;
   }

   class="kw">public void disableSlides() {
      this.movingBoxBoxCollision.setCheckForOnGround(false);
   }

   class="kw">public void enableSlides() {
      this.movingBoxBoxCollision.setCheckForOnGround(true);
   }

   class="kw">public void disableCharacterCollisions() {
      this.checkForCharacterCollisions = false;
   }

   class="kw">public void enableCharacterCollsions() {
      this.checkForCharacterCollisions = true;
   }

   class="kw">public boolean isCheckingForCharacterCollisions() {
      class="kw">return this.checkForCharacterCollisions;
   }

   class="kw">public boolean isRecordingPassThrough() {
      class="kw">return this.recordPassThrough;
   }

   class="kw">public void setRecordPassThrough(boolean var1) {
      this.recordPassThrough = var1;
   }

   class="kw">public void enableTriggerBlocks() {
      this.collisionConfig.setCheckTriggerBlocks(true);
   }

   class="kw">public void disableTriggerBlocks() {
      this.collisionConfig.setCheckTriggerBlocks(false);
   }

   class="kw">public boolean isCheckingTriggerBlocks() {
      class="kw">return this.collisionConfig.isCheckTriggerBlocks();
   }

   class="kw">public void enableDamageBlocks() {
      this.collisionConfig.setCheckDamageBlocks(true);
   }

   class="kw">public void disableDamageBlocks() {
      this.collisionConfig.setCheckDamageBlocks(false);
   }

   class="kw">public boolean isCheckingDamageBlocks() {
      class="kw">return this.collisionConfig.isCheckDamageBlocks();
   }

   class="kw">public boolean setDamageBlocking(boolean var1) {
      boolean var2 = this.collisionConfig.setCollideWithDamageBlocks(var1);
      this.updateDamageWalkableFlag();
      class="kw">return var2;
   }

   class="kw">public boolean isDamageBlocking() {
      class="kw">return this.collisionConfig.isCollidingWithDamageBlocks();
   }

   @Nullable
   class="kw">public Predicate<CollisionConfig> getBlockCollisionFilter() {
      class="kw">return this.collisionConfig.extraBlockCollisionFilter;
   }

   @Nullable
   class="kw">public Predicate<CollisionConfig> setBlockCollisionFilter(@Nullable Predicate<CollisionConfig> var1) {
      Predicate var2 = this.collisionConfig.extraBlockCollisionFilter;
      this.collisionConfig.extraBlockCollisionFilter = var1;
      class="kw">return var2;
   }

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

   class="kw">public void setCollisionByMaterial(int var1, int var2) {
      this.collisionConfig.setCollisionByMaterial(var1);
      this.setWalkableByMaterial(var2);
   }

   class="kw">public int getCollisionByMaterial() {
      class="kw">return this.collisionConfig.getCollisionByMaterial();
   }

   class="kw">public void setDefaultCollisionBehaviour() {
      this.collisionConfig.setDefaultCollisionBehaviour();
   }

   class="kw">public void setDefaultBlockCollisionPredicate() {
      this.collisionConfig.setDefaultBlockCollisionPredicate();
   }

   class="kw">public void setDefaultNonWalkablePredicate() {
      this.isNonWalkable = var1 -> {
         int var2 = var1.blockMaterialMask & this.walkableMaterialMask;
         class="kw">return var2 == 0 || (var2 & 16) != 0;
      };
   }

   class="kw">public void setNonWalkablePredicate(Predicate<CollisionConfig> var1) {
      this.isNonWalkable = var1;
   }

   class="kw">public void setWalkableByMaterial(int var1) {
      this.walkableMaterialMask = 15 & var1;
      this.updateDamageWalkableFlag();
   }

   class="kw">protected void updateDamageWalkableFlag() {
      if (this.collisionConfig.isCollidingWithDamageBlocks()) {
         this.walkableMaterialMask |= 16;
      } else {
         this.walkableMaterialMask &= -17;
      }
   }

   class="kw">public void setDefaultWalkableBehaviour() {
      this.setDefaultNonWalkablePredicate();
      this.setWalkableByMaterial(5);
   }

   class="kw">public void setDefaultPlayerSettings() {
      this.enableSlides();
      this.disableCharacterCollisions();
      this.setDefaultNonWalkablePredicate();
      this.setDefaultBlockCollisionPredicate();
      this.setCollisionByMaterial(4);
      this.setWalkableByMaterial(15);
   }

   class="kw">public boolean isComputeOverlaps() {
      class="kw">return this.movingBoxBoxCollision.isComputeOverlaps();
   }

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

   class="kw">public HytaleLogger getLogger() {
      class="kw">return this.logger;
   }

   class="kw">public boolean shouldLog() {
      class="kw">return this.logger != null;
   }

   class="kw">public void setLogger(HytaleLogger var1) {
      this.logger = var1;
   }

   class="kw">public void setLogger(HytaleLogger var1, int var2) {
      this.logger = var1;
      this.debugEntityId = var2;
   }

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

   class="kw">public int getDebugEntityId() {
      class="kw">return this.debugEntityId;
   }
}