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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.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.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.protocol.MovementSettings;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.protocol.Rangef;
class="kw">import com.hypixel.hytale.server.core.asset.modifiers.MovementEffects;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.camera.CameraSettings;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementManager;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockCollisionData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CharacterCollisionData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionDataArray;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModuleConfig;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionResult;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.PhysicsValues;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
class="kw">import com.hypixel.hytale.server.core.modules.splitvelocity.SplitVelocity;
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.WorldChunk;
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.npc.NPCPlugin;
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.NavState;
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.BuilderMotionControllerBase;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.RoleDebugFlags;
class="kw">import com.hypixel.hytale.server.npc.role.support.DebugSupport;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import com.hypixel.hytale.server.npc.util.VisHelper;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.EnumSet;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.function.BiPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;

class="kw">public class="kw">abstract class MotionControllerBase class="kw">implements MotionController {
   class="kw">public class="kw">static class="kw">final double FORCE_SCALE = 5.0;
   class="kw">public class="kw">static class="kw">final double BISECT_DIST = 0.05;
   class="kw">public class="kw">static class="kw">final double FILTER_COEFFICIENT = 0.7;
   class="kw">public class="kw">static class="kw">final double DOT_PRODUCT_EPSILON = 0.1;
   class="kw">private class="kw">static class="kw">final double RAIL_GRAZING_EPSILON = 1.0E-6;
   class="kw">private class="kw">static class="kw">final double RAIL_GRAZING_RATIO = 0.05;
   class="kw">public class="kw">static class="kw">final double DEFAULT_BLOCK_DRAG = 0.82;
   class="kw">protected class="kw">static class="kw">final HytaleLogger LOGGER = NPCPlugin.get().getLogger();
   class="kw">public class="kw">static class="kw">final boolean DEBUG_APPLIED_FORCES = false;
   @Nonnull
   class="kw">protected class="kw">final NPCEntity entity;
   class="kw">protected class="kw">final String type;
   class="kw">protected class="kw">final double epsilonSpeed;
   class="kw">protected class="kw">final float epsilonAngle;
   class="kw">protected class="kw">final double externalVelocityDamping;
   class="kw">protected class="kw">final double maxHorizontalSpeed;
   class="kw">protected class="kw">final double fastMotionThreshold;
   class="kw">protected class="kw">final double fastMotionThresholdRange;
   class="kw">protected class="kw">final float maxHeadRotationSpeed;
   class="kw">protected Role role;
   class="kw">protected double inertia;
   class="kw">protected double knockbackScale;
   class="kw">protected double gravity;
   @Nullable
   class="kw">protected float[] headPitchAngleRange;
   class="kw">protected boolean debugModeSteer;
   class="kw">protected boolean debugModeMove;
   class="kw">protected boolean debugModeMoveSkipIdle;
   class="kw">protected boolean debugModeCollisions;
   class="kw">protected boolean debugModeBlockCollisions;
   class="kw">protected boolean debugModeProbeBlockCollisions;
   class="kw">protected boolean debugModeValidatePositions;
   class="kw">protected boolean debugModeOverlaps;
   class="kw">protected boolean debugModeNonOverlaps;
   class="kw">protected boolean debugModeValidateMath;
   class="kw">protected int debugEntityId = -1;
   class="kw">protected class="kw">final Vector3d position = new Vector3d();
   class="kw">protected class="kw">final Box collisionBoundingBox = new Box();
   class="kw">protected class="kw">final CollisionResult collisionResult = new CollisionResult();
   class="kw">protected class="kw">final Vector3d translation = new Vector3d();
   class="kw">protected class="kw">final Vector3d bisectValidPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d bisectInvalidPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d lastValidPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d externalVelocity = new Vector3d();
   class="kw">protected class="kw">final Vector3d appliedVelocity = new Vector3d();
   class="kw">protected boolean ignoreDamping;
   class="kw">protected class="kw">final List<MotionControllerBase.AppliedVelocity> appliedVelocities = new ObjectArrayList();
   class="kw">protected boolean isObstructed;
   class="kw">protected NavState navState;
   class="kw">protected double throttleDuration;
   class="kw">protected double targetDeltaSquared;
   class="kw">protected boolean recomputePath;
   class="kw">private boolean railStepAppliedThisTick;
   class="kw">protected class="kw">final Vector3dc worldNormal = Vector3dUtil.UP;
   class="kw">protected class="kw">final Vector3dc worldAntiNormal = Vector3dUtil.DOWN;
   class="kw">protected class="kw">final Vector3d componentSelector = new Vector3d(1.0, 0.0, 1.0);
   class="kw">protected class="kw">final Vector3d planarComponentSelector = new Vector3d(1.0, 0.0, 1.0);
   class="kw">protected boolean enableTriggers = true;
   class="kw">protected boolean enableBlockDamage = true;
   class="kw">protected boolean isReceivingBlockDamage;
   class="kw">protected boolean requiresPreciseMovement;
   class="kw">protected boolean havePreciseMovementTarget;
   @Nonnull
   class="kw">protected Vector3d preciseMovementTarget = new Vector3d();
   @Nonnull
   class="kw">protected EnumSet<RelaxedConstraint> relaxedConstraints = EnumSet.noneOf(RelaxedConstraint.class);
   class="kw">protected boolean isBlendingHeading;
   class="kw">protected double blendHeading;
   class="kw">protected boolean haveBlendHeadingPosition;
   @Nonnull
   class="kw">protected Vector3d blendHeadingPosition = new Vector3d();
   class="kw">protected double blendLevelAtTargetPosition = 0.5;
   class="kw">protected boolean fastMotionKind;
   class="kw">protected boolean idleMotionKind;
   class="kw">protected boolean horizontalIdleKind;
   class="kw">protected double moveSpeed;
   class="kw">protected double previousSpeed;
   class="kw">protected MotionKind motionKind;
   class="kw">protected MotionKind lastMovementStateUpdatedMotionKind;
   class="kw">protected MotionKind previousMotionKind;
   class="kw">protected double effectHorizontalSpeedMultiplier;
   class="kw">protected boolean cachedMovementBlocked;
   class="kw">private float yaw;
   class="kw">private float pitch;
   class="kw">private float roll;
   class="kw">private class="kw">final Vector3d beforeTriggerExternalVelocity = new Vector3d();
   class="kw">private class="kw">final Vector3d beforeTriggerPosition = new Vector3d();
   class="kw">private boolean processTriggersHasMoved;
   class="kw">protected MovementSettings movementSettings;

