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.component.Store;
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.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockCollisionData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.WorldUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
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.ChunkColumn;
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.asset.builder.BuilderSupport;
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.controllers.builders.BuilderMotionControllerFly;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import com.hypixel.hytale.server.npc.util.PositionProbeAir;
class="kw">import java.util.Set;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class MotionControllerFly class="kw">extends MotionControllerBase {
   class="kw">public class="kw">static class="kw">final String TYPE = "Fly";
   class="kw">public class="kw">static class="kw">final Set<MovementMode> SUPPORTED_MOVEMENT_MODES = Set.of(MovementMode.FLY);
   class="kw">public class="kw">static class="kw">final Set<MovementMode> DEFAULT_SPAWN_MOVEMENT_MODES = Set.of(MovementMode.FLY);
   class="kw">public class="kw">static class="kw">final double DAMPING_FACTOR = 20.0;
   class="kw">public class="kw">static class="kw">final int COLLISION_MATERIALS_PASSIVE = 4;
   class="kw">public class="kw">static class="kw">final int COLLISION_MATERIALS_ACTIVE = 6;
   class="kw">protected class="kw">final double minAirSpeed;
   class="kw">protected class="kw">final double maxClimbSpeed;
   class="kw">protected class="kw">final double maxSinkSpeed;
   class="kw">protected class="kw">final double maxFallSpeed;
   class="kw">protected class="kw">final double maxSinkSpeedFluid;
   class="kw">protected class="kw">final float maxClimbAngle;
   class="kw">protected class="kw">final float maxSinkAngle;
   class="kw">protected class="kw">final double acceleration;
   class="kw">protected class="kw">final double deceleration;
   class="kw">protected class="kw">final double sinkRatio = 0.5;
   class="kw">protected class="kw">final double desiredAltitudeWeight;
   class="kw">protected class="kw">final float maxTurnSpeed;
   class="kw">protected class="kw">final float maxRollAngle;
   class="kw">protected class="kw">final float maxRollSpeed;
   class="kw">protected class="kw">final float rollDamping;
   class="kw">protected class="kw">final double fastFlyThreshold;
   class="kw">protected class="kw">final double minHeightOverGround;
   class="kw">protected class="kw">final double maxHeightOverGround;
   class="kw">protected class="kw">final boolean autoLevel;
   class="kw">protected class="kw">final double sinMaxClimbAngle;
   class="kw">protected class="kw">final double sinMaxSinkAngle;
   class="kw">protected class="kw">final MotionController.VerticalRange verticalRange = new MotionController.VerticalRange();
   class="kw">protected class="kw">final PositionProbeAir moveProbe = new PositionProbeAir();
   class="kw">protected class="kw">final PositionProbeAir probeMoveProbe = new PositionProbeAir();
   class="kw">protected int lastVerticalPositionX = Integer.MIN_VALUE;
   class="kw">protected int lastVerticalPositionZ = Integer.MIN_VALUE;
   class="kw">protected class="kw">final Vector3d lastVelocity = new Vector3d();
   class="kw">protected double lastSpeed;
   class="kw">protected float lastRoll;
   class="kw">protected double currentRelativeSpeed;
   class="kw">protected double externalVelocityStopThresholdSquared;
   @Nullable
   class="kw">protected double[] desiredAltitudeOverride;

