class="kw">package com.hypixel.hytale.server.npc.movement.controllers;

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.shape.Box;
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.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
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.asset.type.fluidfx.config.FluidFX;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockCollisionData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BoxBlockIntersectionEvaluator;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionMath;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionResult;
class="kw">import com.hypixel.hytale.server.core.modules.collision.WorldUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PositionDataComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.Velocity;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
class="kw">import com.hypixel.hytale.server.core.modules.splitvelocity.VelocityConfig;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
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 com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.movement.MotionKind;
class="kw">import com.hypixel.hytale.server.npc.movement.MovementMode;
class="kw">import com.hypixel.hytale.server.npc.movement.Steering;
class="kw">import com.hypixel.hytale.server.npc.movement.constraints.RelaxedConstraint;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.builders.BuilderMotionControllerWalk;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import java.util.EnumSet;
class="kw">import java.util.Set;
class="kw">import java.util.function.IntPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.function.Supplier;
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 MotionControllerWalk class="kw">extends MotionControllerBase {
   class="kw">public class="kw">static class="kw">final String TYPE = "Walk";
   class="kw">public class="kw">static class="kw">final Set<MovementMode> SUPPORTED_MOVEMENT_MODES = Set.of(MovementMode.WALK, MovementMode.WADE, MovementMode.UNDERWATER_WALK);
   class="kw">public class="kw">static class="kw">final double CLIMB_FORWARD_DISTANCE = 0.1;
   class="kw">public class="kw">static class="kw">final double CLIMB_FORWARD_DISTANCE_SQUARED = 0.010000000000000002;
   class="kw">public class="kw">static class="kw">final double JUMP_FORWARD_DISTANCE = 0.5;
   class="kw">public class="kw">static class="kw">final double ONE_PLUS_THRESHOLD = 1.00001;
   class="kw">public class="kw">static class="kw">final double MIN_SAFETY_DISTANCE = 0.05;
   class="kw">public class="kw">static class="kw">final double EDGE_MARGIN_BBOX_FACTOR = 0.1;
   class="kw">public class="kw">static class="kw">final double MIN_SEPARATION_STEERING = 1.0E-5;
   class="kw">protected class="kw">static class="kw">final EnumSet<MotionKind> STATE_CAN_HOVER = EnumSet.of(MotionKind.MOVING, MotionKind.STANDING);
   class="kw">protected class="kw">static class="kw">final EnumSet<MotionKind> VALID_MOTIONS = EnumSet.of(
      MotionKind.ASCENDING, MotionKind.DESCENDING, MotionKind.DROPPING, MotionKind.STANDING, MotionKind.MOVING
   );
   class="kw">protected class="kw">static class="kw">final int COLLISION_MATERIALS = 4;
   class="kw">protected class="kw">static class="kw">final int WALKING_MATERIALS = 5;
   class="kw">protected class="kw">static class="kw">final int WALKING_MATERIALS_RELAXED = 13;
   class="kw">protected class="kw">final double minHorizontalSpeed;
   class="kw">protected class="kw">final double maxVerticalSpeed;
   class="kw">protected class="kw">final double maxVerticalSpeedFluid;
   class="kw">protected class="kw">final double acceleration;
   class="kw">protected class="kw">final double maxRotationSpeed;
   class="kw">protected class="kw">final float maxMoveTurnAngle;
   class="kw">protected class="kw">final float blendRestTurnAngle;
   class="kw">protected class="kw">final double blendRestRelativeSpeed;
   class="kw">protected class="kw">final double maxClimbHeight;
   class="kw">protected class="kw">final double jumpHeight;
   class="kw">protected class="kw">final double minJumpHeight;
   class="kw">protected class="kw">final double minJumpDistance;
   class="kw">protected class="kw">final double jumpForce;
   class="kw">protected class="kw">final double jumpDescentSteepness;
   class="kw">protected class="kw">final double jumpBlending;
   class="kw">protected class="kw">final double jumpDescentBlending;
   class="kw">protected class="kw">final double climbSpeedMult;
   class="kw">protected class="kw">final double climbSpeedPow;
   class="kw">protected class="kw">final double climbSpeedConst;
   class="kw">protected class="kw">final double maxDropHeight;
   class="kw">protected class="kw">final double maxDropHeightRelaxed;
   class="kw">protected class="kw">final double minDescentAnimationHeight;
   class="kw">protected class="kw">final double descendFlatness;
   class="kw">protected class="kw">final double descendSpeedCompensation;
   class="kw">protected class="kw">final double descentSteepness;
   class="kw">protected class="kw">final double descentBlending;
   class="kw">protected class="kw">final MotionControllerWalk.DescentAnimationType descentAnimationType;
   class="kw">protected class="kw">final MotionControllerWalk.AscentAnimationType ascentAnimationType;
   class="kw">protected class="kw">final double maxWalkSpeedAfterHitMultiplier;
   class="kw">protected class="kw">final int fenceBlockSet;
   class="kw">protected class="kw">final double minHover;
   class="kw">protected class="kw">final double maxHover;
   class="kw">protected class="kw">final double hoverFreq;
   class="kw">protected class="kw">final float hoverCycle;
   class="kw">protected class="kw">final double minHoverClimb;
   class="kw">protected class="kw">final double minHoverDrop;
   class="kw">protected class="kw">final boolean floatsDown;
   class="kw">protected boolean onGround;
   class="kw">protected boolean inWater;
   class="kw">protected double horizontalSpeedMultiplier;
   class="kw">protected double fallStartHeight;
   class="kw">protected double fallSpeed;
   class="kw">protected double currentRelativeSpeed;
   class="kw">protected boolean isFullyRotated = true;
   @Nullable
   class="kw">protected BlockType belowBlockType;
   class="kw">protected int belowBlockTypeId = 0;
   class="kw">protected int[] footingBlocks;
   class="kw">protected short[] footingFillers;
   class="kw">protected byte[] footingRotations;
   class="kw">protected class="kw">final Vector3d footingPosition = new Vector3d();
   class="kw">protected boolean footingBlocksValid;
   class="kw">protected double breathingDepth;
   class="kw">protected double constraintDepth;
   class="kw">protected double climbUpDistance;
   class="kw">protected double currentJumpHeight;
   class="kw">protected double jumpDropHeight;
   class="kw">protected double jumpBlockHeight;
   class="kw">protected double predictedFallHeight;
   class="kw">protected class="kw">final Vector3d jumpDropDirection = new Vector3d();
   class="kw">protected class="kw">final Vector3d climbUpDirection = new Vector3d();
   class="kw">protected double currentClimbForwardDistance;
   class="kw">protected double maxClimbForwardDistance;
   class="kw">protected double totalDropDistance;
   class="kw">protected class="kw">final Vector3d climbForwardDirection = new Vector3d();
   class="kw">protected double climbSpeed;
   class="kw">protected boolean jumping;
   class="kw">protected class="kw">final MotionController.VerticalRange verticalRange = new MotionController.VerticalRange();
   class="kw">protected class="kw">final Vector3d tmpClimbPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d tmpClimbMovement = new Vector3d();
   class="kw">protected class="kw">final Vector3d tmpMovePosition = new Vector3d();
   class="kw">protected class="kw">final CollisionResult tmpResults = new CollisionResult();
   class="kw">protected class="kw">final Vector2d tmpClimbHeightResults = new Vector2d();
   @Nullable
   class="kw">private Predicate<CollisionConfig> activeProbeBlockCollisionFilter;
   @Nullable
   class="kw">private IntPredicate activeProbeBreathableBlockOverride;
   class="kw">private class="kw">final EnumSet<RelaxedConstraint> effectiveMoveConstraints = EnumSet.noneOf(RelaxedConstraint.class);

   class="kw">public MotionControllerWalk(@Nonnull BuilderMotionControllerWalk var1, @Nonnull BuilderSupport var2) {
      super(var2, var1);
      this.setGravity(var1.getGravity());
      this.minHorizontalSpeed = var1.getMinHorizontalSpeed();
      this.maxVerticalSpeed = var1.getMaxVerticalSpeed();
      this.maxVerticalSpeedFluid = var1.getMaxVerticalSpeedFluid();
      this.acceleration = var1.getAcceleration(var2);
      this.maxRotationSpeed = var1.getMaxRotationSpeed(var2);
      this.maxMoveTurnAngle = var1.getMaxMoveTurnAngle(var2);
      this.blendRestTurnAngle = var1.getBlendRestTurnAngle(var2);
      this.blendRestRelativeSpeed = var1.getBlendRestRelativeSpeed(var2);
      this.maxClimbHeight = var1.getMaxClimbHeight(var2);
      this.jumpHeight = var1.getJumpHeight(var2);
      this.minJumpHeight = var1.getMinJumpHeight(var2);
      this.minJumpDistance = var1.getMinJumpDistance(var2);
      this.jumpForce = var1.getJumpForce(var2);
      this.jumpDescentSteepness = var1.getJumpDescentSteepness(var2);
      this.jumpBlending = var1.getJumpBlending(var2);
      this.jumpDescentBlending = var1.getJumpDescentBlending(var2);
      this.ascentAnimationType = var1.getAscentAnimationType(var2);
      this.climbSpeedMult = var1.getClimbSpeedMult(var2);
      this.climbSpeedPow = var1.getClimbSpeedPow(var2);
      this.climbSpeedConst = var1.getClimbSpeedConst(var2);
      this.minDescentAnimationHeight = var1.getMinDescentAnimationHeight(var2);
      this.descendFlatness = var1.getDescendForwardAmount(var2);
      this.descendSpeedCompensation = var1.getDescendSpeedCompensation(var2);
      this.maxDropHeight = var1.getMaxDropHeight(var2);
      this.maxDropHeightRelaxed = this.maxDropHeight + var1.getMaxDropHeightRelaxedAdjustment(var2);
      this.fenceBlockSet = var1.getFenceBlockSet();
      this.minHover = var1.getMinHover();
      this.maxHover = var1.getMaxHover();
      this.minHoverClimb = var1.getMinHoverClimb();
      this.minHoverDrop = var1.getMinHoverDrop();
      this.floatsDown = var1.isFloatsDown();
      this.hoverFreq = var1.getHoverFreq();
      this.hoverCycle = this.hoverFreq > 0.0 ? 1.0F / (float)this.hoverFreq : 0.0F;
      this.maxWalkSpeedAfterHitMultiplier = var1.getMaxWalkSpeedAfterHitMultiplier();
      this.descentAnimationType = var1.getDescentAnimationType(var2);
      this.descentSteepness = var1.getDescentSteepness(var2);
      this.descentBlending = var1.getDescentBlending(var2);
   }

   @Nonnull
   @Override
   class="kw">public String getType() {
      class="kw">return "Walk";
   }

   @Nonnull
   @Override
   class="kw">public Set<MovementMode> getSupportedMovementModes() {
      class="kw">return SUPPORTED_MOVEMENT_MODES;
   }

   @Nonnull
   @Override
   class="kw">public Set<MovementMode> getDefaultSpawnMovementModes() {
      assert this.role != null;
      if (this.role.isBreathesInAir()) {
         class="kw">return Set.of(MovementMode.WALK);
      }

      assert this.role.isBreathesInWater();
      class="kw">return Set.of(MovementMode.UNDERWATER_WALK);
   }

   @Override
   class="kw">public void spawned() {
      this.position.y = this.position.y + this.minHover;
   }

   @Override
   class="kw">public double getWanderVerticalMovementRatio() {
      class="kw">return 0.0;
   }

   @Nonnull
   @Override
   class="kw">public MotionController.VerticalRange getDesiredVerticalRange(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      TransformComponent var3 = var2.getComponent(var1, TransformComponent.getComponentType());
      assert var3 != null;
      this.verticalRange.set(var3.getPosition().y(), 0.0, 320.0);
      class="kw">return this.verticalRange;
   }

   @Override
   class="kw">protected void adjustReadPosition(Ref<EntityStore> var1, ComponentAccessor<EntityStore> var2) {
      NPCEntity var3 = var2.getComponent(var1, NPCEntity.getComponentType());
      assert var3 != null;
      this.position.y = this.position.y - var3.getHoverHeight();
   }

   @Override
   class="kw">protected void adjustWritePosition(Ref<EntityStore> var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
      NPCEntity var5 = var4.getComponent(var1, NPCEntity.getComponentType());
      assert var5 != null;
      if (this.maxHover > 0.0 && this.hoverCycle > 0.0F && var2 > 0.0) {
         double var6 = var5.getHoverHeight();
         float var8 = var5.getHoverPhase();
         if (this.switchedToMotionKind(MotionKind.DROPPING) || this.switchedToMotionKind(MotionKind.DESCENDING)) {
            double var14 = this.maxHover - var6;
            double var15 = this.dropDistance(this.position, var14, var4);
            if (var15 < var14) {
               var14 = var15;
            } else {
               var8 = this.hoverCycle / 2.0F;
            }

            var6 += var14;
            this.position.y -= var14;
         } else if (this.switchedToMotionKind(MotionKind.ASCENDING)) {
            double var9 = var6 - this.minHoverClimb;
            if (var9 > this.climbUpDistance) {
               var9 = this.climbUpDistance;
            } else {
               var8 = 0.0F;
            }

            var6 -= var9;
            this.position.y += var9;
            this.climbUpDistance -= var9;
         } else if (var6 < this.minHover) {
            var6 += var2 * this.computeClimbSpeed(this.moveSpeed);
            if (var6 >= this.minHover) {
               var6 = this.minHover;
               var8 = 0.0F;
            }
         } else if (STATE_CAN_HOVER.contains(this.getMotionKind())) {
            var8 = (var8 + (float)var2) % this.hoverCycle;
            double var13 = (float) (Math.PI * 2) / this.hoverCycle;
            double var11 = TrigMathUtil.cos(var13 * var8 - (float) (Math.PI / 2)) * var13;
            var6 += var2 * var11 * (this.maxHover - this.minHover) / 2.0;
            if (var6 <= this.minHover) {
               var6 = this.minHover;
               var8 = 0.0F;
            } else if (var6 >= this.maxHover) {
               var6 = this.maxHover;
               var8 = this.hoverCycle / 2.0F;
            }
         }

         var5.setHoverPhase(var8);
         var5.setHoverHeight(var6);
      }

      this.position.y = this.position.y + var5.getHoverHeight();
   }

   @Override
   class="kw">protected void updateAscendingStates(
      @Nonnull Ref<EntityStore> var1, @Nonnull MovementStates var2, boolean var3, boolean var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      if (!this.jumping) {
         class="kw">switch (this.ascentAnimationType) {
            case Walk:
               var2.jumping = false;
               var2.idle = false;
               var2.flying = false;
               break;
            case Jump:
               var2.jumping = true;
               var2.idle = false;
               var2.flying = false;
               break;
            case Climb:
               var2.jumping = false;
               var2.idle = false;
               var2.flying = false;
               var2.climbing = true;
               break;
            case Fly:
               var2.jumping = false;
               var2.idle = false;
               var2.flying = true;
               break;
            case Idle:
               var2.jumping = false;
               var2.idle = true;
               var2.flying = false;
         }
      } else {
         NPCEntity var6 = var5.getComponent(var1, NPCEntity.getComponentType());
         assert var6 != null;
         var2.jumping = this.jumping;
         var2.idle = false;
         var2.flying = var6.getHoverHeight() > 0.0;
      }

      var2.horizontalIdle = var4;
      var2.falling = false;
      var2.running = var3;
      var2.walking = !var3;
      var2.sprinting = false;
      var2.swimming = false;
   }

   @Override
   class="kw">protected void updateDescendingStates(
      @Nonnull Ref<EntityStore> var1, @Nonnull MovementStates var2, boolean var3, boolean var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      if (this.predictedFallHeight >= this.minDescentAnimationHeight - 1.0E-5) {
         class="kw">switch (this.descentAnimationType) {
            case Walk:
               var2.falling = false;
               var2.idle = false;
               var2.running = var3;
               var2.walking = !var3;
               var2.flying = var4;
               break;
            case Fall:
               var2.falling = true;
               var2.idle = false;
               var2.running = false;
               var2.walking = false;
               var2.flying = false;
               break;
            case Idle:
               var2.falling = false;
               var2.idle = true;
               var2.running = false;
               var2.walking = false;
               var2.flying = var4;
         }
      } else {
         var2.falling = false;
         var2.idle = false;
         var2.running = var3;
         var2.walking = !var3;
         var2.flying = var4;
      }

      var2.horizontalIdle = false;
      var2.swimming = false;
      var2.jumping = false;
      var2.sprinting = false;
   }

   @Override
   class="kw">public boolean isFastMotionKind(double var1) {
      boolean var3 = this.fastMotionKind;
      if (this.jumping && this.getMotionKind() == MotionKind.ASCENDING) {
         class="kw">return var3;
      }

      double var4;
      if (var3) {
         var4 = this.fastMotionThreshold - this.fastMotionThresholdRange;
      } else {
         var4 = this.fastMotionThreshold + this.fastMotionThresholdRange;
      }

      var4 *= this.maxHorizontalSpeed;
      class="kw">return var1 > var4;
   }

   @Override
   class="kw">public boolean isInProgress() {
      MotionKind var1 = this.getMotionKind();
      class="kw">return var1 == MotionKind.ASCENDING || var1 == MotionKind.DESCENDING || var1 == MotionKind.DROPPING;
   }

   class="kw">private boolean isOnSolidGround() {
      class="kw">return this.onGround && this.belowBlockType != null && this.belowBlockType.getMaterial() == BlockMaterial.Solid;
   }

   @Override
   class="kw">public boolean canSteer(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      class="kw">return super.canSteer(var1, var2) && this.isOnSolidGround();
   }

   @Nullable
   @Override
   class="kw">public String canSteerFailReason(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      String var3 = super.canSteerFailReason(var1, var2);
      if (var3 != null) {
         class="kw">return var3;
      } else if (!this.onGround) {
         class="kw">return "OFF_GROUND";
      } else if (this.belowBlockType == null) {
         class="kw">return "NO_BLOCK_BELOW";
      } else {
         class="kw">return this.belowBlockType.getMaterial() != BlockMaterial.Solid ? "NO_SOLID_BLOCK_BELOW" : null;
      }
   }

   @Override
   class="kw">public void updateModelParameters(Ref<EntityStore> var1, Model var2, @Nonnull Box var3, ComponentAccessor<EntityStore> var4) {
      super.updateModelParameters(var1, var2, var3, var4);
      float var5 = var2 != null ? var2.getEyeHeight(var1, var4) : 0.0F;
      this.collisionBoundingBox.max.y = this.collisionBoundingBox.max.y + this.maxHover;
      this.breathingDepth = 1.0E-5 + var5;
      if (this.role.isBreathesInAir() && this.role.isBreathesInWater()) {
         this.constraintDepth = this.breathingDepth;
      } else if (this.role.isBreathesInAir()) {
         this.constraintDepth = Math.min(0.25, this.breathingDepth / 2.0);
      } else {
         this.constraintDepth = 1.0E-5;
      }

      int var6 = (int)(MathUtil.fastCeil(this.collisionBoundingBox.width() + 1.0) * MathUtil.fastCeil(this.collisionBoundingBox.depth() + 1.0));
      this.footingBlocks = new int[var6];
      this.footingFillers = new short[var6];
      this.footingRotations = new byte[var6];
      this.footingBlocksValid = false;
   }

   @Override
   class="kw">public void constrainRotations(Role var1, @Nonnull TransformComponent var2) {
      Rotation3f var3 = var2.getRotation();
      var3.setPitch(0.0F);
      var3.setRoll(0.0F);
   }

   @Override
   class="kw">public void setVelocity(@Nonnull Vector3dc var1, VelocityConfig var2, boolean var3) {
      super.setVelocity(var1, var2, var3);
      this.onGround = false;
   }

   @Override
   class="kw">public boolean inAir() {
      class="kw">return !this.onGround && !this.inWater;
   }

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

   @Override
   class="kw">public boolean standingOnBlockOfType(int var1) {
      class="kw">return BlockSetModule.getInstance().blockInSet(var1, this.belowBlockType);
   }

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

   @Override
   class="kw">public boolean touchesWater(boolean var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      class="kw">return this.inWater;
   }

   @Override
   class="kw">public double getCurrentSpeed() {
      class="kw">return this.moveSpeed;
   }

   @Override
   class="kw">public double getCurrentTurnRadius() {
      class="kw">return 0.0;
   }

   @Override
   class="kw">public float getMaxClimbAngle() {
      class="kw">return 0.0F;
   }

   @Override
   class="kw">public float getMaxSinkAngle() {
      class="kw">return 0.0F;
   }

   @Override
   class="kw">public double getMaxClimbHeight() {
      class="kw">return this.maxClimbHeight;
   }

   @Override
   class="kw">public double getMaxDropHeight() {
      class="kw">return this.maxDropHeight;
   }

   @Override
   class="kw">public double getMaximumSpeed() {
      class="kw">return this.maxHorizontalSpeed * this.horizontalSpeedMultiplier * this.effectHorizontalSpeedMultiplier;
   }

   @Override
   class="kw">public boolean is2D() {
      class="kw">return true;
   }

   @Override
   class="kw">public boolean canRestAtPlace() {
      class="kw">return true;
   }

   @Override
   class="kw">public double getDesiredAltitudeWeight() {
      class="kw">return 0.0;
   }

   @Override
   class="kw">public double getHeightOverGround() {
      class="kw">return 0.0;
   }

   @Override
   class="kw">public boolean estimateVelocity(@Nonnull Steering var1, @Nonnull Vector3d var2) {
      if (var1.hasTranslation()) {
         var2.set(var1.getTranslation()).mul(this.getCurrentSpeed());
         class="kw">return true;
      } else {
         var2.zero();
         class="kw">return false;
      }
   }

   @Override
   class="kw">public void setMotionKind(MotionKind var1) {
      if (!VALID_MOTIONS.contains(var1)) {
         var1 = MotionKind.STANDING;
      }

      super.setMotionKind(var1);
   }

   @Override
   class="kw">public void postReadPosition(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      if (!this.footingPosition.equals(this.position)) {
         this.footingBlocksValid = false;
         this.footingPosition.set(this.position);
      }

      World var3 = var2.getExternalData().getWorld();
      boolean var4 = this.onGround;
      double var5 = this.position.y + this.collisionBoundingBox.min.y;
      int var7 = MathUtil.floor(var5);
      if (var5 - var7 < 1.0E-5) {
         var7--;
      }

      if (var7 >= 0 && var7 <= 319) {
         double var8 = this.position.x > 0.0 ? this.position.x + MathUtil.EPSILON_DOUBLE : this.position.x - MathUtil.EPSILON_DOUBLE;
         double var10 = this.position.z > 0.0 ? this.position.z + MathUtil.EPSILON_DOUBLE : this.position.z - MathUtil.EPSILON_DOUBLE;
         long var12 = MathUtil.fastFloor(var8 + this.collisionBoundingBox.min.x);
         long var14 = MathUtil.fastFloor(var8 + this.collisionBoundingBox.max.x);
         long var16 = MathUtil.fastFloor(var10 + this.collisionBoundingBox.min.z);
         long var18 = MathUtil.fastFloor(var10 + this.collisionBoundingBox.max.z);
         int var20 = ChunkUtil.chunkCoordinate(var12);
         int var21 = ChunkUtil.chunkCoordinate(var14);
         int var22 = ChunkUtil.chunkCoordinate(var16);
         int var23 = ChunkUtil.chunkCoordinate(var18);
         boolean var24 = !this.footingBlocksValid;
         int var25 = 0;
         this.footingBlocksValid = true;
         ChunkStore var26 = var3.getChunkStore();
         Store var27 = var26.getStore();

         label279:
         for (int var28 = var20; var28 <= var21; var28++) {
            for (int var29 = var22; var29 <= var23; var29++) {
               Ref var30 = var26.getChunkReference(ChunkUtil.indexChunk(var28, var29));
               BlockChunk var31 = var30 != null && var30.isValid() ? var27.getComponent(var30, BlockChunk.getComponentType()) : null;
               if (var31 == null) {
                  this.footingBlocksValid = false;
                  this.belowBlockType = null;
                  this.belowBlockTypeId = 0;
                  this.onGround = false;
                  break label279;
               }

               int var32 = var28 == var20 ? ChunkUtil.localCoordinate(var12) : 0;
               int var33 = var28 == var21 ? ChunkUtil.localCoordinate(var14) : 31;
               int var34 = var29 == var22 ? ChunkUtil.localCoordinate(var16) : 0;
               int var35 = var29 == var23 ? ChunkUtil.localCoordinate(var18) : 31;
               BlockSection var36 = var31.getSectionAtBlockY(var7);

               for (int var37 = var32; var37 <= var33; var37++) {
                  for (int var38 = var34; var38 <= var35; var38++) {
                     int var39 = var36.get(var37, var7, var38);
                     if (var24 || var39 != this.footingBlocks[var25]) {
                        this.footingBlocks[var25] = var39;
                        this.footingFillers[var25] = (short)var36.getFiller(var37, var7, var38);
                        this.footingRotations[var25] = (byte)var36.getRotationIndex(var37, var7, var38);
                        var24 = true;
                     }

                     var25++;
                  }
               }
            }
         }

         if (var24 && this.footingBlocksValid) {
            this.belowBlockType = null;
            this.onGround = false;
            this.belowBlockTypeId = 0;
            BoxBlockIntersectionEvaluator var66 = this.collisionResult.getBoxBlockIntersection();
            var66.setBox(this.collisionBoundingBox, this.footingPosition);
            Vector3dc var67 = var66.getWorldUp();
            int var68;
            if (var67.y() != 0.0) {
               var68 = 40;
            } else if (var67.x() != 0.0) {
               var68 = 48;
            } else {
               var68 = 24;
            }

            var25 = 0;

            label241:
            for (int var69 = var20; var69 <= var21; var69++) {
               int var70 = ChunkUtil.minBlock(var69);

               for (int var71 = var22; var71 <= var23; var71++) {
                  int var72 = ChunkUtil.minBlock(var71);
                  int var73 = var69 == var20 ? ChunkUtil.localCoordinate(var12) : 0;
                  int var74 = var69 == var21 ? ChunkUtil.localCoordinate(var14) : 31;
                  int var75 = var71 == var22 ? ChunkUtil.localCoordinate(var16) : 0;
                  int var76 = var71 == var23 ? ChunkUtil.localCoordinate(var18) : 31;

                  for (int var77 = var73; var77 <= var74; var77++) {
                     for (int var40 = var75; var40 <= var76; var40++) {
                        int var41 = this.footingRotations[var25];
                        int var42 = this.footingFillers[var25];
                        int var43 = this.footingBlocks[var25++];
                        if (var43 != 0) {
                           BlockType var44 = BlockType.getAssetMap().getAsset(var43);
                           int var45 = var70 + var77;
                           int var46 = var72 + var40;
                           int var47 = var7;
                           if (var42 != 0) {
                              var45 -= FillerBlockUtil.unpackX(var42);
                              var47 -= FillerBlockUtil.unpackY(var42);
                              var46 -= FillerBlockUtil.unpackZ(var42);
                           }

                           BlockMaterial var48 = var44.getMaterial();
                           if (var48 == BlockMaterial.Solid) {
                              BlockBoundingBoxes var49 = BlockBoundingBoxes.getAssetMap().getAsset(var44.getHitboxTypeIndex());
                              BlockBoundingBoxes.RotatedVariantBoxes var50 = var49.get(var41);
                              int var51 = var66.intersectBoxComputeOnGround(var50.getBoundingBox(), var45, var47, var46);
                              if (!CollisionMath.isDisjoint(var51)) {
                                 if (var50.hasDetailBoxes()) {
                                    for (Box var55 : var50.getDetailBoxes()) {
                                       var51 = var66.intersectBoxComputeOnGround(var55, var45, var47, var46);
                                       if (var66.isOnGround() && (var51 & var68) == var68) {
                                          this.belowBlockType = var44;
                                          this.belowBlockTypeId = var43;
                                          this.onGround = true;
                                          break label241;
                                       }
                                    }
                                 } else if (var66.isOnGround() && (var51 & var68) == var68) {
                                    this.belowBlockType = var44;
                                    this.belowBlockTypeId = var43;
                                    this.onGround = true;
                                    break label241;
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      } else {
         this.footingBlocksValid = false;
         this.belowBlockType = null;
         this.belowBlockTypeId = 0;
         this.onGround = false;
      }

      if (this.shouldDebugMove(this.translation) && var4 != this.onGround) {
         LOGGER.at(Level.INFO).log("eid=%d PostReadPosition: OnGround was changed from %s to %s", this.debugEntityId, var4, this.onGround);
      }

      int var56 = MathUtil.floor(this.position.x);
      int var9 = MathUtil.floor(this.position.y + this.collisionBoundingBox.min.y);
      int var57 = MathUtil.floor(this.position.z);
      TransformComponent var11 = var2.getComponent(var1, TransformComponent.getComponentType());
      assert var11 != null;
      Ref var13 = var11.getSectionRef();
      Fluid var58;
      if (var13 != null && var13.isValid()) {
         Store var59 = var3.getChunkStore().getStore();
         FluidSection var15 = var59.getComponent(var13, FluidSection.getComponentType());
         assert var15 != null;
         var58 = Fluid.getAssetMap().getAsset(var15.getFluidId(var56, var9, var57));
      } else {
         var58 = null;
      }

      this.inWater = var58 != null && !var58.equals(Fluid.EMPTY);
      this.horizontalSpeedMultiplier = 1.0;
      if (this.inWater) {
         int var60 = var58.getFluidFXIndex();
         if (var60 != 0) {
            FluidFX var62 = FluidFX.getAssetMap().getAsset(var60);
            this.horizontalSpeedMultiplier = var62 != null && var62.getMovementSettings() != null ? var62.getMovementSettings().horizontalSpeedMultiplier : 1.0;
         }
      }

      if (var13 != null && var13.isValid()) {
         PositionDataComponent var61 = var2.getComponent(var1, PositionDataComponent.getComponentType());
         assert var61 != null;
         Store var63 = var3.getChunkStore().getStore();
         BlockSection var64 = var63.getComponent(var13, BlockSection.getComponentType());
         assert var64 != null;
         var61.setInsideBlockTypeId(var64.get(var56, var9, var57));
         var61.setStandingOnBlockTypeId(this.belowBlockTypeId);
      }
   }

   @Override
   class="kw">public boolean translateToAccessiblePosition(@Nonnull Vector3d var1, @Nullable Box var2, double var3, double var5, ComponentAccessor<EntityStore> var7) {
      if (var5 < var3) {
         class="kw">return false;
      }

      if (var3 < 0.0) {
         var3 = 0.0;
      }

      if (var5 > 320.0) {
         var5 = 320.0;
      }

      if (var2 == null) {
         class="kw">return translateToAccessiblePosition(var1, var3, var5, var7) > 0;
      }

      int var8 = MathUtil.floor(var2.min.x + var1.x);
      int var9 = MathUtil.floor(var2.max.x + var1.x);
      int var10 = MathUtil.floor(var2.min.z + var1.z);
      int var11 = MathUtil.floor(var2.max.z + var1.z);
      double var12 = var1.y;
      double var14 = var1.y + var2.min.y;
      double var16 = -1.0;
      if (var9 - var8 > 2 || var11 - var10 > 2) {
         var1.y = var14;
         int var18 = translateToAccessiblePosition(var1, var3, var5, var7);
         if (var18 < 0) {
            var1.y = var12;
            class="kw">return false;
         }

         if (var18 > 0 && var1.y > var16) {
            var16 = var1.y;
            var3 = var16;
            if (var16 > var14) {
               var14 = var16;
            }
         }
      }

      for (int var19 = var8; var19 <= var9; var19++) {
         for (int var20 = var10; var20 <= var11; var20++) {
            var1.y = var14;
            int var21 = translateToAccessiblePosition(var1, var3, var5, var7);
            if (var21 < 0) {
               var1.y = var12;
               class="kw">return false;
            }

            if (var21 > 0 && var1.y > var16) {
               var16 = var1.y;
               var3 = var16;
               if (var16 > var14) {
                  var14 = var16;
               }
            }
         }
      }

      if (var16 < 0.0) {
         var1.y = var12;
         class="kw">return false;
      } else {
         var1.y = var16 - var2.min.y;
         class="kw">return true;
      }
   }

   class="kw">public class="kw">static int translateToAccessiblePosition(@Nonnull Vector3d var0, double var1, double var3, @Nonnull ComponentAccessor<EntityStore> var5) {
      if (var0.y() < 0.0) {
         class="kw">return -1;
      }

      World var6 = var5.getExternalData().getWorld();
      long var7 = ChunkUtil.indexChunkFromBlock(var0.x(), var0.z());
      ChunkStore var9 = var6.getChunkStore();
      Ref var10 = var9.getChunkReference(var7);
      if (var10 != null && var10.isValid()) {
         Store var11 = var9.getStore();
         WorldChunk var12 = var11.getComponent(var10, WorldChunk.getComponentType());
         if (var12 == null) {
            class="kw">return -1;
         }

         BlockChunk var13 = var11.getComponent(var10, BlockChunk.getComponentType());
         if (var13 == null) {
            class="kw">return -1;
         }

         BlockTypeAssetMap var14 = BlockType.getAssetMap();
         int var15 = MathUtil.floor(var0.x());
         int var16 = MathUtil.floor(var0.y());
         int var17 = MathUtil.floor(var0.z());
         if (var16 < 320) {
            int var18 = var13.getBlock(var15, var16, var17);
            if (var18 != 0) {
               BlockType var19 = var14.getAsset(var18);
               int var20 = var12.getFiller(var15, var16, var17);
               boolean var21 = var20 != 0;
               if (var21 || var19.getMaterial() == BlockMaterial.Solid) {
                  int var22;
                  for (var22 = MathUtil.ceil(var3); var16 < var22; var16++) {
                     var18 = var13.getBlock(var15, var16, var17);
                     if (var18 == 0) {
                        break;
                     }

                     var19 = var14.getAsset(var18);
                     var20 = var12.getFiller(var15, var16, var17);
                     if (var19.getMaterial() != BlockMaterial.Solid) {
                        break;
                     }
                  }

                  if (var16 == var22) {
                     class="kw">return 0;
                  }

                  var19 = var12.getBlockType(var15, --var16, var17);
                  int var23 = var12.getRotationIndex(var15, var16, var17);
                  BlockBoundingBoxes var26 = BlockBoundingBoxes.getAssetMap().getAsset(var19.getHitboxTypeIndex());
                  BlockBoundingBoxes.RotatedVariantBoxes var27 = var26.get(var23);
                  double var24;
                  if (var20 != 0) {
                     var24 = var16 - FillerBlockUtil.unpackY(var20) + var27.getBoundingBox().max.y;
                  } else {
                     var24 = var16 + var27.getBoundingBox().max.y;
                  }

                  if (var24 > var3) {
                     class="kw">return 0;
                  }

                  var0.y = var24;
                  class="kw">return 1;
               }
            }
         } else {
            var16 = 319;
         }

         int var31 = ChunkUtil.indexSection(var16);

         while (var31 >= 0) {
            BlockSection var34 = var13.getSectionAtIndex(var31);
            if (var34.isSolidAir()) {
               var16 = 32 * var31 - 1;
               if (var16 < var1) {
                  class="kw">return 0;
               }

               var31--;
            } else {
               int var35 = 32 * var31--;

               while (var16 >= var35) {
                  if (var16 < var1) {
                     class="kw">return 0;
                  }

                  int var36 = var34.getRotationIndex(var15, var16, var17);
                  int var37 = var34.getFiller(var15, var16, var17);
                  int var38 = var34.get(var15, var16--, var17);
                  if (var38 != 0) {
                     BlockType var39 = var14.getAsset(var38);
                     if (var37 != 0) {
                        if (var39.getMaterial() == BlockMaterial.Solid) {
                           BlockBoundingBoxes var25 = BlockBoundingBoxes.getAssetMap().getAsset(var39.getHitboxTypeIndex());
                           BlockBoundingBoxes.RotatedVariantBoxes var41 = var25.get(var36);
                           double var43 = var16 + 1 - FillerBlockUtil.unpackY(var37) + var41.getBoundingBox().max.y;
                           if (var43 < var1) {
                              class="kw">return 0;
                           }

                           var0.y = var43;
                           class="kw">return 1;
                        }
                     } else if (var39.getMaterial() == BlockMaterial.Solid) {
                        BlockBoundingBoxes var40 = BlockBoundingBoxes.getAssetMap().getAsset(var39.getHitboxTypeIndex());
                        BlockBoundingBoxes.RotatedVariantBoxes var42 = var40.get(var36);
                        double var44 = var16 + 1 + var42.getBoundingBox().max.y;
                        if (var44 < var1) {
                           class="kw">return 0;
                        }

                        var0.y = var44;
                        class="kw">return 1;
                     }
                  }
               }
            }
         }

         class="kw">return 0;
      } else {
         class="kw">return -1;
      }
   }

   @Override
   class="kw">protected double computeMove(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Role var2,
      @Nonnull Steering var3,
      double var4,
      @Nonnull Vector3d var6,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      NPCEntity var8 = var7.getComponent(var1, NPCEntity.getComponentType());
      assert var8 != null;
      this.saveMotionKind();
      this.isFullyRotated = true;
      Vector3d var9 = var3.getTranslation();
      var9.y = 0.0;
      this.currentRelativeSpeed = var9.length();
      if (!var3.hasPitch()) {
         var3.setPitch(0.0F);
      }

      double var10 = this.inWater() ? this.maxVerticalSpeedFluid : this.maxVerticalSpeed;
      double var12 = this.getMaximumSpeed();
      boolean var14 = !this.isAlive(var1, var7);
      if (var14 && !this.isForcePushed()) {
         this.climbUpDistance = 0.0;
         this.currentClimbForwardDistance = 0.0;
         this.maxClimbForwardDistance = 0.0;
         var3.setYaw(this.getYaw());
         if (this.onGround) {
            var6.zero();
            var3.setPitch(0.0F);
         } else {
            var3.setPitch(this.getPitch());
            Velocity var31 = var7.getComponent(var1, Velocity.getComponentType());
            Vector3d var39 = var31.getVelocity();
            var6.set(var39);
         }

         var6.y = this.computeNewFallSpeed(var4, var6.y);
         var6.mul(var4);
         this.validateTranslation(var6, "Death");
         class="kw">return var4;
      } else if (this.isForcePushed()) {
         this.climbUpDistance = 0.0;
         this.currentClimbForwardDistance = 0.0;
         this.maxClimbForwardDistance = 0.0;
         var6.set(this.externalVelocity);

         for (int var28 = 0; var28 < this.appliedVelocities.size(); var28++) {
            MotionControllerBase.AppliedVelocity var37 = this.appliedVelocities.get(var28);
            if (var37.velocity.y + this.externalVelocity.y <= 0.0 || var37.velocity.y < 0.0) {
               var37.canClear = true;
            }

            if (this.onGround && var37.canClear) {
               var37.velocity.y = 0.0;
            }

            var6.add(var37.velocity);
         }

         var6.mul(var4);
         if (!this.onGround || !(this.externalVelocity.y < 0.0)) {
            this.externalVelocity.y = this.computeNewFallSpeed(var4, this.externalVelocity.y);
         } else if (var6.y < 0.0) {
            var6.y = 0.0;
            this.externalVelocity.y = 0.0;
         }

         if (!this.appliedVelocity.equals(Vector3dUtil.ZERO)) {
            if (this.moveSpeed > 0.0) {
               float var29 = PhysicsMath.headingX(this.getYaw());
               float var38 = PhysicsMath.headingZ(this.getYaw());
               double var40 = this.appliedVelocity.x * this.appliedVelocity.x + this.appliedVelocity.z * this.appliedVelocity.z;
               double var51 = var40 > 0.0 ? (var29 * this.appliedVelocity.x + var38 * this.appliedVelocity.z) / Math.sqrt(var40) : 0.0;
               var51 = Math.min((var51 + 1.0) / 2.0, this.maxWalkSpeedAfterHitMultiplier);
               this.moveSpeed *= var51;
               if (this.moveSpeed > this.minHorizontalSpeed) {
                  var6.add(this.moveSpeed * var4 * var29, 0.0, this.moveSpeed * var4 * var38);
                  this.currentRelativeSpeed = this.moveSpeed;
               } else {
                  this.moveSpeed = 0.0;
               }
            }

            if (this.maxHover > 0.0) {
               var8.setHoverHeight(var6.y <= 0.0 ? this.minHoverDrop : this.maxHover);
            }

            this.appliedVelocity.zero();
         }

         if (this.onGround && this.ignoreDamping) {
            double var30 = this.externalVelocity.length() - var4 * this.inertia * this.acceleration * 5.0;
            if (var30 > 0.0) {
               this.externalVelocity.normalize(var30);
            } else {
               this.externalVelocity.zero();
            }
         }

         var3.setYaw(this.getYaw());
         this.validateTranslation(var6, "ExtForce");
         class="kw">return var4;
      } else {
         if (this.cachedMovementBlocked) {
            class="kw">return var4;
         }

         float var15 = this.getYaw();
         if (this.getMotionKind() == MotionKind.ASCENDING) {
            if (this.isRequiresPreciseMovement() && this.havePreciseMovementTarget) {
               double var33 = this.waypointDistance(this.preciseMovementTarget, this.position) + this.currentClimbForwardDistance;
               if (var33 < this.maxClimbForwardDistance) {
                  this.maxClimbForwardDistance = var33;
               }
            }

            double var34 = var4 * this.climbSpeed;
            if (this.jumping) {
               if (this.climbUpDistance > 0.0) {
                  var34 *= Math.max(Math.pow(this.climbUpDistance * this.climbUpDistance * this.jumpForce, this.jumpBlending), 1.0);
                  this.climbUpDistance = this.computeClimbMove(this.climbUpDirection, this.climbUpDistance, var34, var6);
               } else if (this.jumpDropHeight > 0.0) {
                  double var44 = this.currentJumpHeight - this.jumpDropHeight;
                  var34 *= Math.max(Math.pow(var44 * var44 * this.jumpDescentSteepness, this.jumpDescentBlending), 1.0);
                  this.jumpDropHeight = this.computeClimbMove(this.jumpDropDirection, this.jumpDropHeight, var34, var6);
               } else {
                  this.setMotionKind(MotionKind.DROPPING);
               }

               double var45 = this.currentJumpHeight - this.climbUpDistance - var6.y;
               double var57 = 0.0;
               if (var45 > this.jumpBlockHeight) {
                  double var62;
                  if (this.climbUpDistance > 0.0) {
                     var62 = (var45 - this.jumpBlockHeight) / var45 / 2.0;
                  } else {
                     var62 = 0.5 + (1.0 - this.jumpDropHeight / (this.currentJumpHeight - this.jumpBlockHeight)) / 2.0;
                  }

                  double var24 = this.maxClimbForwardDistance * var62;
                  if (var24 > this.maxClimbForwardDistance) {
                     var24 = this.maxClimbForwardDistance;
                  }

                  var57 = var24 - this.currentClimbForwardDistance;
                  if (var57 < 0.0) {
                     var57 = 0.0;
                  }

                  this.currentClimbForwardDistance = var24;
                  var6.add(this.climbForwardDirection.x * var57, 0.0, this.climbForwardDirection.z * var57);
               }

               if (this.isBlendingHeading) {
                  var15 = this.computeBlendHeading(
                     var15,
                     NPCPhysicsMath.headingFromDirection(this.climbForwardDirection.x, this.climbForwardDirection.z, var15),
                     var4,
                     var57 / var4,
                     var3.getRelativeTurnSpeed()
                  );
               }

               this.lockOrientation(var3, var6, var15);
               this.fallSpeed = 0.0;
               this.onGround = false;
               this.validateTranslation(var6, "AscendingJump");
               class="kw">return var4;
            } else {
               double var43;
               if (this.climbUpDistance > 0.0) {
                  double var55 = this.climbUpDistance;
                  this.climbUpDistance = this.computeClimbMove(this.climbUpDirection, var55, var34, var6);
                  var43 = var55 - this.climbUpDistance;
               } else if (this.currentClimbForwardDistance < this.maxClimbForwardDistance) {
                  double var56 = this.maxClimbForwardDistance - this.currentClimbForwardDistance;
                  if (var34 < var56) {
                     double var22 = var56 - var34;
                     var43 = var22 <= 1.0E-5 ? var56 : var34;
                  } else {
                     var43 = var56;
                  }

                  this.currentClimbForwardDistance += var43;
                  var6.set(this.climbForwardDirection).mul(var43);
                  this.onGround = false;
               } else {
                  this.setMotionKind(MotionKind.DROPPING);
                  var43 = 0.0;
               }

               if (this.isBlendingHeading) {
                  var15 = this.computeBlendHeading(
                     var15,
                     NPCPhysicsMath.headingFromDirection(this.climbForwardDirection.x, this.climbForwardDirection.z, var15),
                     var4,
                     var43 / var4,
                     var3.getRelativeTurnSpeed()
                  );
               }

               this.lockOrientation(var3, var6, var15);
               this.fallSpeed = 0.0;
               this.onGround = false;
               this.validateSpeeds(var1, "Ascending", var7);
               this.validateTranslation(var6, "Ascending");
               class="kw">return var4;
            }
         } else if (this.getMotionKind() == MotionKind.DESCENDING) {
            double var32 = this.currentRelativeSpeed * var12;
            if (this.isRequiresPreciseMovement() && this.havePreciseMovementTarget) {
               double var41 = this.waypointDistance(this.position, this.preciseMovementTarget);
               if (var41 < var32 * var4) {
                  var32 = var41 / var4;
               }
            }

            this.fallSpeed = MathUtil.maxValue(0.0, NPCPhysicsMath.accelerateDragCapped(this.fallSpeed, 5.0 * this.gravity, var4, var10));
            this.moveSpeed = MathUtil.clamp(var32, 0.0, this.moveSpeed + var4 * this.acceleration);
            if (this.moveSpeed > var12) {
               this.moveSpeed = var12;
            }

            if (this.moveSpeed <= 0.3 * this.maxHorizontalSpeed) {
               this.setMotionKind(MotionKind.DROPPING);
            }

            double var42 = this.climbForwardDirection.y;
            if (this.predictedFallHeight > 0.0) {
               this.totalDropDistance = this.totalDropDistance + Math.abs(this.climbForwardDirection.y * this.moveSpeed * var4);
               double var54 = Math.min(this.totalDropDistance / this.predictedFallHeight, 1.0);
               var42 *= Math.pow(this.descentSteepness, this.descentBlending) * Math.pow(var54, this.descentBlending);
            }

            var6.set(this.climbForwardDirection.x, var42, this.climbForwardDirection.z);
            var6.mul(this.moveSpeed * var4);
            var6.y = Math.min(var6.y, -this.fallSpeed * var4);
            Vector3dUtil.clipToZero(var6, this.getEpsilonSpeed());
            if (this.isBlendingHeading) {
               var15 = this.computeBlendHeading(
                  var15,
                  NPCPhysicsMath.headingFromDirection(this.climbForwardDirection.x, this.climbForwardDirection.z, var15),
                  var4,
                  this.moveSpeed,
                  var3.getRelativeTurnSpeed()
               );
            }

            this.lockOrientation(var3, var6, var15);
            this.validateSpeeds(var1, "Descending", var7);
            this.validateTranslation(var6, "Descending");
            class="kw">return var4;
         } else {
            this.validateSpeeds(var1, "Enter Walk/Drop", var7);
            boolean var16 = this.canSteer(var1, var7);
            boolean var18 = false;
            float var17;
            if (var16) {
               var17 = NPCPhysicsMath.headingFromDirection(var9.x, var9.z, var15);
               if (this.isRequiresPreciseMovement() && !this.isBlendingHeading) {
                  float var19 = NPCPhysicsMath.turnAngle(var15, var17);
                  float var20 = this.getEpsilonAngle();
                  if (var19 < -var20 || var19 > var20) {
                     float var21 = (float)MathUtil.clamp(var4 * this.getCurrentMaxBodyRotationSpeed() * var3.getRelativeTurnSpeed(), 0.0, (float) (Math.PI / 2));
                     var19 = MathUtil.clamp(var19, -var21, var21);
                     var15 = PhysicsMath.normalizeTurnAngle(var15 + var19);
                     var6.set(0.0, 0.0, 0.0);
                     var3.setYaw(var15);
                     this.isFullyRotated = false;
                     class="kw">return var4;
                  }

                  var15 = var17;
               }

               this.moveSpeed = MathUtil.clamp(this.currentRelativeSpeed * var12, 0.0, this.moveSpeed + var4 * this.acceleration);
               if (this.fallSpeed > 0.0) {
                  this.fallSpeed = 0.0;
               }

               if (this.moveSpeed < this.getEpsilonSpeed()) {
                  this.moveSpeed = 0.0;
               } else if (this.moveSpeed < this.minHorizontalSpeed) {
                  this.moveSpeed = this.minHorizontalSpeed;
               }

               if (this.isBlendingHeading) {
                  if (this.blendRestTurnAngle > 0.0F) {
                     float var46 = this.computeBlendTurnAngle(var15, var17);
                     if (Math.abs(var46) > this.blendRestTurnAngle) {
                        var18 = true;
                     }

                     var15 = this.computeBlendHeading(var15, var17, var4, this.moveSpeed, var46, var3.getRelativeTurnSpeed());
                  } else {
                     var15 = this.computeBlendHeading(var15, var17, var4, this.moveSpeed, var3.getRelativeTurnSpeed());
                  }

                  var3.setYaw(var15);
                  this.isFullyRotated = true;
               } else if (var3.hasYawOrDirection()) {
                  float var47 = var3.getYawOrDirection();
                  var15 = this.computeHeading(var47, var3.getRelativeTurnSpeed(), var15, var4, false, false);
                  var3.setYaw(var15);
               } else if (this.moveSpeed != 0.0) {
                  var15 = this.computeHeading(var17, var3.getRelativeTurnSpeed(), var15, var4, true, true);
                  var17 = var15;
                  var3.setYaw(var15);
               }

               if (this.debugModeSteer) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d === Compute = t =%.4f v =%.4f h =%.4f mh=%.4f",
                        this.debugEntityId,
                        var4,
                        this.moveSpeed,
                        (180.0F / (float)Math.PI) * var15,
                        (180.0F / (float)Math.PI) * var17
                     );
               }
            } else {
               Velocity var49 = var7.getComponent(var1, Velocity.getComponentType());
               Vector3d var53 = var49.getVelocity();
               var17 = NPCPhysicsMath.headingFromDirection(var53.x, var53.z, var15);
               if (!var3.hasYawOrDirection()) {
                  var3.setYaw(var15);
               }

               if (this.maxHover > 0.0 && this.floatsDown) {
                  this.fallSpeed = this.climbSpeedConst;
                  if (this.fallSpeed != 0.0 && this.climbSpeedMult != 0.0) {
                     double var59 = this.fallSpeed;
                     double var23 = this.climbSpeedMult * Math.pow(var59, this.climbSpeedPow);
                     this.fallSpeed += var23;
                  }
               } else {
                  double var58 = this.fallSpeed;
                  this.fallSpeed = -NPCPhysicsMath.gravityDrag(-var58, 5.0 * this.gravity, var4, var10);
               }
            }

            if (this.moveSpeed > var12) {
               this.moveSpeed = var12;
            }

            if (this.fallSpeed > var10) {
               this.fallSpeed = var10;
            } else if (this.fallSpeed < -var10) {
               this.fallSpeed = -var10;
            }

            double var50 = this.moveSpeed;
            if (var18) {
               double var60 = this.blendRestRelativeSpeed * this.getMaximumSpeed();
               if (var50 > var60) {
                  var50 = var60;
               }
            }

            var6.x = var50 * var4 * PhysicsMath.headingX(var17);
            var6.z = var50 * var4 * PhysicsMath.headingZ(var17);
            var6.y = -this.fallSpeed * var4;
            double var61 = var3.getMaxDistance();
            if (this.canSteer(var1, var7) && var61 < Double.MAX_VALUE && var61 > 0.0) {
               double var63 = NPCPhysicsMath.dotProduct(var6.x, var6.y, var6.z, this.getComponentSelector());
               double var25 = Math.sqrt(var63);
               if (var25 > var61) {
                  var6.mul(var61 / var25);
               }
            }

            this.validateSpeeds(var1, var16 ? "Moving" : "Falling", var7);
            this.validateTranslation(var6, var16 ? "Moving" : "Falling");
            class="kw">return var4;
         }
      }
   }

   class="kw">private double computeNewFallSpeed(double var1, double var3) {
      Box var5 = this.collisionBoundingBox;
      int var6 = this.movementSettings.invertedGravity ? 1 : -1;
      double var7 = var6
         * PhysicsMath.getTerminalVelocity(
            this.movementSettings.mass, 0.001225, Math.abs((var5.max.x - var5.min.x) * (var5.max.z - var5.min.z)), this.movementSettings.dragCoefficient
         );
      double var9 = PhysicsMath.getAcceleration(var3, var7) * var1;
      if (var3 < var7 && var9 > 0.0) {
         var3 = Math.min(var3 + var9, var7);
      } else if (var3 > var7 && var9 < 0.0) {
         var3 = Math.max(var3 + var9, var7);
      }

      class="kw">return var3;
   }

   class="kw">private boolean findMoveCollisions(int var1, boolean var2, @Nonnull Vector3d var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      this.collisionResult.setCollisionByMaterial(4, var1);
      this.resetObstructedFlags();
      if (this.debugModeBlockCollisions) {
         this.collisionResult.setLogger(LOGGER, this.debugEntityId);
      }

      boolean var5 = this.collisionResult.setDamageBlocking(var2);
      boolean var6 = !CollisionModule.findCollisions(this.collisionBoundingBox, this.position, var3, false, this.collisionResult, var4);
      this.collisionResult.setDamageBlocking(var5);
      if (this.debugModeBlockCollisions) {
         this.collisionResult.setLogger(null);
      }

      if (this.debugModeCollisions) {
         this.dumpCollisionResults();
      }

      class="kw">return var6;
   }

   class="kw">private double finishPhysicsCollision(@Nonnull Ref<EntityStore> var1, double var2, double var4, @Nonnull ComponentAccessor<EntityStore> var6) {
      this.processTriggers(var1, this.collisionResult, var4, var6);
      var2 *= var4;
      if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
         LOGGER.at(Level.WARNING)
            .log("eid=%d Move: Physics moved to invalid position pos=%s/%s/%s", this.debugEntityId, this.position.x, this.position.y, this.position.z);
      }

      class="kw">return var2;
   }

   class="kw">private double executePhysicsMove(@Nonnull Ref<EntityStore> var1, double var2, @Nonnull Vector3d var4, @Nonnull ComponentAccessor<EntityStore> var5) {
      this.findMoveCollisions(13, false, var4, var5);
      BlockCollisionData var6 = this.collisionResult.getFirstBlockCollision();
      this.lastValidPosition.set(this.position);
      boolean var7 = this.onGround;
      if (var6 == null) {
         double var16;
         double var19;
         if (this.collisionResult.isSliding) {
            var16 = this.collisionResult.slideStart;
            var19 = this.collisionResult.slideEnd;
         } else {
            var16 = Double.MAX_VALUE;
            var19 = Double.MAX_VALUE;
         }

         this.position.add(var4);
         this.onGround = var16 <= 1.0 && var19 >= 1.0;
         double var20 = 1.0;
         if (this.onGround) {
            this.setMotionKind(MotionKind.STANDING);
         } else {
            this.setMotionKind(MotionKind.DROPPING);
            if (var7) {
               this.fallStartHeight = this.position.y;
               this.fallSpeed = 0.0;
            }
         }

         if (!this.isValidPosition(this.position, this.collisionResult, var5)) {
            double var14 = this.bisect(this.lastValidPosition, this.position, this.position, var5);
            var20 *= var14;
            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d Move: Physics no-collision bisect scale=%s newpos=%s state=%s",
                     this.debugEntityId,
                     var14,
                     Vector3dUtil.formatShortString(this.position),
                     this.getMotionKind()
                  );
            }

            if (var14 == 0.0) {
               this.isObstructed = true;
            }
         } else if (this.shouldDebugMove(var4)) {
            LOGGER.at(Level.INFO)
               .log(
                  "eid=%d Move: Physics no-collision onGround=%s newpos=%s state=%s",
                  this.debugEntityId,
                  this.onGround,
                  Vector3dUtil.formatShortString(this.position),
                  this.getMotionKind()
               );
         }

         this.processTriggers(var1, this.collisionResult, var20, var5);
         if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var5)) {
            LOGGER.at(Level.WARNING)
               .log("eid=%d Move: Physics moved to invalid position pos=%s/%s/%s", this.debugEntityId, this.position.x, this.position.y, this.position.z);
         }

         class="kw">return var2;
      } else {
         double var8 = var6.collisionStart;
         this.position.set(var6.collisionPoint);
         this.tmpMovePosition.set(this.lastValidPosition).add(var4).sub(var6.collisionPoint);
         if (!this.tmpMovePosition.equals(Vector3dUtil.ZERO)) {
            double var10 = this.tmpMovePosition.dot(var6.collisionNormal);
            this.tmpMovePosition.fma(-var10, var6.collisionNormal);
            this.position.add(this.tmpMovePosition);
         }

         if (!this.isValidPosition(this.position, this.collisionResult, var5)) {
            double var17 = this.bisect(this.lastValidPosition, this.position, this.position, var5);
            var8 *= var17;
            if (this.debugModeMove) {
               LOGGER.at(Level.INFO).log("eid=%d Move: Physics collision bisect=%s triggerScale=%s", this.debugEntityId, var17, var8);
            }
         }

         if (!this.isForcePushed()) {
            if (var6.collisionNormal.equals(this.getWorldNormal())) {
               this.setMotionKind(MotionKind.STANDING);
               if (!this.onGround) {
                  this.onGround = true;
                  this.postReadPosition(var1, var5);
               }

               this.fallSpeed = 0.0;
               if (this.debugModeMove) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d Move: Physics ground collision onGround=%s newpos=%s state=%s",
                        this.debugEntityId,
                        this.onGround,
                        Vector3dUtil.formatShortString(this.position),
                        this.getMotionKind()
                     );
               }

               class="kw">return this.finishPhysicsCollision(var1, var2, var8, var5);
            } else if (var6.collisionNormal.equals(this.getWorldAntiNormal())) {
               this.fallSpeed = 0.0;
               this.setMotionKind(MotionKind.DROPPING);
               if (this.debugModeMove) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d Move: Physics ceiling collision newpos=%s state=%s",
                        this.debugEntityId,
                        Vector3dUtil.formatShortString(this.position),
                        this.getMotionKind()
                     );
               }

               class="kw">return this.finishPhysicsCollision(var1, var2, var8, var5);
            } else {
               this.isObstructed = true;
               this.setMotionKind(MotionKind.STANDING);
               if (this.debugModeMove) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d Move: Physics wall collision newpos=%s state=%s",
                        this.debugEntityId,
                        Vector3dUtil.formatShortString(this.position),
                        this.getMotionKind()
                     );
               }

               class="kw">return this.finishPhysicsCollision(var1, var2, var8, var5);
            }
         } else {
            if (this.ignoreDamping) {
               this.ignoreDamping = false;
               this.clearExternalVelocity();
            }

            int var18 = this.collisionResult.getBlockCollisionCount();

            for (int var11 = 0; var11 < var18; var11++) {
               BlockCollisionData var12 = this.collisionResult.getBlockCollision(var11);
               if (var12.collisionNormal.equals(this.getWorldNormal())) {
                  this.onGround = true;
                  this.fallSpeed = 0.0;
                  break;
               }
            }

            this.setMotionKind(MotionKind.DROPPING);
            if (var6.collisionNormal.equals(this.getWorldAntiNormal())) {
               this.fallSpeed = 0.0;
            }

            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d Move: Physics force-push collision normal=%s onGround=%s newpos=%s state=%s",
                     this.debugEntityId,
                     var6.collisionNormal,
                     this.onGround,
                     Vector3dUtil.formatShortString(this.position),
                     this.getMotionKind()
                  );
            }

            class="kw">return this.finishPhysicsCollision(var1, var2, var8, var5);
         }
      }
   }

   @Override
   class="kw">protected double executeMove(
      @Nonnull Ref<EntityStore> var1, @Nonnull Role var2, double var3, @Nonnull Vector3d var5, @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      if (this.shouldDebugMove(var5)) {
         LOGGER.at(Level.INFO)
            .log(
               "eid=%d Move: Execute pos=%s vel=%s onGround=%s blocked=%s solidGround=%s avdDmg=%s relax=%s",
               this.debugEntityId,
               Vector3dUtil.formatShortString(this.position),
               Vector3dUtil.formatShortString(var5),
               this.onGround,
               this.isObstructed,
               this.isOnSolidGround(),
               this.isAvoidingBlockDamage(),
               !this.getRelaxedConstraints().isEmpty()
            );
      }

      if (this.isAlive(var1, var6) && !this.isForcePushed()) {
         this.effectiveMoveConstraints.clear();
         this.effectiveMoveConstraints.addAll(this.relaxedConstraints);
         if (!this.isOnSolidGround()) {
            this.effectiveMoveConstraints.add(RelaxedConstraint.DAMAGE);
            this.effectiveMoveConstraints.add(RelaxedConstraint.WADE);
         }

         if (this.inWater) {
            this.effectiveMoveConstraints.add(RelaxedConstraint.WADE);
         }

         if (!var2.couldBreatheCached(var1, var6)) {
            this.effectiveMoveConstraints.add(RelaxedConstraint.BREATHE);
         }

         boolean var7 = !this.effectiveMoveConstraints.contains(RelaxedConstraint.DAMAGE);
         boolean var8 = this.effectiveMoveConstraints.contains(RelaxedConstraint.WADE);
         double var9 = this.effectiveMaxDropHeight(this.effectiveMoveConstraints);
         boolean var11 = this.findMoveCollisions(var8 ? 13 : 5, var7, var5, var6);
         BlockCollisionData var12 = this.collisionResult.getFirstBlockCollision();
         double var13;
         double var15;
         if (this.collisionResult.isSliding) {
            var13 = this.collisionResult.slideStart;
            var15 = this.collisionResult.slideEnd;
            if (this.onGround) {
               var12 = this.discardIgnorableSlideCollisions(this.collisionResult, var12, this.effectiveMoveConstraints);
            }
         } else {
            var13 = Double.MAX_VALUE;
            var15 = Double.MAX_VALUE;
         }

         boolean var17 = this.isRequiresPreciseMovement() && !this.isFullyRotated;
         this.lastValidPosition.set(this.position);
         boolean var18 = this.onGround;
         if (var12 == null) {
            double var27;
            if (var18 && !(var15 >= 1.0)) {
               if (this.isOnSolidGround() && var17) {
                  this.isObstructed = false;
                  var15 = this.shortenSlide(var5, var15);
               } else {
                  this.onGround = false;
                  this.tmpMovePosition.set(this.position).fma(var15, var5);
                  if (this.isDropBlocked(this.tmpMovePosition, var9, false, this.effectiveMoveConstraints, var6)) {
                     ChunkStore var31 = var6.getExternalData().getWorld().getChunkStore();
                     if (this.isValidWalkPosition(
                        var31, this.lastValidPosition.x, this.lastValidPosition.y, this.lastValidPosition.z, this.effectiveMoveConstraints
                     )) {
                        var15 = this.shortenSlide(var5, var15);
                        this.isObstructed = true;
                        this.onGround = true;
                     }
                  }
               }

               this.position.fma(var15, var5);
               var27 = var15;
               var3 *= var15;
               if (this.onGround && this.validateGroundPosition(var9, this.effectiveMoveConstraints, var6)) {
                  var27 = 0.0;
               }
            } else {
               this.position.add(var5);
               this.onGround = var13 <= 1.0 && var15 >= 1.0;
               var27 = 1.0;
               if (var18 && this.onGround) {
                  ChunkStore var30 = var6.getExternalData().getWorld().getChunkStore();
                  if (!this.isValidWalkPosition(var30, this.position.x, this.position.y, this.position.z, this.effectiveMoveConstraints)
                     && this.isValidWalkPosition(
                        var30, this.lastValidPosition.x, this.lastValidPosition.y, this.lastValidPosition.z, this.effectiveMoveConstraints
                     )) {
                     double var34 = this.bisect(
                        this.lastValidPosition,
                        this.position,
                        this,
                        (var2x, var3x) -> var2x.isValidWalkPosition(var30, var3x.x, var3x.y, var3x.z, this.effectiveMoveConstraints),
                        this.position
                     );
                     var27 *= var34;
                     if (var34 == 0.0) {
                        this.isObstructed = true;
                     }
                  }
               }
            }

            if (this.getMotionKind() != MotionKind.ASCENDING) {
               if (this.onGround) {
                  this.setMotionKind(
                     !this.isObstructed && NPCPhysicsMath.projectedLengthSquared(var5, this.getComponentSelector()) > 0.0
                        ? MotionKind.MOVING
                        : MotionKind.STANDING
                  );
               } else if (this.initiateDescend(var5, var18, "No collision", var6)) {
                  this.position.set(this.lastValidPosition);
                  this.moveSpeed = 0.0;
                  var27 = 0.0;
               }
            }

            if (!this.isValidPosition(this.position, this.collisionResult, var6)) {
               if (this.getMotionKind() == MotionKind.DESCENDING) {
                  this.setMotionKind(MotionKind.DROPPING);
               }

               double var32 = this.bisect(this.lastValidPosition, this.position, this.position, var6);
               var27 *= var32;
               if (this.shouldDebugMove(var5)) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d Move: No collision, bisect onGround was/is=%s/%s slide=%s/%s scale=%s newpos=%s state=%s blocked=%s",
                        this.debugEntityId,
                        var18,
                        this.onGround,
                        var13,
                        var15,
                        var32,
                        Vector3dUtil.formatShortString(this.position),
                        this.getMotionKind(),
                        this.isObstructed
                     );
               }

               if (var32 == 0.0) {
                  this.isObstructed = true;
               }
            } else if (this.shouldDebugMove(var5)) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d Move: No collision onGround was/is=%s/%s slide=%s/%s newpos=%s state=%s",
                     this.debugEntityId,
                     var18,
                     this.onGround,
                     var13,
                     var15,
                     Vector3dUtil.formatShortString(this.position),
                     this.getMotionKind()
                  );
            }

            this.processTriggers(var1, this.collisionResult, var27, var6);
            if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
               LOGGER.at(Level.WARNING)
                  .log(
                     "eid=%d Move: Walked on invalid position pos=%s/%s/%s overlaps=%s",
                     this.debugEntityId,
                     this.position.x,
                     this.position.y,
                     this.position.z,
                     this.collisionResult.getBlockCollisionCount()
                  );
            }

            class="kw">return var3;
         } else {
            if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
               throw new IllegalStateException("Invalid position");
            }

            double var19 = var12.collisionStart;
            this.position.set(var12.collisionPoint);
            if (!this.isValidPosition(this.position, this.collisionResult, var6)) {
               double var21 = this.bisect(this.lastValidPosition, this.position, this.position, var6);
               var19 *= var21;
               if (this.debugModeMove) {
                  LOGGER.at(Level.INFO).log("eid=%d Move: Collision bisect=%s triggerScale=%s", this.debugEntityId, var21, var19);
               }
            }

            if (var12.collisionNormal.equals(this.getWorldNormal())) {
               if (this.onGround && !this.isDropBlocked(this.position, var9, false, this.effectiveMoveConstraints, var6)) {
                  this.initiateDescend(var5, true, "Collision", var6);
                  this.onGround = false;
               } else {
                  if (this.onGround) {
                     this.isObstructed = true;
                     if (var7 && var12.willDamage) {
                        var19 = this.shortenMovement(var19);
                     }
                  } else if (this.getMotionKind() == MotionKind.DROPPING) {
                     double var29 = this.fallStartHeight - this.position.y;
                     if (var29 >= this.maxDropHeight) {
                        this.moveSpeed = 0.0;
                     } else if (var29 > this.maxClimbHeight) {
                        this.moveSpeed = this.moveSpeed * ((var29 - this.maxClimbHeight) / (this.maxDropHeight - this.maxClimbHeight));
                        this.validateSpeeds(var1, "Collision on Ground", var6);
                     }
                  }

                  this.setMotionKind(MotionKind.STANDING);
                  if (this.shouldDebugMove(var5)) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: Collision Up onGround is/was=%s/%s blocked=%s newpos=%s state=%s",
                           this.debugEntityId,
                           this.onGround,
                           var18,
                           this.isObstructed,
                           Vector3dUtil.formatShortString(this.position),
                           this.getMotionKind()
                        );
                  }

                  if (!this.onGround) {
                     this.onGround = true;
                     this.postReadPosition(var1, var6);
                  }
               }

               if (this.onGround && this.validateGroundPosition(var9, this.effectiveMoveConstraints, var6)) {
                  var19 = 0.0;
               }

               this.processTriggers(var1, this.collisionResult, var19, var6);
               var3 *= var19;
               if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
                  LOGGER.at(Level.WARNING)
                     .log(
                        "eid=%d Move: Walked on invalid position pos=%s/%s/%s overlaps=%s",
                        this.debugEntityId,
                        this.position.x,
                        this.position.y,
                        this.position.z,
                        this.collisionResult.getBlockCollisionCount()
                     );
               }

               class="kw">return var3;
            } else if (var12.collisionNormal.equals(this.getWorldAntiNormal())) {
               this.fallSpeed = 0.0;
               this.setMotionKind(MotionKind.DROPPING);
               if (this.debugModeMove) {
                  LOGGER.at(Level.INFO)
                     .log(
                        "eid=%d Move: No ext force, collision down, clear vert speed newpos=%s state=%s",
                        this.debugEntityId,
                        Vector3dUtil.formatShortString(this.position),
                        this.getMotionKind()
                     );
               }

               if (this.onGround && this.validateGroundPosition(var9, this.effectiveMoveConstraints, var6)) {
                  var19 = 0.0;
               }

               this.processTriggers(var1, this.collisionResult, var19, var6);
               var3 *= var19;
               if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
                  LOGGER.at(Level.WARNING)
                     .log(
                        "eid=%d Move: Walked on invalid position pos=%s/%s/%s overlaps=%s",
                        this.debugEntityId,
                        this.position.x,
                        this.position.y,
                        this.position.z,
                        this.collisionResult.getBlockCollisionCount()
                     );
               }

               class="kw">return var3;
            } else {
               boolean var28;
               if (!var11
                  && !var17
                  && this.isOnSolidGround()
                  && var12.blockType != null
                  && this.isClimbable(var12.blockType, var12.fluid, this.effectiveMoveConstraints)) {
                  var28 = this.tryClimb(var5, this.effectiveMoveConstraints, var6);
                  if (this.debugModeMove) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: No ext force, collision horz, try climb h=%s succ=%s newpos(succ|fail)=%s|%s state=%s",
                           this.debugEntityId,
                           this.climbUpDistance,
                           var28,
                           Vector3dUtil.formatShortString(this.tmpMovePosition),
                           Vector3dUtil.formatShortString(this.position),
                           this.getMotionKind()
                        );
                  }
               } else {
                  var28 = false;
                  if (var7 && var12.willDamage) {
                     var19 = this.shortenMovement(var19);
                  }

                  if (this.debugModeMove) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: No ext force, collision horz, don't try climb onGround %s, block %s newpos=%s state=%s",
                           this.debugEntityId,
                           this.onGround,
                           var12.blockType != null,
                           Vector3dUtil.formatShortString(this.position),
                           this.getMotionKind()
                        );
                  }
               }

               this.isObstructed = this.isFullyRotated && !var28 && !var11;
               if (this.onGround && this.validateGroundPosition(var9, this.effectiveMoveConstraints, var6)) {
                  var28 = false;
                  var19 = 0.0;
               }

               this.processTriggers(var1, this.collisionResult, var19, var6);
               var3 *= var19;
               if (var28 && !this.isProcessTriggersHasMoved()) {
                  this.setMotionKind(MotionKind.ASCENDING);
                  this.climbUpDirection.set(this.getWorldNormal());
                  this.climbForwardDirection.set(var5).normalize();
                  this.climbSpeed = this.computeClimbSpeed(this.moveSpeed);
                  this.onGround = false;
                  if (this.debugModeMove) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: No ext force, collision horz, start climbing h=%s forw=%s state=%s",
                           this.debugEntityId,
                           this.climbUpDistance,
                           this.maxClimbForwardDistance,
                           this.getMotionKind()
                        );
                  }

                  if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
                     throw new IllegalStateException("Invalid position");
                  }
               } else if (var2.getLastAvoidanceSteering().lengthSquared() < 1.0E-5 && var2.getLastSeparationSteering().lengthSquared() < 1.0E-5) {
                  this.tmpMovePosition.set(this.lastValidPosition).add(var5).sub(var12.collisionPoint);
                  if (!this.tmpMovePosition.equals(Vector3dUtil.ZERO)) {
                     double var22 = this.tmpMovePosition.dot(var12.collisionNormal);
                     this.tmpMovePosition.fma(-var22, var12.collisionNormal);
                     this.position.add(this.tmpMovePosition);
                  }

                  if (this.debugModeMove) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: No ext force, collision horz, sliding at wall h=%s state=%s",
                           this.debugEntityId,
                           Vector3dUtil.formatShortString(this.tmpMovePosition),
                           this.getMotionKind()
                        );
                  }

                  if (!this.isValidPosition(this.position, this.collisionResult, var6)) {
                     double var33 = this.bisect(this.lastValidPosition, this.position, this.position, var6);
                     if (this.debugModeMove) {
                        LOGGER.at(Level.INFO).log("eid=%d Move: Collision slide bisect=%s dt=%s", this.debugEntityId, var33, var3);
                     }
                  }

                  if (this.lastValidPosition.distanceSquared(this.position) > this.getEpsilonSpeed()) {
                     this.setMotionKind(MotionKind.MOVING);
                  } else {
                     this.setMotionKind(MotionKind.STANDING);
                  }
               } else {
                  if (this.debugModeMove) {
                     LOGGER.at(Level.INFO)
                        .log(
                           "eid=%d Move: No ext force, collision horz, no sliding at wall, avoidance/separation, h=%s state=%s",
                           this.debugEntityId,
                           Vector3dUtil.formatShortString(this.tmpMovePosition),
                           this.getMotionKind()
                        );
                  }

                  this.setMotionKind(MotionKind.STANDING);
               }

               if (this.debugModeValidatePositions && !this.isValidPosition(this.position, this.collisionResult, var6)) {
                  LOGGER.at(Level.WARNING)
                     .log(
                        "eid=%d Move: Walked on invalid position pos=%s/%s/%s overlaps=%s",
                        this.debugEntityId,
                        this.position.x,
                        this.position.y,
                        this.position.z,
                        this.collisionResult.getBlockCollisionCount()
                     );
               }

               class="kw">return var3;
            }
         }
      } else {
         class="kw">return this.executePhysicsMove(var1, var3, var5, var6);
      }
   }

   @Override
   class="kw">public double probeMove(@Nonnull Ref<EntityStore> var1, @Nonnull ProbeMoveData var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      World var4 = var3.getExternalData().getWorld();
      boolean var5 = var2.startProbing();
      Vector3d var6 = var2.probeDirection;
      double var7 = NPCPhysicsMath.projectedLengthSquared(var6, this.getComponentSelector());
      if (var7 == 0.0) {
         class="kw">return 0.0;
      }

      EnumSet var9 = var2.getRelaxedConstraints();
      boolean var10 = !var9.contains(RelaxedConstraint.DAMAGE);
      boolean var11 = var9.contains(RelaxedConstraint.WADE);
      double var12 = this.effectiveMaxDropHeight(var9);
      this.collisionResult.setCollisionByMaterial(4, var11 ? 13 : 5);
      Predicate var14 = this.collisionResult.setBlockCollisionFilter(var2.getBlockCollisionFilter());
      Predicate var15 = this.tmpResults.setBlockCollisionFilter(var2.getBlockCollisionFilter());
      this.activeProbeBlockCollisionFilter = var2.getBlockCollisionFilter();
      this.activeProbeBreathableBlockOverride = var2.getBreathableBlockOverride();

      try {
         Vector3d var16 = var2.probePosition;
         Vector3d var17 = var2.initialPosition;
         Vector3d var18 = var2.targetPosition;
         Vector3d var19 = var2.directionComponentSelector;
         CollisionModule var22 = CollisionModule.get();
         boolean var21;
         if (var17.equals(this.position)) {
            var21 = this.onGround;
         } else {
            this.applyActiveProbeBlockCollisionFilter(this.collisionResult);
            var21 = var22.validatePosition(var4, this.collisionBoundingBox, var16, this.collisionResult) == 1;
         }

         var19.set(this.getComponentSelector());
         var6.mul(var19);
         if (var5) {
            var2.addStartSegment(var17, true);
         }

         if (!var21) {
            if (this.isDropBlocked(var16, var12, true, var9, var3)) {
               if (var5) {
                  var2.addBlockedDropSegment(var16, this.waypointDistance(var17, var16));
                  class="kw">return var2.getLastDistance();
               }

               var2.edgeBlocked = true;
               class="kw">return this.waypointDistance(var17, var16);
            }

            if (var5) {
               var2.addDropSegment(var16, this.waypointDistance(var17, var16));
            }
         }

         while (var7 > 0.0) {
            if (this.debugModeProbeBlockCollisions || var2.debugCollision) {
               this.collisionResult.setLogger(LOGGER, this.debugEntityId);
            }

            boolean var23 = this.collisionResult.setDamageBlocking(var10);
            this.applyActiveProbeBlockCollisionFilter(this.collisionResult);
            boolean var24 = !CollisionModule.findCollisions(this.collisionBoundingBox, var16, var6, this.collisionResult, var3);
            this.collisionResult.setDamageBlocking(var23);
            if (this.debugModeProbeBlockCollisions || var2.debugCollision) {
               this.collisionResult.setLogger(null);
            }

            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d Probe Step: pos=%s mov=%s left=%s",
                     this.debugEntityId,
                     Vector3dUtil.formatShortString(var16),
                     Vector3dUtil.formatShortString(var6),
                     Math.sqrt(var7)
                  );
            }

            if (this.debugModeCollisions) {
               this.dumpCollisionResults();
            }

            BlockCollisionData var20 = this.collisionResult.getFirstBlockCollision();
            double var25 = this.collisionResult.isSliding ? this.collisionResult.slideEnd : Double.MAX_VALUE;
            if (this.collisionResult.isSliding) {
               var20 = this.discardIgnorableSlideCollisions(this.collisionResult, var20, var9);
            }

            if (var20 != null && var20.collisionStart <= var25) {
               if (var10 && var20.willDamage) {
                  this.shortenMovement(var16, var20.collisionPoint, var16);
                  var7 = 0.0;
               } else {
                  var16.set(var20.collisionPoint);
                  var7 = this.updateMovementVector(var16, var6, var18, var19);
               }

               if (var20.collisionNormal.equals(this.getWorldNormal())) {
                  double var40 = this.waypointDistance(var17, var16);
                  if (var5) {
                     var2.addBlockedGroundSegment(var16, var40, var20.collisionNormal, var20.blockId);
                  }

                  class="kw">return var40;
               }

               if (var5) {
                  var2.addHitWallSegment(var16, true, this.waypointDistance(var17, var16), var20.collisionNormal, var20.blockId);
               }

               int var39 = var20.blockId;
               if (var20.blockType == null || var7 < 0.010000000000000002 || !this.isClimbable(var20.blockType, var20.fluid, var9)) {
                  if (var5) {
                     var2.changeSegmentToBlockedWall();
                  }

                  class="kw">return this.waypointDistance(var17, var16);
               }

               double var28 = var24 ? 0.0 : this.computeClimbHeight(var16, var6, this.maxClimbHeight, 0.1, null, this.tmpClimbHeightResults, var9, var3);
               if (var28 <= 0.0) {
                  if (var5) {
                     var2.changeSegmentToBlockedWall();
                  }

                  class="kw">return this.waypointDistance(var17, var16);
               }

               var16.fma(var28, this.getWorldNormal());
               if (var5) {
                  var2.addClimbSegment(var16, this.waypointDistance(var17, var16), var39);
               }

               var7 = this.updateMovementVector(var16, var6, var18, var19);
            } else {
               if (var25 >= 1.0) {
                  var16.add(var6);
                  if (!var11) {
                     ChunkStore var37 = var3.getExternalData().getWorld().getChunkStore();
                     if (!this.isValidWalkPosition(var37, var16.x, var16.y, var16.z, var9) && this.isValidWalkPosition(var37, var17.x, var17.y, var17.z, var9)) {
                        var16.sub(var6);
                        if (var5) {
                           var2.addBlockedGroundSegment(var16, this.waypointDistance(var17, var16), this.getWorldNormal(), -1);
                        }

                        class="kw">return this.waypointDistance(var17, var16);
                     }
                  }

                  var6.set(Vector3dUtil.ZERO);
                  double var38 = this.waypointDistance(var17, var16);
                  if (var5) {
                     var2.addMoveSegment(var16, true, var38);
                  }

                  class="kw">return var38;
               }

               var16.fma(var25, var6);
               if (var5) {
                  var2.addHitEdgeSegment(var16, this.waypointDistance(var17, var16));
               }

               if (this.isDropBlocked(var16, var12, true, var9, var3)) {
                  ChunkStore var27 = var3.getExternalData().getWorld().getChunkStore();
                  if (var11 || this.isValidWalkPosition(var27, var17.x, var17.y, var17.z, var9)) {
                     var6.set(var18).sub(var16).mul(var19);
                     if (var5) {
                        var2.changeSegmentToBlockedEdge();
                        class="kw">return var2.getLastDistance();
                     }

                     var2.edgeBlocked = true;
                     class="kw">return this.waypointDistance(var17, var16);
                  }
               }

               if (var5) {
                  var2.addDropSegment(var16, this.waypointDistance(var17, var16));
               }

               var7 = this.updateMovementVector(var16, var6, var18, var19);
            }
         }

         double var36 = this.waypointDistance(var17, var16);
         if (var5) {
            var2.addEndSegment(var16, true, var36);
         }

         class="kw">return var36;
      } class="kw">finally {
         this.collisionResult.setBlockCollisionFilter(var14);
         this.tmpResults.setBlockCollisionFilter(var15);
         this.activeProbeBlockCollisionFilter = null;
         this.activeProbeBreathableBlockOverride = null;
      }
   }

   @Override
   class="kw">protected void postExecuteMove() {
      if (this.isObstructed && !this.onGround) {
         this.moveSpeed = 0.0;
      }
   }

   @Override
   class="kw">public double getCurrentMaxBodyRotationSpeed() {
      class="kw">return this.maxRotationSpeed * this.effectHorizontalSpeedMultiplier;
   }

   class="kw">protected float computeHeading(float var1, double var2, float var4, double var5, boolean var7, boolean var8) {
      double var9 = NPCPhysicsMath.turnAngle(var4, var1);
      double var11 = this.getEpsilonAngle();
      if (var9 >= -var11 && var9 <= var11) {
         var4 = var1;
         if (var7) {
            this.isFullyRotated = true;
         }
      } else {
         double var13 = var5 * this.getCurrentMaxBodyRotationSpeed() * var2;
         var9 = MathUtil.clamp(var9, -var13, var13);
         var4 = PhysicsMath.normalizeTurnAngle((float)(var4 + var9));
         if (var7) {
            this.isFullyRotated = false;
         }
      }

      if (var8 && Math.abs(var9) > this.maxMoveTurnAngle) {
         this.moveSpeed = 0.0;
      }

      class="kw">return var4;
   }

   class="kw">protected boolean initiateDescend(@Nonnull Vector3d var1, boolean var2, String var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      if (var2 && this.getMotionKind() != MotionKind.DESCENDING && this.getMotionKind() != MotionKind.DROPPING) {
         this.fallStartHeight = this.position.y;
         this.fallSpeed = 0.0;
         this.predictedFallHeight = this.dropDistance(this.position, this.maxDropHeight, var4);
         this.totalDropDistance = 0.0;
         this.computeDescendDirection(var1);
         if (this.debugModeMove) {
            LOGGER.at(Level.INFO).log("eid=%d Move: %s, descend init %s %s", this.debugEntityId, var3, this.moveSpeed, this.climbForwardDirection.toString());
         }
      }

      if (this.getMotionKind() != MotionKind.DROPPING) {
         if (this.fallStartHeight - this.position.y > this.maxClimbHeight || this.predictedFallHeight > this.maxClimbHeight + 1.0E-5) {
            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d Move: %s, dropping %s %s %s %s",
                     this.debugEntityId,
                     var3,
                     this.moveSpeed,
                     this.fallStartHeight - this.position.y,
                     this.predictedFallHeight,
                     this.climbForwardDirection.toString()
                  );
            }

            boolean var5 = this.getMotionKind() == MotionKind.DESCENDING;
            this.setMotionKind(MotionKind.DROPPING);
            class="kw">return var5;
         }

         if (this.getMotionKind() != MotionKind.DESCENDING) {
            if (this.debugModeMove) {
               LOGGER.at(Level.INFO).log("eid=%d Move: %s, descending %s %s", this.debugEntityId, var3, this.moveSpeed, this.climbForwardDirection.toString());
            }

            this.setMotionKind(MotionKind.DESCENDING);
         }
      }

      class="kw">return false;
   }

   class="kw">protected double updateMovementVector(@Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, @Nonnull Vector3d var4) {
      var2.set(var3).sub(var1).mul(var4);
      class="kw">return this.waypointDistanceSquared(var1, var3);
   }

   @Nullable
   class="kw">private BlockCollisionData discardIgnorableSlideCollisions(
      @Nonnull CollisionResult var1, @Nullable BlockCollisionData var2, @Nonnull EnumSet<RelaxedConstraint> var3
   ) {
      boolean var4 = !var3.contains(RelaxedConstraint.DAMAGE);
      double var5 = var1.slideEnd;

      while (var2 != null) {
         if (var4 && var2.willDamage) {
            class="kw">return var2;
         }

         BlockType var7 = var2.blockType;
         if (var7 == null || !var2.collisionNormal.equals(this.getWorldNormal()) || var2.collisionStart > var5) {
            class="kw">return var2;
         }

         var2 = var1.forgetFirstBlockCollision();
      }

      class="kw">return null;
   }

   class="kw">private double bisect(@Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      this.applyActiveProbeBlockCollisionFilter(this.collisionResult);
      if (!this.isValidPosition(var1, this.collisionResult, var4)) {
         var3.set(var2);
         class="kw">return 1.0;
      } else {
         class="kw">return this.bisect(var1, var2, this, (var1x, var2x) -> {
            var1x.applyActiveProbeBlockCollisionFilter(var1x.collisionResult);
            class="kw">return var1x.isValidPosition(var2x, var1x.collisionResult, var4);
         }, var3);
      }
   }

   class="kw">private boolean validateGroundPosition(double var1, @Nonnull EnumSet<RelaxedConstraint> var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      if (this.isDropBlocked(this.position, var1, false, var3, var4)) {
         this.position.set(this.lastValidPosition);
         this.isObstructed = true;
         class="kw">return true;
      } else {
         ChunkStore var5 = var4.getExternalData().getWorld().getChunkStore();
         if (!this.isValidWalkPosition(var5, this.position.x, this.position.y, this.position.z, var3)
            && this.isValidWalkPosition(var5, this.lastValidPosition.x, this.lastValidPosition.y, this.lastValidPosition.z, var3)) {
            this.position.set(this.lastValidPosition);
            this.isObstructed = true;
            class="kw">return true;
         } else {
            class="kw">return false;
         }
      }
   }

   class="kw">private double shortenSlide(@Nonnull Vector3d var1, double var2) {
      Vector3d var4 = this.getComponentSelector();
      double var5 = (this.collisionBoundingBox.max.x - this.collisionBoundingBox.min.x) * 0.1 * var4.x;
      double var7 = (this.collisionBoundingBox.max.y - this.collisionBoundingBox.min.y) * 0.1 * var4.y;
      double var9 = (this.collisionBoundingBox.max.z - this.collisionBoundingBox.min.z) * 0.1 * var4.z;
      double var11 = Math.max(Math.max(var5, Math.max(var7, var9)), 0.05);
      double var13 = var1.length() * var2;
      if (var13 > var11) {
         var2 = var2 * (var13 - var11) / var13;
      } else {
         var2 = 0.0;
      }

      class="kw">return var2;
   }

   class="kw">private double shortenMovement(@Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3) {
      double var4 = var2.distance(var1);
      if (var4 <= 0.05) {
         class="kw">return 0.0;
      }

      var4 = (var4 - 0.05) / var4;
      NPCPhysicsMath.lerp(var1, var2, var4, var3);
      class="kw">return var4;
   }

   class="kw">private double shortenMovement(double var1) {
      double var3 = this.shortenMovement(this.lastValidPosition, this.position, this.position);
      var1 *= var3;
      if (this.debugModeMove) {
         LOGGER.at(Level.INFO).log("eid=%d Move: Collision reduction=%s triggerScale=%s", this.debugEntityId, var3, var1);
      }

      class="kw">return var1;
   }

   class="kw">private void validateTranslation(@Nonnull Vector3d var1, String var2) {
      if (this.debugModeValidateMath) {
         boolean var3 = NPCPhysicsMath.isValid(var1) && var1.lengthSquared() < 1000000.0;
         if (!var3) {
            throw new IllegalStateException(
               String.format(
                  "Walk - Translation invalid path=%s %s, moveSpeed=%s, fallSpeed=%s, pos=%s",
                  var2,
                  var1,
                  this.moveSpeed,
                  this.fallSpeed,
                  Vector3dUtil.formatShortString(this.position)
               )
            );
         }
      } else if (!NPCPhysicsMath.isValid(var1) || var1.lengthSquared() > 1000000.0) {
         var1.zero();
      }
   }

   class="kw">private void validateSpeeds(@Nonnull Ref<EntityStore> var1, @Nonnull String var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      if (this.debugModeValidateMath) {
         if (!Double.isFinite(this.moveSpeed) || !(Math.abs(this.moveSpeed) < 200.0) || !Double.isFinite(this.fallSpeed) || !(Math.abs(this.fallSpeed) < 200.0)
            )
          {
            throw new IllegalStateException(
               String.format(
                  "Walk - Invalid speed path=%s, moveSpeed=%s, fallSpeed=%s, onGround=%s canSteer=%s, pos=%s, motionKind=%s",
                  var2,
                  this.moveSpeed,
                  this.fallSpeed,
                  this.onGround,
                  this.canSteer(var1, var3),
                  Vector3dUtil.formatShortString(this.position),
                  this.getMotionKind()
               )
            );
         }
      } else {
         this.moveSpeed = MathUtil.clamp(this.moveSpeed, -200.0, 200.0);
         this.fallSpeed = MathUtil.clamp(this.fallSpeed, -200.0, 200.0);
      }
   }

   class="kw">private void lockOrientation(@Nonnull Steering var1, @Nonnull Vector3d var2, float var3) {
      var1.setYaw(var3);
      var1.setPitch(this.getPitch());
      var1.setRoll(this.getRoll());
      if (this.debugModeValidateMath && !NPCPhysicsMath.isValid(var2)) {
         throw new IllegalArgumentException("Translation invalid");
      }
   }

   class="kw">private float computeBlendHeading(float var1, float var2, double var3, double var5, double var7) {
      float var9 = this.computeBlendTurnAngle(var1, var2);
      class="kw">return this.computeBlendHeading(var1, var2, var3, var5, var9, var7);
   }

   class="kw">private float computeBlendHeading(float var1, float var2, double var3, double var5, float var7, double var8) {
      double var10 = this.getCurrentMaxBodyRotationSpeed();
      float var12 = (float)MathUtil.clamp(var3 * var10 * var8, 0.0, (float) (Math.PI / 2));
      if (this.haveBlendHeadingPosition && var5 > 0.0) {
         var7 *= (float)this.blendLevelAtTargetPosition;
         double var13 = this.waypointDistance(this.position, this.blendHeadingPosition) / var5;
         if (var13 * var10 * var8 > var7) {
            var7 = NPCPhysicsMath.turnAngle(var1, var2);
         }
      }

      var7 = MathUtil.clamp(var7, -var12, var12);
      class="kw">return PhysicsMath.normalizeTurnAngle(var1 + var7);
   }

   class="kw">private float computeBlendTurnAngle(float var1, float var2) {
      float var3 = Double.isNaN(this.blendHeading) ? var2 : (float)this.blendHeading;
      class="kw">return NPCPhysicsMath.turnAngle(var1, var3);
   }

   class="kw">private double computeClimbMove(@Nonnull Vector3d var1, double var2, double var4, @Nonnull Vector3d var6) {
      if (var4 >= var2) {
         var4 = var2;
         var2 = 0.0;
      } else {
         double var7 = var2 - var4;
         if (var7 <= 1.0E-5) {
            var4 = var2;
            var2 = 0.0;
         } else {
            var2 = var7;
         }
      }

      var6.set(var1).mul(var4);
      class="kw">return var2;
   }

   class="kw">private void computeDescendDirection(@Nonnull Vector3d var1) {
      this.climbForwardDirection.set(this.getWorldAntiNormal());
      if (!(this.descendFlatness <= 0.0)) {
         double var2 = NPCPhysicsMath.dotProduct(var1.x, 0.0, var1.z);
         if (!(var2 <= 1.0E-12)) {
            var2 = Math.sqrt(var2);
            double var4 = this.descendFlatness / var2;
            this.climbForwardDirection.x = var4 * var1.x;
            this.climbForwardDirection.z = var4 * var1.z;
            this.climbForwardDirection.normalize();
            double var6 = Math.sqrt(NPCPhysicsMath.dotProduct(this.climbForwardDirection.x, 0.0, this.climbForwardDirection.z));
            if (var6 > 1.0E-6) {
               double var8 = 1.0 + (1.0 / var6 - 1.0) * this.descendSpeedCompensation;
               this.climbForwardDirection.mul(var8);
            }
         }
      }
   }

   class="kw">private double computeClimbSpeed(double var1) {
      double var3 = this.climbSpeedConst;
      if (var1 != 0.0 && this.climbSpeedMult != 0.0) {
         var3 += this.climbSpeedMult * Math.pow(var1, this.climbSpeedPow);
      }

      class="kw">return var3;
   }

   class="kw">private boolean tryClimb(@Nonnull Vector3d var1, @Nonnull EnumSet<RelaxedConstraint> var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      boolean var4 = this.jumpHeight > 0.0;
      this.currentClimbForwardDistance = 0.0;
      this.maxClimbForwardDistance = 0.1;
      this.climbUpDistance = this.computeClimbHeight(
         this.position, var1, this.maxClimbHeight + this.jumpHeight, this.maxClimbForwardDistance, null, this.tmpClimbHeightResults, var2, var3
      );
      double var5 = this.climbUpDistance + this.jumpHeight;
      double var7 = this.tmpClimbHeightResults.y;
      if (this.climbUpDistance > this.maxClimbHeight + 1.0E-5) {
         this.climbUpDistance = 0.0;
      } else if (var4 && this.climbUpDistance >= this.minJumpHeight && var7 >= var5) {
         this.currentJumpHeight = var5;
         this.jumpDropHeight = this.currentJumpHeight - this.climbUpDistance;
         this.jumpBlockHeight = this.climbUpDistance;
         this.jumpDropDirection.set(this.getWorldAntiNormal());
         double var9 = this.climbUpDistance;
         this.climbUpDistance = this.currentJumpHeight;
         this.tmpClimbMovement.set(var1).normalize(0.4);
         this.tmpMovePosition.set(this.position).add(0.0, var9, 0.0);
         double var11 = this.maxMoveFactor(this.tmpMovePosition, this.tmpClimbMovement, var2, var3);
         this.maxClimbForwardDistance += var11 * 0.4;
         this.tmpMovePosition.fma(var11, this.tmpClimbMovement);
         this.jumping = this.maxClimbForwardDistance >= this.minJumpDistance;
      } else {
         this.jumping = false;
      }

      class="kw">return this.climbUpDistance > 0.0;
   }

   class="kw">private double computeClimbHeight(
      @Nonnull Vector3d var1,
      @Nonnull Vector3d var2,
      double var3,
      double var5,
      @Nullable Vector3d var7,
      @Nonnull Vector2d var8,
      @Nonnull EnumSet<RelaxedConstraint> var9,
      @Nonnull ComponentAccessor<EntityStore> var10
   ) {
      World var11 = var10.getExternalData().getWorld();
      ChunkStore var12 = var11.getChunkStore();
      boolean var13 = var9.contains(RelaxedConstraint.WADE);
      this.tmpResults.setCollisionByMaterial(4, var13 ? 13 : 5);
      var8.zero();
      Vector3dc var14 = this.getWorldNormal();
      this.tmpClimbMovement.set(var14).mul(var3);
      double var15 = this.maxMoveFactor(var1, this.tmpClimbMovement, var9, var10);
      var3 *= var15;
      if (var3 == 0.0) {
         class="kw">return 0.0;
      }

      this.tmpClimbMovement.set(var2).normalize(var5);
      this.tmpClimbPosition.set(var1).add(this.tmpClimbMovement);
      this.tmpClimbMovement.set(var14).mul(var3);
      boolean var17 = this.tmpResults.isComputeOverlaps();
      this.tmpResults.setComputeOverlaps(true);
      this.applyActiveProbeBlockCollisionFilter(this.tmpResults);
      CollisionModule.findCollisions(this.collisionBoundingBox, this.tmpClimbPosition, this.tmpClimbMovement, false, this.tmpResults, var10);
      this.tmpResults.setComputeOverlaps(var17);
      BlockCollisionData var18 = this.tmpResults.getFirstBlockCollision();
      Vector3dc var19 = this.getWorldAntiNormal();
      double var20 = 0.0;
      double var22 = 1.0;

      while (var18 != null) {
         BlockType var24 = var18.blockType;
         if (var24 == null || !this.isClimbable(var24, var18.fluid, var9)) {
            break;
         }

         if (var18.collisionNormal.equals(var19)) {
            if (var18.collisionStart > var20) {
               var22 = var18.collisionStart;
               break;
            }

            if (var18.collisionEnd > var20) {
               var20 = var18.collisionEnd;
               if (var20 > 1.00001) {
                  class="kw">return 0.0;
               }
            }
         }

         var18 = this.tmpResults.forgetFirstBlockCollision();
      }

      if (var20 == 0.0) {
         class="kw">return 0.0;
      }

      this.tmpClimbPosition.fma(var20, this.tmpClimbMovement);
      if (!this.isValidWalkPosition(var12, this.tmpClimbPosition.x, this.tmpClimbPosition.y, this.tmpClimbPosition.z, var9)) {
         class="kw">return 0.0;
      }

      double var27 = var3 * var20;
      var8.set(var27, var3 * var22);
      if (var7 != null) {
         var7.set(this.tmpClimbPosition);
      }

      class="kw">return var27;
   }

   class="kw">private double effectiveMaxDropHeight(@Nonnull EnumSet<RelaxedConstraint> var1) {
      class="kw">return var1.contains(RelaxedConstraint.DROP) ? this.maxDropHeightRelaxed : this.maxDropHeight;
   }

   class="kw">private boolean isDropBlocked(
      @Nonnull Vector3d var1, double var2, boolean var4, @Nonnull EnumSet<RelaxedConstraint> var5, @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      World var7 = var6.getExternalData().getWorld();
      ChunkStore var8 = var7.getChunkStore();
      boolean var9 = !var5.contains(RelaxedConstraint.DAMAGE);
      this.applyActiveProbeBlockCollisionFilter(this.tmpResults);
      if (this.debugModeValidatePositions && !this.isValidPosition(var1, this.tmpResults, var6)) {
         throw new IllegalStateException("Invalid position");
      }

      BlockCollisionData var10 = this.findDropBlockCollision(var1, var2, var6);
      if (var10 == null) {
         class="kw">return true;
      }

      this.tmpClimbPosition.set(var10.collisionPoint);
      if (var9) {
         double var11 = var10.collisionStart;

         do {
            if (var10.willDamage) {
               if (this.debugModeMove) {
                  LOGGER.at(Level.FINE)
                     .log("eid=%d Drop DMG  %.2f/%.2f/%.2f", this.debugEntityId, this.tmpClimbPosition.x, this.tmpClimbPosition.y, this.tmpClimbPosition.z);
               }

               class="kw">return true;
            }

            var10 = this.tmpResults.forgetFirstBlockCollision();
         } while (var10 != null && var10.collisionStart <= var11);
      }

      if (!this.isValidWalkPosition(var8, this.tmpClimbPosition.x, this.tmpClimbPosition.y, this.tmpClimbPosition.z, var5)) {
         if (this.debugModeMove) {
            LOGGER.at(Level.FINE)
               .log("eid=%d Drop INV  %.2f/%.2f/%.2f", this.debugEntityId, this.tmpClimbPosition.x, this.tmpClimbPosition.y, this.tmpClimbPosition.z);
         }

         class="kw">return true;
      } else {
         if (this.debugModeMove) {
            LOGGER.at(Level.FINE)
               .log("eid=%d Drop END  %.2f/%.2f/%.2f", this.debugEntityId, this.tmpClimbPosition.x, this.tmpClimbPosition.y, this.tmpClimbPosition.z);
         }

         if (var4) {
            var1.set(this.tmpClimbPosition);
         }

         class="kw">return false;
      }
   }

   class="kw">private double dropDistance(@Nonnull Vector3d var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
      BlockCollisionData var5 = this.findDropBlockCollision(var1, var2, var4);
      class="kw">return var5 != null ? var5.collisionStart * var2 : var2;
   }

   @Nullable
   class="kw">private BlockCollisionData findDropBlockCollision(@Nonnull Vector3d var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
      this.tmpResults.setCollisionByMaterial(4);
      this.tmpClimbMovement.set(this.getWorldAntiNormal()).mul(var2);
      this.applyActiveProbeBlockCollisionFilter(this.tmpResults);
      CollisionModule.findCollisions(this.collisionBoundingBox, var1, this.tmpClimbMovement, this.tmpResults, var4);
      BlockCollisionData var5 = this.tmpResults.getFirstBlockCollision();
      if (this.debugModeMove) {
         LOGGER.at(Level.FINE)
            .log(
               "eid=%d Test Drop BOX  %.2f/%.2f/%.2f %.2f/%.2f/%.2f",
               this.debugEntityId,
               this.collisionBoundingBox.min.x,
               this.collisionBoundingBox.min.y,
               this.collisionBoundingBox.min.z,
               this.collisionBoundingBox.max.x,
               this.collisionBoundingBox.max.y,
               this.collisionBoundingBox.max.z
            );
         if (var5 == null) {
            LOGGER.at(Level.FINE)
               .log(
                  "eid=%d Test Drop NONE %.2f/%.2f/%.2f %.2f/%.2f/%.2f",
                  this.debugEntityId,
                  var1.x,
                  var1.y,
                  var1.z,
                  this.tmpClimbMovement.x,
                  this.tmpClimbMovement.y,
                  this.tmpClimbMovement.z
               );
         } else {
            LOGGER.at(Level.FINE)
               .log(
                  "eid=%d Test Drop COLL %.2f/%.2f/%.2f %.2f/%.2f/%.2f dist=%s",
                  this.debugEntityId,
                  var1.x,
                  var1.y,
                  var1.z,
                  this.tmpClimbMovement.x,
                  this.tmpClimbMovement.y,
                  this.tmpClimbMovement.z,
                  var5.collisionStart * var2
               );
         }
      }

      class="kw">return var5;
   }

   class="kw">private boolean isClimbable(@Nonnull BlockType var1, @Nonnull Fluid var2, @Nonnull EnumSet<RelaxedConstraint> var3) {
      boolean var4 = var3.contains(RelaxedConstraint.DAMAGE);
      boolean var5 = var3.contains(RelaxedConstraint.FENCE);
      class="kw">return (var4 || var1.getDamageToEntities() <= 0 && var2.getDamageToEntities() <= 0)
         && (var5 || this.fenceBlockSet == Integer.MIN_VALUE || !BlockSetModule.getInstance().blockInSet(this.fenceBlockSet, var1));
   }

   class="kw">private boolean isValidWalkPosition(
      @Nonnull Ref<ChunkStore> var1,
      @Nonnull ComponentAccessor<ChunkStore> var2,
      double var3,
      double var5,
      double var7,
      @Nonnull EnumSet<RelaxedConstraint> var9
   ) {
      boolean var10 = !var9.contains(RelaxedConstraint.BREATHE);
      boolean var11 = var9.contains(RelaxedConstraint.WADE);
      if (var10) {
         if (!this.couldBreatheAtWalkPosition(var1, var2, var3, var5 + this.breathingDepth, var7)) {
            class="kw">return false;
         }

         if (this.breathingDepth == this.constraintDepth) {
            class="kw">return true;
         }
      }

      class="kw">return !var11 ? this.couldBreatheAtWalkPosition(var1, var2, var3, var5 + this.constraintDepth, var7) : true;
   }

   class="kw">private boolean couldBreatheAtWalkPosition(@Nonnull Ref<ChunkStore> var1, @Nonnull ComponentAccessor<ChunkStore> var2, double var3, double var5, double var7) {
      long var9 = WorldUtil.getPackedMaterialAndFluidAtPosition(var1, var2, var3, var5, var7);
      BlockMaterial var11 = this.isProbeBreathableBlockOverride(var1, var2, var3, var5, var7)
         ? BlockMaterial.Empty
         : BlockMaterial.VALUES[MathUtil.unpackLeft(var9)];
      int var12 = MathUtil.unpackRight(var9);
      class="kw">return this.role.couldBreathe(var11, var12);
   }

   class="kw">private boolean isProbeBreathableBlockOverride(
      @Nonnull Ref<ChunkStore> var1, @Nonnull ComponentAccessor<ChunkStore> var2, double var3, double var5, double var7
   ) {
      if (this.activeProbeBreathableBlockOverride == null) {
         class="kw">return false;
      }

      BlockChunk var9 = var2.getComponent(var1, BlockChunk.getComponentType());
      if (var9 == null) {
         class="kw">return false;
      }

      int var10 = var9.getBlock(MathUtil.floor(var3), MathUtil.floor(var5), MathUtil.floor(var7));
      class="kw">return this.activeProbeBreathableBlockOverride.test(var10);
   }

   class="kw">private boolean isValidWalkPosition(@Nonnull ChunkStore var1, double var2, double var4, double var6, @Nonnull EnumSet<RelaxedConstraint> var8) {
      long var9 = ChunkUtil.indexChunkFromBlock(var2, var6);
      Ref var11 = var1.getChunkReference(var9);
      class="kw">return var11 != null && var11.isValid() ? this.isValidWalkPosition(var11, var1.getStore(), var2, var4, var6, var8) : false;
   }

   class="kw">private double maxMoveFactor(
      @Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull EnumSet<RelaxedConstraint> var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      this.applyActiveProbeBlockCollisionFilter(this.tmpResults);
      CollisionModule.findCollisions(this.collisionBoundingBox, var1, var2, this.tmpResults, var4);
      BlockCollisionData var5;
      if (var2.y != 0.0) {
         var5 = this.tmpResults.getFirstBlockCollision();
      } else {
         var5 = this.discardIgnorableSlideCollisions(this.tmpResults, this.tmpResults.getFirstBlockCollision(), var3);
      }

      class="kw">return var5 == null ? 1.0 : MathUtil.clamp(var5.collisionStart, 0.0, 1.0);
   }

   class="kw">private void applyActiveProbeBlockCollisionFilter(@Nonnull CollisionResult var1) {
      if (this.activeProbeBlockCollisionFilter != null) {
         var1.setBlockCollisionFilter(this.activeProbeBlockCollisionFilter);
      }
   }

   class="kw">public enum AscentAnimationType class="kw">implements Supplier<String> {
      Walk("Play walk animation"),
      Jump("Play jump animation"),
      Climb("Play climb animation"),
      Fly("Play fly animation"),
      Idle("Play idle animation");

      class="kw">private class="kw">final String description;

      AscentAnimationType(String nullxx) {
         this.description = nullxx;
      }

      class="kw">public String get() {
         class="kw">return this.description;
      }
   }

   class="kw">public enum DescentAnimationType class="kw">implements Supplier<String> {
      Walk("Play walk animation"),
      Fall("Play fall animation"),
      Idle("Play idle animation");

      class="kw">private class="kw">final String description;

      DescentAnimationType(String nullxx) {
         this.description = nullxx;
      }

      class="kw">public String get() {
         class="kw">return this.description;
      }
   }
}