   class="kw">public MotionControllerBase(@Nonnull BuilderSupport var1, @Nonnull BuilderMotionControllerBase var2) {
      NPCEntity var3 = var1.getHolder().getComponent(NPCEntity.getComponentType());
      assert var3 != null : "NPC component null in motion controller construction!";
      this.entity = var3;
      this.type = var2.getType();
      this.epsilonSpeed = var2.getEpsilonSpeed();
      this.epsilonAngle = var2.getEpsilonAngle();
      this.externalVelocityDamping = var2.getExternalVelocityDamping();
      this.maxHorizontalSpeed = var2.getMaxHorizontalSpeed(var1);
      this.fastMotionThreshold = var2.getFastHorizontalThreshold(var1);
      this.fastMotionThresholdRange = var2.getFastHorizontalThresholdRange();
      this.maxHeadRotationSpeed = var2.getMaxHeadRotationSpeed(var1);
      this.setInertia(1.0);
      this.setKnockbackScale(1.0);
      this.setGravity(10.0);
   }

   @Override
   class="kw">public Role getRole() {
      class="kw">return this.role;
   }

   @Override
   class="kw">public void setRole(Role var1) {
      this.role = var1;
   }

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

   @Override
   class="kw">public void setInertia(double var1) {
      this.inertia = Math.max(var1, 1.0E-4);
   }

   @Override
   class="kw">public void setKnockbackScale(double var1) {
      this.knockbackScale = Math.max(0.0, var1);
   }

   @Override
   class="kw">public void updateModelParameters(Ref<EntityStore> var1, Model var2, @Nonnull Box var3, ComponentAccessor<EntityStore> var4) {
      Objects.requireNonNull(var3, "updateModelParameters: MotionController needs a bounding box");
      this.collisionBoundingBox.assign(var3);
   }

   @Override
   class="kw">public void setHeadPitchAngleRange(float[] var1) {
      if (var1 == null) {
         this.headPitchAngleRange = null;
      } else {
         assert var1.length == 2;
         this.headPitchAngleRange = (float[])var1.clone();
      }
   }

   class="kw">protected void readEntityPosition(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      TransformComponent var3 = var2.getComponent(var1, TransformComponent.getComponentType());
      assert var3 != null;
      Rotation3f var4 = var3.getRotation();
      this.position.set(var3.getPosition());
      this.yaw = var4.y();
      this.pitch = var4.pitch();
      this.roll = var4.roll();
      this.adjustReadPosition(var1, var2);
      this.postReadPosition(var1, var2);
   }

   class="kw">public void postReadPosition(Ref<EntityStore> var1, ComponentAccessor<EntityStore> var2) {
   }

   class="kw">public void moveEntity(@Nonnull Ref<EntityStore> var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
      TransformComponent var5 = var4.getComponent(var1, TransformComponent.getComponentType());
      assert var5 != null;
      this.adjustWritePosition(var1, var2, var4);
      Rotation3f var6 = var5.getRotation();
      var6.setYaw(this.yaw);
      var6.setPitch(this.pitch);
      var6.setRoll(this.roll);
      this.entity.moveTo(var1, this.position.x, this.position.y, this.position.z, var4);
   }

   class="kw">public float getYaw() {
      class="kw">return this.yaw;
   }

   class="kw">public float getPitch() {
      class="kw">return this.pitch;
   }

   class="kw">public float getRoll() {
      class="kw">return this.roll;
   }

   class="kw">public boolean touchesWater(boolean var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      World var3 = var2.getExternalData().getWorld();
      ChunkStore var4 = var3.getChunkStore();
      long var5 = ChunkUtil.indexChunkFromBlock(this.position.x(), this.position.z());
      Ref var7 = var4.getChunkReference(var5);
      if (var7 != null && var7.isValid()) {
         WorldChunk var8 = var4.getStore().getComponent(var7, WorldChunk.getComponentType());
         assert var8 != null;
         int var9 = MathUtil.floor(this.position.x());
         int var10 = MathUtil.floor(this.position.y() + this.collisionBoundingBox.min.y);
         int var11 = MathUtil.floor(this.position.z());
         int var12 = var8.getFluidId(var9, var10, var11);
         class="kw">return var12 != 0;
      } else {
         class="kw">return var1;
      }
   }

   @Override
   class="kw">public void updateMovementState(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull MovementStates var2,
      @Nonnull Steering var3,
      @Nonnull Vector3d var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      boolean var6 = var2.running;
      var2.climbing = false;
      var2.swimJumping = false;
      var2.inFluid = this.touchesWater(var2.inFluid, var5);
      var2.onGround = this.role.isOnGround();
      double var7 = this.waypointDistance(Vector3dUtil.ZERO, var4);
      var7 = 0.7 * this.previousSpeed + 0.30000000000000004 * var7;
      this.previousSpeed = var7;
      this.fastMotionKind = this.isFastMotionKind(var7);
      this.idleMotionKind = var3.getTranslation().equals(Vector3dUtil.ZERO);
      this.horizontalIdleKind = this.isHorizontalIdle(var7);
      if (this.motionKind != this.lastMovementStateUpdatedMotionKind
         || var6 != this.fastMotionKind
         || var2.idle != this.idleMotionKind
         || var2.horizontalIdle != this.horizontalIdleKind) {
         class="kw">switch (this.motionKind) {
            case FLYING:
               this.updateFlyingStates(var2, this.idleMotionKind, this.fastMotionKind);
               break;
            case SWIMMING:
               this.updateSwimmingStates(var2, this.idleMotionKind, this.fastMotionKind, this.horizontalIdleKind);
               break;
            case SWIMMING_TURNING:
               this.updateSwimmingStates(var2, false, true, false);
               break;
            case ASCENDING:
               this.updateAscendingStates(var1, var2, this.fastMotionKind, this.horizontalIdleKind, var5);
               break;
            case MOVING:
               updateMovingStates(var1, var2, this.fastMotionKind, var5);
               break;
            case DESCENDING: {
               NPCEntity var11 = var5.getComponent(var1, NPCEntity.getComponentType());
               assert var11 != null;
               this.updateDescendingStates(var1, var2, this.fastMotionKind, var11.getHoverHeight() > 0.0, var5);
               break;
            }
            case DROPPING:
               this.updateDroppingStates(var2);
               break;
            case STANDING: {
               NPCEntity var9 = var5.getComponent(var1, NPCEntity.getComponentType());
               assert var9 != null;
               this.updateStandingStates(var2, this.motionKind, var9.getHoverHeight() > 0.0);
            }
         }
      }

      this.lastMovementStateUpdatedMotionKind = this.motionKind;
   }

   class="kw">protected class="kw">abstract boolean isFastMotionKind(double var1);

   class="kw">protected void updateFlyingStates(@Nonnull MovementStates var1, boolean var2, boolean var3) {
      var1.flying = true;
      var1.idle = var2;
      var1.horizontalIdle = false;
      var1.walking = !var3;
      var1.running = var3;
      var1.falling = false;
      var1.swimming = false;
      var1.jumping = false;
   }