   class="kw">public MotionControllerFly(@Nonnull BuilderSupport var1, @Nonnull BuilderMotionControllerFly var2) {
      super(var1, var2);
      this.setGravity(var2.getGravity());
      this.componentSelector.set(1.0, 1.0, 1.0);
      this.minAirSpeed = var2.getMinAirSpeed();
      this.maxClimbSpeed = var2.getMaxClimbSpeed();
      this.maxSinkSpeed = var2.getMaxSinkSpeed();
      this.maxFallSpeed = var2.getMaxFallSpeed();
      this.maxSinkSpeedFluid = var2.getMaxSinkSpeedFluid();
      this.maxClimbAngle = var2.getMaxClimbAngle();
      this.sinMaxClimbAngle = TrigMathUtil.sin(this.maxClimbAngle);
      this.maxSinkAngle = var2.getMaxSinkAngle();
      this.sinMaxSinkAngle = -TrigMathUtil.sin(this.maxSinkAngle);
      this.acceleration = var2.getAcceleration();
      this.deceleration = var2.getDeceleration();
      this.maxTurnSpeed = var2.getMaxTurnSpeed();
      this.maxRollAngle = var2.getMaxRollAngle();
      this.minHeightOverGround = var2.getMinHeightOverGround(var1);
      this.maxHeightOverGround = var2.getMaxHeightOverGround(var1);
      this.maxRollSpeed = var2.getMaxRollSpeed();
      this.rollDamping = var2.getRollDamping();
      this.fastFlyThreshold = var2.getFastFlyThreshold();
      this.autoLevel = var2.isAutoLevel();
      this.desiredAltitudeWeight = var2.getDesiredAltitudeWeight();
      this.externalVelocityStopThresholdSquared = MathUtil.minValue(this.maxHorizontalSpeed, this.maxSinkSpeed, this.maxClimbSpeed);
      this.externalVelocityStopThresholdSquared = this.externalVelocityStopThresholdSquared * this.externalVelocityStopThresholdSquared;
   }

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

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

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