   class="kw">protected void updateSwimmingStates(@Nonnull MovementStates var1, boolean var2, boolean var3, boolean var4) {
      var1.flying = false;
      var1.idle = var2;
      var1.horizontalIdle = var4;
      var1.walking = !var3;
      var1.running = var3;
      var1.falling = false;
      var1.swimming = true;
      var1.jumping = false;
   }

   class="kw">protected class="kw">static void updateMovingStates(
      @Nonnull Ref<EntityStore> var0, @Nonnull MovementStates var1, boolean var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      NPCEntity var4 = var3.getComponent(var0, NPCEntity.getComponentType());
      assert var4 != null;
      var1.flying = var4.getHoverHeight() > 0.0;
      var1.idle = false;
      var1.horizontalIdle = false;
      var1.falling = false;
      var1.walking = !var2;
      var1.running = var2;
      var1.swimming = false;
      var1.jumping = false;
   }

   class="kw">protected void updateAscendingStates(
      @Nonnull Ref<EntityStore> var1, @Nonnull MovementStates var2, boolean var3, boolean var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      updateMovingStates(var1, var2, var3, var5);
   }

   class="kw">protected void updateDescendingStates(
      @Nonnull Ref<EntityStore> var1, @Nonnull MovementStates var2, boolean var3, boolean var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      updateMovingStates(var1, var2, var3, var5);
   }

   class="kw">protected void updateDroppingStates(@Nonnull MovementStates var1) {
      var1.falling = true;
   }

   class="kw">protected void updateStandingStates(@Nonnull MovementStates var1, @Nonnull MotionKind var2, boolean var3) {
      var1.flying = var3;
      var1.idle = true;
      var1.horizontalIdle = true;
      var1.walking = false;
      var1.running = false;
      var1.falling = false;
      var1.swimming = false;
      var1.jumping = false;
   }

   @Override
   class="kw">public double steer(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Role var2,
      @Nonnull Steering var3,
      @Nonnull Steering var4,
      double var5,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      if (this.railStepAppliedThisTick) {
         class="kw">return var5;
      } else {
         this.readEntityPosition(var1, var7);
         if (this.debugModeSteer) {
            double var8 = this.position.x;
            double var10 = this.position.z;
            double var12 = this.steer0(var1, var2, var3, var4, var5, var7);
            double var14 = var5 - var12;
            var8 = this.position.x - var8;
            var10 = this.position.z - var10;
            double var16 = Math.sqrt(var8 * var8 + var10 * var10);
            double var18 = var14 > 0.0 ? var16 / var14 : 0.0;
            LOGGER.at(Level.INFO)
               .log(
                  "eid=%d ==  Steer %s  = t =%.4f dt=%.4f h =%.4f l =%.4f v =%.4f obstr=%s motion=%s",
                  this.debugEntityId,
                  this.getType(),
                  var5,
                  var14,
                  (180.0F / (float)Math.PI) * this.yaw,
                  var16,
                  var18,
                  this.isObstructed ? "yes" : "no",
                  var2.getSteeringMotionName()
               );
            class="kw">return var12;
         } else {
            class="kw">return this.steer0(var1, var2, var3, var4, var5, var7);
         }
      }
   }

   class="kw">public double steer0(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Role var2,
      @Nonnull Steering var3,
      @Nonnull Steering var4,
      double var5,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      World var8 = var7.getExternalData().getWorld();
      NPCEntity var9 = var7.getComponent(var1, NPCEntity.getComponentType());
      assert var9 != null;
      this.effectHorizontalSpeedMultiplier = var9.getCurrentHorizontalSpeedMultiplier(var1, var7);
      this.applyRuntimeRelaxedConstraints(!var2.couldBreatheCached(var1, var7));
      this.translation.zero();
      this.cachedMovementBlocked = this.isMovementBlocked(var1, var7);
      this.computeMove(var1, var2, var3, var5, this.translation, var7);
      if (this.shouldDebugMove(this.translation)) {
         LOGGER.at(Level.INFO)
            .log(
               "eid=%d ==  Move  %s  = t =%.4f pos=%s motion=%s obstr=%s",
               this.debugEntityId,
               this.type,
               var5,
               Vector3dUtil.formatShortString(this.position),
               var2.getSteeringMotionName(),
               this.isObstructed ? "yes" : "no"
            );
      }

      if (this.debugModeValidateMath) {
         if (!NPCPhysicsMath.isValid(this.translation)) {
            throw new IllegalArgumentException(String.valueOf(this.translation));
         }

         if (this.translation.lengthSquared() > 1000000.0) {
            throw new IllegalStateException(
               String.format(
                  "NPC with role %s has abnormal high speed! (Distance=%s, MotionController=%s)", var2.getRoleName(), this.translation.length(), this.type
               )
            );
         }
      } else if (this.translation.lengthSquared() > 1000000.0) {
         this.translation.zero();
      }

      this.applyRuntimeRelaxedConstraints(!var2.couldBreatheCached(var1, var7));
      this.executeMove(var1, var2, var5, this.translation, var7);
      if (DebugSupport.get(var1, var7).isDebugFlagSet(RoleDebugFlags.VisTranslation)) {
         VisHelper.renderDebugVectorTo(this.position, this.translation, VisHelper.DEBUG_COLOR_STEERING_PRE, var8);
      }

      this.postExecuteMove();
      this.clearRequirePreciseMovement();
      this.clearBlendHeading();
      boolean var10 = !var2.couldBreatheCached(var1, var7);
      this.relaxedConstraints.clear();
      this.applyRuntimeRelaxedConstraints(var10);
      float var11 = (float)(var5 * this.getCurrentMaxBodyRotationSpeed() * var3.getRelativeTurnSpeed());
      float var12 = (float)(var5 * this.maxHeadRotationSpeed * var4.getRelativeTurnSpeed() * this.effectHorizontalSpeedMultiplier);
      this.calculateYaw(var1, var3, var4, var12, var11, var7);
      this.calculatePitch(var1, var3, var4, var12, var7);
      this.calculateRoll(var3, var4);
      this.moveEntity(var1, var5, var7);
      HeadRotation var13 = var7.getComponent(var1, HeadRotation.getComponentType());
      assert var13 != null;
      Rotation3f var14 = var13.getRotation();
      var14.setYaw(var4.getYaw());
      var14.setPitch(var4.getPitch());
      var14.setRoll(var4.getRoll());
      if (!this.externalVelocity.equals(Vector3dUtil.ZERO) && !this.ignoreDamping) {
         double var15 = 1.0000000000000002E-10;
         if (this.externalVelocity.lengthSquared() >= var15) {
            this.dampExternalVelocity(this.externalVelocity, this.externalVelocityDamping, var5, var7);
         } else {
            this.externalVelocity.zero();
         }
      }

      double var29 = 60.0;
      int var17 = var8.getTps();
      double var18 = var29 / var17;
      boolean var20 = this.shouldDampenAppliedVelocitiesY();
      boolean var21 = this.shouldAlwaysUseGroundResistance() || this.onGround();

      for (int var22 = 0; var22 < this.appliedVelocities.size(); var22++) {
         MotionControllerBase.AppliedVelocity var23 = this.appliedVelocities.get(var22);
         float var24;
         float var25;
         if (var21) {
            var24 = var23.config.getGroundResistance();
            var25 = var23.config.getGroundResistanceMax();
         } else {
            var24 = var23.config.getAirResistance();
            var25 = var23.config.getAirResistanceMax();
         }

         float var26 = var24;
         if (var25 >= 0.0F) {
            var26 = class="kw">switch (var23.config.getStyle()) {
               case Linear -> {
                  float var31 = (float)var23.velocity.length();
                  if (var31 < var23.config.getThreshold()) {
                     float var33 = var31 / var23.config.getThreshold();
                     yield var24 * var33 + var25 * (1.0F - var33);
                  } else {
                     yield var24;
                  }
               }
               case Exp -> {
                  float var27 = (float)var23.velocity.lengthSquared();
                  if (var27 < var23.config.getThreshold() * var23.config.getThreshold()) {
                     float var28 = var27 / (var23.config.getThreshold() * var23.config.getThreshold());
                     yield var24 * var28 + var25 * (1.0F - var28);
                  } else {
                     yield var24;
                  }
               }
            };
         }

         double var32 = Math.pow(var26, var18);
         var23.velocity.x *= var32;
         var23.velocity.z *= var32;
         if (var20) {
            var23.velocity.y *= var32;
         }
      }

      for (int var30 = this.appliedVelocities.size() - 1; var30 >= 0; var30--) {
         if (this.appliedVelocities.get(var30).velocity.lengthSquared() < 0.001) {
            this.appliedVelocities.remove(var30);
         }
      }

      class="kw">return var5;
   }

   class="kw">protected boolean shouldDampenAppliedVelocitiesY() {
      class="kw">return false;
   }

   class="kw">protected boolean shouldAlwaysUseGroundResistance() {
      class="kw">return false;
   }

   class="kw">protected void calculateYaw(
      @Nonnull Ref<EntityStore> var1, @Nonnull Steering var2, @Nonnull Steering var3, float var4, float var5, @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      if (var2.hasYawOrDirection()) {
         this.yaw = var2.getYawOrDirection();
      } else if (NPCPhysicsMath.dotProduct(this.translation.x, 0.0, this.translation.z) > 0.1) {
         this.yaw = PhysicsMath.headingFromDirection(this.translation.x, this.translation.z);
      }

      boolean var7 = var3.hasYaw();
      if (!var7) {
         var3.setYaw(this.yaw);
      }

      HeadRotation var8 = var6.getComponent(var1, HeadRotation.getComponentType());
      assert var8 != null;
      ModelComponent var9 = var6.getComponent(var1, ModelComponent.getComponentType());
      assert var9 != null;
      Rotation3f var10 = var8.getRotation();
      float var11 = var10.yaw();
      float var12 = var3.getYaw();
      float var13 = MathUtil.clamp(NPCPhysicsMath.turnAngle(var11, var12), -var4, var4);
      var3.setYaw(PhysicsMath.normalizeTurnAngle(var11 + var13));
      if (var7) {
         float var14 = MathUtil.wrapAngle(var3.getYaw() - this.yaw);
         CameraSettings var17 = var9.getModel().getCamera();
         float var15;
         float var16;
         if (var17 != null && var17.getYaw() != null && var17.getYaw().getAngleRange() != null) {
            Rangef var18 = var17.getYaw().getAngleRange();
            var15 = var18.min * (float) (Math.PI / 180.0);
            var16 = var18.max * (float) (Math.PI / 180.0);
         } else {
            var15 = (float) (-Math.PI / 4);
            var16 = (float) (Math.PI / 4);
         }

         if (var14 > var16) {
            float var19 = this.yaw;
            if (!var2.hasYaw()) {
               this.yaw = this.blendBodyYaw(var1, var14, var5, var6);
            }

            var3.setYaw(MathUtil.wrapAngle(var19 + var16));
         } else if (var14 < var15) {
            float var20 = this.yaw;
            if (!var2.hasYaw()) {
               this.yaw = this.blendBodyYaw(var1, var14, var5, var6);
            }

            var3.setYaw(MathUtil.wrapAngle(var20 + var15));
         }
      }
   }

   class="kw">protected float blendBodyYaw(@Nonnull Ref<EntityStore> var1, float var2, float var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      TransformComponent var5 = var4.getComponent(var1, TransformComponent.getComponentType());
      assert var5 != null;
      Rotation3f var6 = var5.getRotation();
      float var7 = var6.yaw();
      float var8 = MathUtil.wrapAngle(this.yaw + var2);
      float var9 = MathUtil.clamp(NPCPhysicsMath.turnAngle(var7, var8), -var3, var3);
      class="kw">return MathUtil.wrapAngle(this.yaw + var9);
   }

   class="kw">protected void calculatePitch(
      @Nonnull Ref<EntityStore> var1, @Nonnull Steering var2, @Nonnull Steering var3, float var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      if (var2.hasPitchOrDirection()) {
         this.pitch = var2.getPitchOrDirection();
      } else if (NPCPhysicsMath.dotProduct(this.translation.x, this.translation.y, this.translation.z) > 0.1) {
         this.pitch = PhysicsMath.pitchFromDirection(this.translation.x, this.translation.y, this.translation.z);
      }

      boolean var6 = var3.hasPitch();
      if (!var6) {
         var3.setPitch(this.pitch);
      }

      HeadRotation var7 = var5.getComponent(var1, HeadRotation.getComponentType());
      assert var7 != null;
      Rotation3f var8 = var7.getRotation();
      float var9 = var8.pitch();
      float var10 = var3.getPitch();
      float var11 = MathUtil.clamp(NPCPhysicsMath.turnAngle(var9, var10), -var4, var4);
      var3.setPitch(PhysicsMath.normalizeTurnAngle(var9 + var11));
      if (var6) {
         ModelComponent var12 = var5.getComponent(var1, ModelComponent.getComponentType());
         assert var12 != null;
         float var13 = this.pitch;
         float var14 = MathUtil.wrapAngle(var3.getPitch() - var13);
         CameraSettings var17 = var12.getModel().getCamera();
         float var15;
         float var16;
         if (this.headPitchAngleRange != null) {
            var15 = this.headPitchAngleRange[0];
            var16 = this.headPitchAngleRange[1];
         } else if (var17 != null && var17.getPitch() != null && var17.getPitch().getAngleRange() != null) {
            Rangef var18 = var17.getPitch().getAngleRange();
            var15 = var18.min * (float) (Math.PI / 180.0);
            var16 = var18.max * (float) (Math.PI / 180.0);
         } else {
            var15 = (float) (-Math.PI / 4);
            var16 = (float) (Math.PI / 4);
         }

         if (var14 > var16) {
            var3.setPitch(MathUtil.wrapAngle(var13 + var16));
         } else if (var14 < var15) {
            var3.setPitch(MathUtil.wrapAngle(var13 + var15));
         }
      }
   }