   @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
   ) {
      this.saveMotionKind();
      this.setMotionKind(this.inWater() ? MotionKind.MOVING : MotionKind.FLYING);
      this.moveProbe.probePosition(var1, this.collisionBoundingBox, this.position, this.collisionResult, var7);
      this.currentRelativeSpeed = var3.getSpeed();
      if (!this.isAlive(var1, var7)) {
         this.externalVelocity.zero();
         this.appliedVelocities.clear();
      }

      double var8 = this.moveProbe.isInWater() ? this.maxSinkSpeedFluid : this.maxFallSpeed;
      boolean var10 = this.onGround();
      if (this.externalVelocity.equals(Vector3dUtil.ZERO) && this.appliedVelocities.isEmpty()) {
         if (NPCPhysicsMath.near(this.lastVelocity, Vector3dUtil.ZERO)) {
            PhysicsMath.vectorFromAngles(this.getYaw(), this.getPitch(), this.lastVelocity);
            this.lastSpeed = 0.0;
         }

         if (this.canSteer(var1, var7)) {
            var6.set(var3.getTranslation());
            double var50 = var3.hasTranslation() ? var6.length() : 0.0;
            float var13 = PhysicsMath.normalizeAngle(this.getYaw());
            float var14 = PhysicsMath.normalizeTurnAngle(this.getPitch());
            double var15 = var6.x;
            double var17 = var6.z;
            double var21 = var15 * var15 + var17 * var17;
            float var19;
            float var20;
            if (var21 >= 1.0E-12) {
               var19 = PhysicsMath.headingFromDirection(var15, var17);
               var20 = TrigMathUtil.atan2(var6.y, Math.sqrt(var21));
            } else {
               var19 = var3.hasYawOrDirection() ? var3.getYawOrDirection() : var13;
               var20 = var3.hasPitchOrDirection() ? var3.getPitchOrDirection() : (this.autoLevel ? 0.0F : var14);
            }

            var3.clearYaw();
            var3.clearPitch();
            var20 = MathUtil.clamp(var20, -this.maxSinkAngle, this.maxClimbAngle);
            float var23 = NPCPhysicsMath.turnAngle(var13, var19);
            float var24 = NPCPhysicsMath.turnAngle(var14, var20);
            float var25 = (float)(this.getCurrentMaxBodyRotationSpeed() * var4);
            var23 = NPCPhysicsMath.clampRotation(var23, var25);
            var24 = NPCPhysicsMath.clampRotation(var24, var25);
            float var26 = PhysicsMath.normalizeAngle(var13 + var23);
            float var27 = PhysicsMath.normalizeTurnAngle(var14 + var24);
            double var28 = this.computeMaxSpeedFromPitch(var14);
            var50 *= var28;
            double var30 = Math.max(this.minAirSpeed, this.lastSpeed - this.deceleration * var4);
            double var32 = this.lastSpeed + this.acceleration * var4;
            var50 = var32 < var30 ? var30 : MathUtil.clamp(var50, var30, var32);
            PhysicsMath.vectorFromAngles(var26, var27, var6);
            var6.normalize();
            double var34 = this.lastVelocity.z;
            double var36 = -this.lastVelocity.x;
            double var38 = Math.sqrt(var34 * var34 + var36 * var36);
            float var40 = 0.0F;
            if (var38 != 0.0) {
               var40 = (float)(NPCPhysicsMath.dotProduct(var34, 0.0, var36, var6.x, var6.y, var6.z) / var38);
            }

            float var41 = (float)(this.maxTurnSpeed * var4);
            float var42 = TrigMathUtil.sin(var41);
            float var43 = var40 / var42;
            double var44 = var50 / var28;
            float var46 = this.maxRollAngle * MathUtil.clamp(var43, -1.0F, 1.0F) * MathUtil.clamp((float)var44, 0.0F, 1.0F);
            float var47 = MathUtil.clamp(this.rollDamping * this.lastRoll + (1.0F - this.rollDamping) * var46, -this.maxRollAngle, this.maxRollAngle);
            float var48 = (float)(this.maxRollSpeed * var4);
            float var49 = MathUtil.clamp(var47, this.lastRoll - var48, this.lastRoll + var48);
            this.lastRoll = var49;
            var3.setYaw(var26);
            var3.setPitch(var27);
            var3.setRoll(var49);
            if (var50 == 0.0) {
               var6.zero();
            } else {
               var6.mul(var50 * this.effectHorizontalSpeedMultiplier);
            }

            this.lastVelocity.set(var6);
            this.lastSpeed = var50;
            var6.mul(var4);
            if (this.debugModeValidateMath && !NPCPhysicsMath.isValid(var6)) {
               throw new IllegalArgumentException(String.valueOf(var6));
            }
         } else {
            var3.setYaw(this.getYaw());
            var3.setPitch(this.getPitch());
            var3.setRoll(this.getRoll());
            if (var10) {
               this.setMotionKind(MotionKind.STANDING);
               this.lastVelocity.zero();
               this.lastSpeed = 0.0;
               class="kw">return var4;
            }

            this.setMotionKind(MotionKind.DROPPING);
            var6.y = NPCPhysicsMath.gravityDrag(this.lastVelocity.y, this.gravity, var4, var8);
            double var53 = var8 - var6.y;
            if (!(var53 <= 0.0) && !this.isObstructed()) {
               double var54 = var6.x * var6.x + var6.z * var6.z;
               if (var53 * var53 < var54) {
                  var54 = Math.sqrt(var54 / var53);
                  var6.x = this.lastVelocity.x * var54;
                  var6.z = this.lastVelocity.z * var54;
               } else {
                  var6.x = this.lastVelocity.x;
                  var6.z = this.lastVelocity.z;
               }
            } else {
               var6.x = 0.0;
               var6.z = 0.0;
            }

            this.lastVelocity.set(var6);
            this.lastSpeed = this.lastVelocity.length();
            var6.mul(var4);
            if (this.debugModeValidateMath && !NPCPhysicsMath.isValid(var6)) {
               throw new IllegalArgumentException(String.valueOf(var6));
            }
         }

         if (this.lastSpeed > 1.0E-6 && this.isAlive(var1, var7)) {
            this.setDirectionFromTranslation(var3, var6);
         }

         class="kw">return var4;
      } else {
         var3.setYaw(this.getYaw());
         var3.setPitch(this.getPitch());
         var3.setRoll(this.getRoll());
         if (!this.isObstructed()) {
            var6.set(this.externalVelocity);

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

               if (var10 && var12.canClear) {
                  var12.velocity.y = 0.0;
               }

               var6.add(var12.velocity);
            }
         } else {
            var6.zero();
            this.appliedVelocities.clear();
            this.externalVelocity.zero();
         }

         if (!var10) {
            var6.y = NPCPhysicsMath.accelerateDrag(var6.y, -this.gravity, var4, var8);
         }

         this.lastVelocity.set(var6);
         this.lastSpeed = this.lastVelocity.length();
         var6.mul(var4);
         if (this.debugModeValidateMath && !NPCPhysicsMath.isValid(var6)) {
            throw new IllegalArgumentException(String.valueOf(var6));
         } else {
            class="kw">return var4;
         }
      }
   }

   class="kw">private void setDirectionFromTranslation(@Nonnull Steering var1, @Nonnull Vector3d var2) {
      if (!var1.hasYaw()) {
         if (var2.x * var2.x + var2.z * var2.z > 1.0E-6) {
            var1.setYaw(PhysicsMath.headingFromDirection(var2.x, var2.z));
         } else {
            var1.setYaw(this.getYaw());
         }
      }

      if (!var1.hasPitch()) {
         var1.setPitch(PhysicsMath.pitchFromDirection(var2.x, var2.y, var2.z));
      }
   }

   @Override
   class="kw">public double probeMove(@Nonnull Ref<EntityStore> var1, @Nonnull ProbeMoveData var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      Predicate var4 = this.collisionResult.setBlockCollisionFilter(var2.getBlockCollisionFilter());

      try {
         class="kw">return var2.probeDirection.length() * this.doMove(var1, var2.probePosition, var2.probeDirection, this.probeMoveProbe, var2, var3);
      } class="kw">finally {
         this.collisionResult.setBlockCollisionFilter(var4);
      }
   }

   @Override
   class="kw">public boolean isFastMotionKind(double var1) {
      class="kw">return this.lastVelocity.y < -1.0E-6 || this.currentRelativeSpeed > this.fastFlyThreshold && this.lastVelocity.y <= 1.0E-6;
   }

   @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;
      Vector3d var4 = var3.getPosition();
      int var5 = MathUtil.floor(var4.x());
      int var6 = MathUtil.floor(var4.z());
      if (var5 == this.lastVerticalPositionX && var6 == this.lastVerticalPositionZ) {
         class="kw">return this.verticalRange;
      }

      this.lastVerticalPositionX = var5;
      this.lastVerticalPositionZ = var6;
      double var7 = var4.y();
      World var9 = var2.getExternalData().getWorld();
      ChunkStore var10 = var9.getChunkStore();
      long var11 = ChunkUtil.indexChunkFromBlock(var5, var6);
      Ref var13 = var10.getChunkReference(var11);
      if (var13 != null && var13.isValid()) {
         Store var14 = var10.getStore();
         ChunkColumn var15 = var14.getComponent(var13, ChunkColumn.getComponentType());
         BlockChunk var16 = var14.getComponent(var13, BlockChunk.getComponentType());
         if (var15 != null && var16 != null) {
            double var17;
            double var19;
            if (this.desiredAltitudeOverride != null) {
               var17 = this.desiredAltitudeOverride[0];
               var19 = this.desiredAltitudeOverride[1];
            } else {
               var17 = this.minHeightOverGround;
               var19 = this.maxHeightOverGround;
            }

            int var21 = MathUtil.floor(var7);
            double var22 = WorldUtil.findFarthestEmptySpaceBelow(var14, var15, var16, var5, var21, var6, var21) + this.collisionBoundingBox.min.y;
            double var24 = WorldUtil.findFarthestEmptySpaceAbove(var14, var15, var16, var5, var21, var6, var21) - this.collisionBoundingBox.max.y + 1.0;
            double var26 = var22 + var17;
            double var28 = Math.min(var22 + var19, var24);
            if (var26 > var28) {
               var26 = var7;
               var28 = var7;
            }

            this.verticalRange.set(var7, var26, var28);
            class="kw">return this.verticalRange;
         } else {
            this.verticalRange.set(var7, var7, var7);
            class="kw">return this.verticalRange;
         }
      } else {
         this.verticalRange.set(var7, var7, var7);
         class="kw">return this.verticalRange;
      }
   }

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

   class="kw">protected double doMove(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Vector3d var2,
      @Nonnull Vector3d var3,
      @Nonnull PositionProbeAir var4,
      @Nullable ProbeMoveData var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      boolean var7 = var5 != null;
      boolean var8 = var7 && var5.startProbing();
      boolean var9 = var7 || this.canSteer(var1, var6);
      String var10 = var7 ? "Probe" : "Move";
      if (this.shouldDebugMove(var3)) {
         LOGGER.at(Level.INFO)
            .log(
               "eid=%d %s - Fly: Execute pos=%s vel=%s onGround=%s blocked=%s ",
               this.debugEntityId,
               var10,
               Vector3dUtil.formatShortString(var2),
               Vector3dUtil.formatShortString(var3),
               this.onGround(),
               this.isObstructed
            );
      }

      if (var7) {
         this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
      }

      if (this.debugModeValidatePositions && !this.isValidPosition(var2, this.collisionResult, var6)) {
         throw new IllegalStateException("Invalid position");
      }

      if (var8) {
         var5.addStartSegment(var2, false);
      }

      if (var7) {
         this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
      }

      if (var7 && !var4.probePosition(var1, this.collisionBoundingBox, var2, this.collisionResult, var6)) {
         if (var8) {
            appendProbeInvalidStartSegment(var5, var2);
         }

         class="kw">return 0.0;
      } else {
         if (!var7) {
            this.isObstructed = false;
            if (this.debugModeBlockCollisions) {
               this.collisionResult.setLogger(LOGGER, this.debugEntityId);
            }
         }

         this.collisionResult.setCollisionByMaterial(var9 ? 6 : 4);
         if (var7) {
            this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
         }

         CollisionModule.findCollisions(this.collisionBoundingBox, var2, var3, this.collisionResult, var6);
         if (this.debugModeBlockCollisions) {
            this.collisionResult.setLogger(null);
         }

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

         BlockCollisionData var11 = this.collisionResult.getFirstBlockCollision();
         this.lastValidPosition.set(var2);
         double var12;
         if (var11 == null) {
            var2.add(var3);
            var12 = 1.0;
            if (this.shouldDebugMove(var3)) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d %s - Fly: No collision pos=%s vel=%s onGround=%s blocked=%s ",
                     this.debugEntityId,
                     var10,
                     Vector3dUtil.formatShortString(var2),
                     Vector3dUtil.formatShortString(var3),
                     this.onGround(),
                     this.isObstructed
                  );
            }

            if (var7) {
               this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
            }

            if (this.debugModeValidatePositions && !this.isValidPosition(var2, this.collisionResult, var6)) {
               throw new IllegalStateException("Invalid position");
            }
         } else {
            var2.set(var11.collisionPoint);
            var12 = var11.collisionStart;
            if (!var7) {
               this.isObstructed = true;
            }

            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d %s - Fly: Collision pos=%s collStart=%s vel=%s onGround=%s blocked=%s ",
                     this.debugEntityId,
                     var10,
                     Vector3dUtil.formatShortString(var2),
                     var12,
                     Vector3dUtil.formatShortString(var3),
                     this.onGround(),
                     this.isObstructed
                  );
            }

            if (var7) {
               this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
            }

            if (this.debugModeValidatePositions && !this.isValidPosition(var2, this.collisionResult, var6)) {
               throw new IllegalStateException("Invalid position");
            }
         }

         if (var7) {
            this.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
         }

         if (!var4.probePosition(var1, this.collisionBoundingBox, var2, this.collisionResult, var6)) {
            double var14 = this.bisect(this.lastValidPosition, var2, this, (var4x, var5x) -> {
               if (var7) {
                  var4x.collisionResult.setBlockCollisionFilter(var5.getBlockCollisionFilter());
               }

               class="kw">return var4x.moveProbe.probePosition(var1, var4x.collisionBoundingBox, var5x, var4x.collisionResult, var6);
            }, var2);
            var12 *= var14;
            if (this.debugModeMove) {
               LOGGER.at(Level.INFO)
                  .log(
                     "eid=%d %s - Fly: Bisect step pos=%s distanceFactor=%s adjust=%s",
                     this.debugEntityId,
                     var10,
                     Vector3dUtil.formatShortString(var2),
                     var12,
                     var14
                  );
            }
         }

         if (!var7) {
            this.processTriggers(var1, this.collisionResult, var12, var6);
         } else if (var8) {
            double var16 = this.waypointDistance(var5.initialPosition, var2);
            if (var11 == null) {
               var5.addMoveSegment(var2, false, var16);
            } else if (this.getWorldNormal().equals(var11.collisionNormal)) {
               var5.addHitGroundSegment(var2, var16, var11.collisionNormal, var11.blockId);
            } else {
               var5.addHitWallSegment(var2, false, var16, var11.collisionNormal, var11.blockId);
            }

            var5.addEndSegment(var2, false, var16);
         }

         class="kw">return var12;
      }
   }

   class="kw">static void appendProbeInvalidStartSegment(@Nonnull ProbeMoveData var0, @Nonnull Vector3d var1) {
      var0.addEndSegment(var1, false, 0.0);
   }

   @Override
   class="kw">protected double executeMove(
      @Nonnull Ref<EntityStore> var1, @Nonnull Role var2, double var3, @Nonnull Vector3d var5, @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      double var7 = this.doMove(var1, this.position, var5, this.moveProbe, null, var6);
      if (var7 < 1.0) {
         var3 *= var7;
         this.lastSpeed *= var7;
         this.lastVelocity.mul(var7);
      }

      class="kw">return var3;
   }

   @Override
   class="kw">public void constrainRotations(Role var1, TransformComponent var2) {
   }

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

   @Override
   class="kw">protected void dampExternalVelocity(@Nonnull Vector3d var1, double var2, double var4, ComponentAccessor<EntityStore> var6) {
      if (var1.lengthSquared() < this.externalVelocityStopThresholdSquared) {
         var1.zero();
      } else {
         NPCPhysicsMath.deccelerateToStop(var1, this.getDampingDeceleration(), var4);
      }
   }

   @Override
   class="kw">protected boolean shouldDampenAppliedVelocitiesY() {
      class="kw">return true;
   }

   @Override
   class="kw">protected boolean shouldAlwaysUseGroundResistance() {
      class="kw">return true;
   }

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

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

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

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

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

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

   @Override
   class="kw">public double getCurrentTurnRadius() {
      class="kw">return this.lastSpeed / this.maxTurnSpeed;
   }

   @Override
   class="kw">public float getMaxClimbAngle() {
      class="kw">return this.maxClimbAngle;
   }

   @Override
   class="kw">public float getMaxSinkAngle() {
      class="kw">return this.maxSinkAngle;
   }

   @Override
   class="kw">public double getMaximumSpeed() {
      class="kw">return MathUtil.maxValue(this.maxClimbSpeed, this.maxHorizontalSpeed, this.maxSinkSpeed) * this.effectHorizontalSpeedMultiplier;
   }

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

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

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

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

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

   @Override
   class="kw">public boolean estimateVelocity(Steering var1, @Nonnull Vector3d var2) {
      var2.zero();
      class="kw">return false;
   }

   @Override
   class="kw">public void clearOverrides() {
      this.desiredAltitudeOverride = null;
   }

   class="kw">public void setDesiredAltitudeOverride(double[] var1) {
      this.desiredAltitudeOverride = var1;
   }

   class="kw">public void takeOff(@Nonnull Ref<EntityStore> var1, double var2, @Nonnull ComponentAccessor<EntityStore> var4) {
      TransformComponent var5 = var4.getComponent(var1, TransformComponent.getComponentType());
      assert var5 != null;
      PhysicsMath.vectorFromAngles(var5.getRotation().yaw(), (float) (Math.PI / 4), this.lastVelocity);
      this.lastSpeed = var2;
   }

   class="kw">public double getExternalVelocityStopThresholdSquared() {
      class="kw">return this.externalVelocityStopThresholdSquared;
   }

   class="kw">public double getDampingDeceleration() {
      class="kw">return this.externalVelocityDamping * 20.0;
   }

   class="kw">protected double computeMaxSpeedFromPitch(double var1) {
      double var3 = TrigMathUtil.sin(var1);
      double var5 = Math.sqrt(1.0 - var3 * var3);
      double var7 = var5 * this.maxHorizontalSpeed;
      double var9 = var3 * (var3 > 0.0 ? this.maxClimbSpeed : this.maxSinkSpeed);
      class="kw">return Math.sqrt(var7 * var7 + var9 * var9);
   }
}