   class="kw">protected void calculateRoll(@Nonnull Steering var1, @Nonnull Steering var2) {
      if (var1.hasRoll()) {
         this.roll = var1.getRoll();
      }

      if (!var2.hasRoll()) {
         var2.setRoll(this.roll);
      }
   }

   class="kw">protected void dampExternalVelocity(@Nonnull Vector3d var1, double var2, double var4, ComponentAccessor<EntityStore> var6) {
      World var7 = var6.getExternalData().getWorld();
      double var8 = 0.0;
      if (this.motionKind != MotionKind.FLYING) {
         if (!this.onGround() && this.motionKind != MotionKind.SWIMMING && this.motionKind != MotionKind.SWIMMING_TURNING) {
            double var10 = Math.sqrt(var1.x * var1.x + var1.z * var1.z);
            var8 = convertToNewRange(
               var10,
               this.movementSettings.airDragMinSpeed,
               this.movementSettings.airDragMaxSpeed,
               this.movementSettings.airDragMin,
               this.movementSettings.airDragMax
            );
         } else {
            var8 = 0.82;
         }
      }

      double var17 = 60.0;
      int var12 = var7.getTps();
      double var13 = 60.0 / var12;
      var8 = Math.pow(var8, var13);
      var1.x *= var8;
      var1.z *= var8;
      float var15 = 0.1F;
      if (Math.abs(var1.x) <= var15) {
         var1.x = 0.0;
      }

      if (Math.abs(var1.y) <= var15) {
         var1.y = 0.0;
      }

      if (Math.abs(var1.z) <= var15) {
         var1.z = 0.0;
      }
   }

   class="kw">private class="kw">static double convertToNewRange(double var0, double var2, double var4, double var6, double var8) {
      if (var6 != var8 && var2 != var4) {
         double var10 = (var0 - var2) * (var8 - var6) / (var4 - var2) + var6;
         class="kw">return MathUtil.clamp(var10, Math.min(var6, var8), Math.max(var6, var8));
      } else {
         class="kw">return var6;
      }
   }

   @Override
   class="kw">public double probeMove(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Vector3dc var2,
      @Nonnull Vector3dc var3,
      @Nonnull ProbeMoveData var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      var4.setPosition(var2).setDirection(var3);
      class="kw">return this.probeMove(var1, var4, var5);
   }

   @Override
   class="kw">public void applyRailStep(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Role var2,
      @Nonnull Vector3dc var3,
      @Nonnull RailStepConfig var4,
      @Nonnull RailStepResult var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      this.readEntityPosition(var1, var6);
      var5.reset();
      this.translation.set(var3);
      if (this.translation.lengthSquared() == 0.0) {
         var5.appliedFraction = 0.0;
      } else {
         this.setMotionKind(MotionKind.MOVING);
         this.railStepAppliedThisTick = true;
         Predicate var7 = this.collisionResult.setBlockCollisionFilter(var4.ignoredBlockFilter);
         boolean var8 = this.collisionResult.isCheckingForCharacterCollisions();
         boolean var9 = this.collisionResult.isRecordingPassThrough();
         List var10 = this.collisionResult.getCollisionEntities();
         if (var4.candidateEntities != null) {
            this.collisionResult.setCollisionEntities(var4.candidateEntities);
            this.collisionResult.enableCharacterCollsions();
         } else {
            this.collisionResult.disableCharacterCollisions();
         }

         this.collisionResult.setRecordPassThrough(var4.ignoredBlockFilter != null);

         try {
            CollisionModule.findCollisions(this.collisionBoundingBox, this.position, this.translation, false, this.collisionResult, var6);
            boolean var11 = this.collisionResult.isSliding;
            double var12 = this.collisionResult.slideEnd;
            Vector3dc var14 = this.getWorldNormal();
            double var15 = 1.0;
            int var17 = this.collisionResult.getBlockCollisionCount();
            double var18 = Math.max(1.0E-6, 0.05 * this.translation.length());

            for (int var20 = 0; var20 < var17; var20++) {
               BlockCollisionData var21 = this.collisionResult.getBlockCollision(var20);
               boolean var22 = var11 && var21.collisionStart <= var12 && var21.collisionNormal.equals(var14);
               if (!var22) {
                  double var23 = this.translation.dot(var21.collisionNormal);
                  if (!(var23 >= -var18)) {
                     double var25 = Math.max(0.0, var21.collisionStart);
                     if (var25 < 0.999999) {
                        var15 = var25;
                        this.isObstructed = true;
                        var5.obstructed = true;
                     }
                     break;
                  }
               }
            }

            if (var4.stopOnEntityHit && this.collisionResult.getCharacterCollisionCount() > 0) {
               CharacterCollisionData var30 = this.collisionResult.getFirstCharacterCollision();
               if (var30 != null) {
                  double var32 = var30.collisionStart;
                  if (var32 < var15) {
                     var15 = Math.max(0.0, var32);
                     var5.hitEntity = true;
                  }
               }
            }

            int var31 = this.collisionResult.getPassThroughCount();

            for (int var33 = 0; var33 < var31; var33++) {
               BlockCollisionData var35 = this.collisionResult.getPassThrough(var33);
               if (var35.collisionStart > var15) {
                  break;
               }

               var5.nextPassThrough().assign(var35.x, var35.y, var35.z, var35.blockId, var35.collisionPoint, var35.collisionNormal, var35.collisionStart);
            }

            int var34 = this.collisionResult.getCharacterCollisionCount();

            for (int var36 = 0; var36 < var34; var36++) {
               CharacterCollisionData var37 = this.collisionResult.getCharacterCollision(var36);
               if (var37.collisionStart > var15) {
                  break;
               }

               var5.nextEntityHit().assign(var37.entityReference, var37.isPlayer, var37.sourcePosition, var37.targetPosition, var37.collisionStart);
            }

            var5.appliedFraction = var15;
            this.position.fma(var15, this.translation);
            if (var4.ignoredBlockFilter != null && !var4.ignoredBlocksFireTriggers) {
               pruneFilteredTriggerBlocks(this.collisionResult);
            }

            this.processTriggers(var1, this.collisionResult, var15, var6);
            this.moveEntity(var1, 0.0, var6);
         } class="kw">finally {
            this.collisionResult.setBlockCollisionFilter(var7);
            if (var8) {
               this.collisionResult.enableCharacterCollsions();
            } else {
               this.collisionResult.disableCharacterCollisions();
            }

            this.collisionResult.setRecordPassThrough(var9);
            this.collisionResult.setCollisionEntities(var10);
         }
      }
   }

   class="kw">protected void postExecuteMove() {
   }

   class="kw">protected void adjustReadPosition(Ref<EntityStore> var1, ComponentAccessor<EntityStore> var2) {
   }

   class="kw">protected void adjustWritePosition(Ref<EntityStore> var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
   }

   @Override
   class="kw">public boolean isInProgress() {
      class="kw">return false;
   }

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

   @Override
   class="kw">public NavState getNavState() {
      class="kw">return this.navState;
   }

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

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

   @Override
   class="kw">public void setNavState(NavState var1, double var2, double var4) {
      this.navState = var1;
      this.throttleDuration = var2;
      this.targetDeltaSquared = var4;
   }

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

   @Override
   class="kw">public void setForceRecomputePath(boolean var1) {
      this.recomputePath = var1;
   }

   @Override
   class="kw">public void beforeInstructionSensorsAndActions(double var1) {
      this.recomputePath = false;
      this.railStepAppliedThisTick = false;
   }

   @Override
   class="kw">public void beforeInstructionMotion(double var1) {
      this.resetNavState();
   }

   class="kw">public boolean isHorizontalIdle(double var1) {
      class="kw">return var1 == 0.0;
   }

   @Override
   class="kw">public boolean isForcePushed() {
      class="kw">return !this.externalVelocity.equals(Vector3dUtil.ZERO) || !this.appliedVelocities.isEmpty();
   }

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

   @Nullable
   @Override
   class="kw">public String canSteerFailReason(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      if (!this.isAlive(var1, var2)) {
         class="kw">return "DEAD";
      } else {
         class="kw">return this.isForcePushed() ? "EXT_FORCE" : null;
      }
   }

   class="kw">public boolean isMovementBlocked(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      InteractionManager var3 = var2.getComponent(var1, InteractionModule.get().getInteractionManagerComponent());
      if (var3 != null) {
         Boolean var4 = var3.forEachInteraction((var0, var1x, var2x) -> {
            if (var2x) {
               class="kw">return Boolean.TRUE;
            }

            MovementEffects var3 = var1x.getEffects().getMovementEffects();
            class="kw">return var3 != null ? var3.isDisableAll() : Boolean.FALSE;
         }, Boolean.FALSE);
         class="kw">return var4;
      } else {
         class="kw">return false;
      }
   }

   class="kw">protected class="kw">abstract double computeMove(
      @Nonnull Ref<EntityStore> var1, @Nonnull Role var2, Steering var3, double var4, Vector3d var6, @Nonnull ComponentAccessor<EntityStore> var7
   );

   class="kw">protected class="kw">abstract double executeMove(
      @Nonnull Ref<EntityStore> var1, @Nonnull Role var2, double var3, Vector3d var5, @Nonnull ComponentAccessor<EntityStore> var6
   );

   class="kw">public <T> double bisect(@Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull T var3, @Nonnull BiPredicate<T, Vector3d> var4, @Nonnull Vector3d var5) {
      class="kw">return this.bisect(var1, var2, var3, var4, 0.05, var5);
   }

   class="kw">public <T> double bisect(
      @Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull T var3, @Nonnull BiPredicate<T, Vector3d> var4, double var5, @Nonnull Vector3d var7
   ) {
      double var8 = 0.0;
      double var10 = 1.0;
      this.bisectValidPosition.set(var1);
      this.bisectInvalidPosition.set(var2);
      var5 *= var5;
      double var14 = 0.1;
      double var16 = 0.9;

      while (this.bisectValidPosition.distanceSquared(this.bisectInvalidPosition) > var5) {
         double var12 = var14 * var8 + var16 * var10;
         var7.x = var14 * this.bisectValidPosition.x + var16 * this.bisectInvalidPosition.x;
         var7.y = var14 * this.bisectValidPosition.y + var16 * this.bisectInvalidPosition.y;
         var7.z = var14 * this.bisectValidPosition.z + var16 * this.bisectInvalidPosition.z;
         if (var4.test(var3, var7)) {
            var8 = var12;
            this.bisectValidPosition.set(var7);
            if (this.shouldDebugMove(this.translation)) {
               LOGGER.at(Level.INFO)
                  .log("eid=%d   Bisect valid: d=[%f %f] w=[%f %f] pos=%s", this.debugEntityId, var8, var10, var14, var16, Vector3dUtil.formatShortString(var7));
            }
         } else {
            var10 = var12;
            this.bisectInvalidPosition.set(var7);
            var14 = 0.5;
            var16 = 0.5;
            if (this.shouldDebugMove(this.translation)) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d   Bisect invalid: d=[%f %f] w=[%f %f] pos=%s", this.debugEntityId, var8, var10, var14, var16, Vector3dUtil.formatShortString(var7)
                  );
            }
         }
      }

      var7.set(this.bisectValidPosition);
      class="kw">return var8;
   }

   @Nonnull
   @Override
   class="kw">public Vector3d getExternalVelocity() {
      class="kw">return this.externalVelocity;
   }

   @Override
   class="kw">public double getCombinedExternalVelocityLength() {
      double var1 = this.externalVelocity.x;
      double var3 = this.externalVelocity.y;
      double var5 = this.externalVelocity.z;

      for (int var7 = 0; var7 < this.appliedVelocities.size(); var7++) {
         Vector3d var8 = this.appliedVelocities.get(var7).velocity;
         var1 += var8.x;
         var3 += var8.y;
         var5 += var8.z;
      }

      class="kw">return Math.sqrt(var1 * var1 + var3 * var3 + var5 * var5);
   }

   @Override
   class="kw">public void clearExternalForces() {
      this.externalVelocity.zero();
      this.appliedVelocity.zero();
      this.appliedVelocities.clear();
      this.ignoreDamping = false;
   }

   @Override
   class="kw">public void addVelocity(@Nonnull Vector3d var1, VelocityConfig var2) {
      double var3 = this.knockbackScale;
      if (!SplitVelocity.SHOULD_MODIFY_VELOCITY && var2 != null) {
         this.appliedVelocities.add(new MotionControllerBase.AppliedVelocity(new Vector3d(var1.x * var3, var1.y * var3, var1.z * var3), var2));
      } else {
         double var5 = 0.18000000000000005 * this.movementSettings.velocityResistance;
         this.externalVelocity.add(var1.x * var3 * var5, var1.y * var3, var1.z * var3 * var5);
         this.appliedVelocity.set(this.externalVelocity);
         this.ignoreDamping = false;
      }
   }

   @Override
   class="kw">public void setVelocity(@Nonnull Vector3dc var1, @Nullable VelocityConfig var2, boolean var3) {
      if (!SplitVelocity.SHOULD_MODIFY_VELOCITY && var2 != null) {
         this.appliedVelocities.clear();
         this.appliedVelocities.add(new MotionControllerBase.AppliedVelocity(new Vector3d(var1), var2));
      } else {
         this.externalVelocity.set(var1);
         this.ignoreDamping = var3;
      }
   }

   class="kw">public void clearExternalVelocity() {
      this.externalVelocity.zero();
   }

   class="kw">protected void dumpCollisionResults() {
      String var1 = "";
      if (this.collisionResult.isSliding) {
         var1 = String.format("SLIDE: start/end=%f/%f", this.collisionResult.slideStart, this.collisionResult.slideEnd);
      }

      LOGGER.at(Level.INFO)
         .log(
            "eid=%d CollRes: pos=%s yaw=%f count=%d %s",
            this.debugEntityId,
            Vector3dUtil.formatShortString(this.position),
            (180.0F / (float)Math.PI) * this.yaw,
            this.collisionResult.getBlockCollisionCount(),
            var1
         );
      if (this.collisionResult.getBlockCollisionCount() > 0) {
         for (int var2 = 0; var2 < this.collisionResult.getBlockCollisionCount(); var2++) {
            BlockCollisionData var3 = this.collisionResult.getBlockCollision(var2);
            String var4 = var3.blockMaterial != null ? var3.blockMaterial.name() : "none";
            String var5 = var3.blockType != null ? var3.blockType.getId() : "none";
            String var6 = var3.blockType != null ? var3.blockType.getHitboxType() : "none";
            String var7;
            if (var3.blockType != null) {
               RotationTuple var8 = RotationTuple.get(var3.rotation);
               var7 = var8.yaw() + " " + var8.pitch();
            } else {
               var7 = "none";
            }

            LOGGER.at(Level.INFO)
               .log(
                  "eid=%d    COLL: blk=%s/%s/%s start=%f norm=%s pos=%s mat=%s block=%s hitbox=%s rot=%s",
                  this.debugEntityId,
                  var3.x,
                  var3.y,
                  var3.z,
                  var3.collisionStart,
                  Vector3dUtil.formatShortString(var3.collisionNormal),
                  Vector3dUtil.formatShortString(var3.collisionPoint),
                  var4,
                  var5,
                  var6,
                  new Object[]{var7}
               );
         }
      }
   }

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

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

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

   @Override
   class="kw">public boolean isAvoidingBlockDamage() {
      class="kw">return !this.relaxedConstraints.contains(RelaxedConstraint.DAMAGE);
   }

   class="kw">protected void applyRuntimeRelaxedConstraints(boolean var1) {
      if (this.isReceivingBlockDamage) {
         this.relaxedConstraints.add(RelaxedConstraint.DAMAGE);
      }

      if (var1) {
         this.relaxedConstraints.add(RelaxedConstraint.BREATHE);
         this.relaxedConstraints.add(RelaxedConstraint.WADE);
      }
   }

   class="kw">public void processTriggers(@Nonnull Ref<EntityStore> var1, @Nonnull CollisionResult var2, double var3, @Nonnull ComponentAccessor<EntityStore> var5) {
      this.processTriggersHasMoved = false;
      this.isReceivingBlockDamage = false;
      if (this.enableTriggers || this.enableBlockDamage) {
         var2.pruneTriggerBlocks(var3);
         int var6 = var2.getTriggerBlocks().size();
         if (var6 != 0) {
            if (this.enableTriggers) {
               this.beforeTriggerExternalVelocity.set(this.getExternalVelocity());
               this.beforeTriggerPosition.set(this.position);
            }

            this.moveEntity(var1, 0.0, var5);
            InteractionManager var7 = var5.getComponent(var1, InteractionModule.get().getInteractionManagerComponent());
            assert var7 != null;
            int var8 = var2.defaultTriggerBlocksProcessing(var7, this.entity, var1, this.enableTriggers, var5);
            if (this.enableBlockDamage && var8 > 0) {
               Damage var9 = new Damage(Damage.NULL_SOURCE, DamageCause.ENVIRONMENT, var8);
               DamageSystems.executeDamage(var1, var5, var9);
               this.isReceivingBlockDamage = true;
            }

            this.readEntityPosition(var1, var5);
            if (this.enableTriggers) {
               this.processTriggersHasMoved = !this.beforeTriggerExternalVelocity.equals(this.getExternalVelocity())
                  || !this.beforeTriggerPosition.equals(this.position);
            }
         }
      }
   }

   class="kw">private class="kw">static void pruneFilteredTriggerBlocks(@Nonnull CollisionResult var0) {
      CollisionDataArray var1 = var0.getTriggerBlocks();

      for (int var2 = var1.size() - 1; var2 >= 0; var2--) {
         if (var1.get(var2).filteredByCollisionFilter) {
            var1.remove(var2);
         }
      }
   }

   class="kw">public boolean isProcessTriggersHasMoved() {
      class="kw">return this.processTriggersHasMoved;
   }

   class="kw">protected boolean isAlive(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      class="kw">return !var2.getArchetype(var1).contains(DeathComponent.getComponentType());
   }

   @Override
   class="kw">public void onDebugFlagsChanged(EnumSet<RoleDebugFlags> var1) {
      MotionController.super.onDebugFlagsChanged(var1);
      this.debugModeSteer = var1.contains(RoleDebugFlags.MotionControllerSteer);
      this.debugModeMove = var1.contains(RoleDebugFlags.MotionControllerMove);
      this.debugModeMoveSkipIdle = var1.contains(RoleDebugFlags.MotionControllerMoveSkipIdle);
      this.debugModeCollisions = var1.contains(RoleDebugFlags.Collisions);
      this.debugModeBlockCollisions = var1.contains(RoleDebugFlags.BlockCollisions);
      this.debugModeProbeBlockCollisions = var1.contains(RoleDebugFlags.ProbeBlockCollisions);
      this.debugModeValidatePositions = var1.contains(RoleDebugFlags.ValidatePositions);
      this.debugModeOverlaps = var1.contains(RoleDebugFlags.Overlaps);
      this.debugModeNonOverlaps = var1.contains(RoleDebugFlags.NonOverlaps);
      this.debugModeValidateMath = var1.contains(RoleDebugFlags.ValidateMath);
   }

   class="kw">protected boolean shouldDebugMove(@Nonnull Vector3d var1) {
      class="kw">return this.debugModeMove && (!this.debugModeMoveSkipIdle || !CollisionModule.isBelowMovementThreshold(var1));
   }

   @Override
   class="kw">public void activate() {
      this.resetObstructedFlags();
      this.resetNavState();
   }

   class="kw">public void resetNavState() {
      this.navState = NavState.AT_GOAL;
      this.throttleDuration = 0.0;
      this.targetDeltaSquared = 0.0;
   }

   class="kw">public void resetObstructedFlags() {
      this.isObstructed = false;
   }

   @Override
   class="kw">public void deactivate() {
   }

   class="kw">public double getEpsilonSpeed() {
      class="kw">return this.epsilonSpeed;
   }

   class="kw">public float getEpsilonAngle() {
      class="kw">return this.epsilonAngle;
   }

   @Nonnull
   @Override
   class="kw">public Vector3d getComponentSelector() {
      class="kw">return this.componentSelector;
   }

   @Nonnull
   @Override
   class="kw">public Vector3d getPlanarComponentSelector() {
      class="kw">return this.planarComponentSelector;
   }

   @Override
   class="kw">public void setComponentSelector(@Nonnull Vector3d var1) {
      this.componentSelector.set(var1);
   }

   @Override
   class="kw">public Vector3dc getWorldNormal() {
      class="kw">return this.worldNormal;
   }

   @Override
   class="kw">public Vector3dc getWorldAntiNormal() {
      class="kw">return this.worldAntiNormal;
   }

   @Override
   class="kw">public double waypointDistance(@Nonnull Vector3dc var1, @Nonnull Vector3dc var2) {
      class="kw">return Math.sqrt(this.waypointDistanceSquared(var1, var2));
   }

   @Override
   class="kw">public double waypointDistanceSquared(@Nonnull Vector3dc var1, @Nonnull Vector3dc var2) {
      double var3 = (var1.x() - var2.x()) * this.getComponentSelector().x;
      double var5 = (var1.y() - var2.y()) * this.getComponentSelector().y;
      double var7 = (var1.z() - var2.z()) * this.getComponentSelector().z;
      class="kw">return var3 * var3 + var5 * var5 + var7 * var7;
   }

   @Override
   class="kw">public double waypointDistance(@Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      class="kw">return Math.sqrt(this.waypointDistanceSquared(var1, var2, var3));
   }

   @Override
   class="kw">public double waypointDistanceSquared(@Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      TransformComponent var4 = var3.getComponent(var1, TransformComponent.getComponentType());
      assert var4 != null;
      Vector3d var5 = var4.getPosition();
      double var6 = (var2.x - var5.x()) * this.getComponentSelector().x;
      double var8 = (var2.y - var5.y()) * this.getComponentSelector().y;
      double var10 = (var2.z - var5.z()) * this.getComponentSelector().z;
      class="kw">return var6 * var6 + var8 * var8 + var10 * var10;
   }

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

   class="kw">public boolean isValidPosition(@Nonnull Vector3dc var1, @Nonnull CollisionResult var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      World var4 = var3.getExternalData().getWorld();
      var2.setDebugEntityId(this.debugEntityId);
      CollisionModule var5 = CollisionModule.get();
      CollisionModuleConfig var6 = var5.getConfig();
      boolean var7 = var6.isDumpInvalidBlocks();
      boolean var8 = var6.isDumpNonOverlappingBlocks();
      var6.setDumpInvalidBlocks(this.debugModeOverlaps);
      var6.setDumpNonOverlappingBlocks(this.debugModeNonOverlaps);
      boolean var9 = var5.validatePosition(
            var4,
            this.collisionBoundingBox,
            var1,
            this.getInvalidOverlapMaterials(),
            null,
            (var0, var1x, var2x, var3x) -> var3x.blockId != Integer.MIN_VALUE,
            var2
         )
         != -1;
      var6.setDumpInvalidBlocks(var7);
      var6.setDumpNonOverlappingBlocks(var8);
      class="kw">return var9;
   }

   class="kw">public int getInvalidOverlapMaterials() {
      class="kw">return 4;
   }

   class="kw">protected void saveMotionKind() {
      this.previousMotionKind = this.getMotionKind();
   }

   class="kw">protected boolean switchedToMotionKind(MotionKind var1) {
      class="kw">return this.getMotionKind() == var1 && this.previousMotionKind != var1;
   }

   class="kw">public MotionKind getMotionKind() {
      class="kw">return this.motionKind;
   }

   class="kw">public void setMotionKind(MotionKind var1) {
      this.motionKind = var1;
   }

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

   class="kw">public void setGravity(double var1) {
      this.gravity = var1;
   }

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

   @Nonnull
   @Override
   class="kw">public Box getCollisionBoundingBox() {
      class="kw">return this.collisionBoundingBox;
   }

   @Override
   class="kw">public boolean standingOnBlockOfType(int var1) {
      class="kw">return false;
   }

   @Override
   class="kw">public void requirePreciseMovement(@Nullable Vector3d var1) {
      this.requiresPreciseMovement = true;
      this.havePreciseMovementTarget = var1 != null;
      if (this.havePreciseMovementTarget) {
         this.preciseMovementTarget.set(var1);
      }
   }

   class="kw">public void clearRequirePreciseMovement() {
      this.requiresPreciseMovement = false;
      this.havePreciseMovementTarget = false;
   }

   class="kw">public boolean isRequiresPreciseMovement() {
      class="kw">return this.requiresPreciseMovement;
   }

   @Override
   class="kw">public void enableHeadingBlending(double var1, @Nullable Vector3d var3, double var4) {
      this.isBlendingHeading = true;
      this.blendHeading = var1;
      this.haveBlendHeadingPosition = var3 != null;
      if (this.haveBlendHeadingPosition) {
         this.blendHeadingPosition.set(var3);
      }

      this.blendLevelAtTargetPosition = var4;
   }

   @Override
   class="kw">public void enableHeadingBlending() {
      this.enableHeadingBlending(Double.NaN, null, 0.0);
   }

   class="kw">public void clearBlendHeading() {
      this.isBlendingHeading = false;
      this.haveBlendHeadingPosition = false;
   }

   @Override
   class="kw">public void setRelaxedMoveConstraints(@Nonnull EnumSet<RelaxedConstraint> var1) {
      this.relaxedConstraints.clear();
      this.relaxedConstraints.addAll(var1);
   }

   @Nonnull
   @Override
   class="kw">public EnumSet<RelaxedConstraint> getRelaxedConstraints() {
      class="kw">return this.relaxedConstraints;
   }

   @Override
   class="kw">public void updatePhysicsValues(PhysicsValues var1) {
      this.movementSettings = MovementManager.MASTER_DEFAULT.apply(var1, GameMode.Adventure);
   }

   class="kw">protected class="kw">static class AppliedVelocity {
      class="kw">public class="kw">final Vector3d velocity;
      class="kw">public class="kw">final VelocityConfig config;
      class="kw">public boolean canClear;

      class="kw">public AppliedVelocity(Vector3d var1, VelocityConfig var2) {
         this.velocity = var1;
         this.config = var2;
      }
   }
}