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

class="kw">import com.google.gson.JsonElement;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderDescriptorState;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.DoubleHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.EnumHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.FloatHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.NumberArrayHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.AssetValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleRangeValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleSequenceValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleSingleValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.RelationalOperator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.BlockSetExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.movement.MovementMode;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionControllerWalk;
class="kw">import com.hypixel.hytale.server.spawning.SpawnTestResult;
class="kw">import com.hypixel.hytale.server.spawning.SpawningContext;
class="kw">import java.util.Set;
class="kw">import javax.annotation.Nonnull;

class="kw">public class BuilderMotionControllerWalk class="kw">extends BuilderMotionControllerBase {
   class="kw">private class="kw">static class="kw">final double[] DEFAULT_JUMP_RANGE = new double[]{0.0, 0.0};
   class="kw">private double minHorizontalSpeed;
   class="kw">private double maxVerticalSpeed;
   class="kw">private class="kw">final DoubleHolder acceleration = new DoubleHolder();
   class="kw">private double gravity;
   class="kw">private class="kw">final DoubleHolder maxRotationSpeed = new DoubleHolder();
   class="kw">private class="kw">final FloatHolder maxMoveTurnAngle = new FloatHolder();
   class="kw">private class="kw">final FloatHolder blendRestTurnAngle = new FloatHolder();
   class="kw">private class="kw">final DoubleHolder blendRestRelativeSpeed = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder maxClimbHeight = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder jumpHeight = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder jumpForce = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder jumpDescentSteepness = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder minJumpHeight = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder minJumpDistance = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder jumpBlending = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder jumpDescentBlending = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder climbSpeedMult = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder climbSpeedPow = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder climbSpeedConst = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder minDescentAnimationHeight = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder descendFlatness = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder descendSpeedCompensation = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder descentSteepness = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder descentBlending = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder maxDropHeight = new DoubleHolder();
   class="kw">private class="kw">final DoubleHolder maxDropHeightRelaxedAdjustment = new DoubleHolder();
   class="kw">private double maxVerticalSpeedFluid;
   class="kw">private class="kw">final NumberArrayHolder jumpRange = new NumberArrayHolder();
   class="kw">private double minHover;
   class="kw">private double maxHover;
   class="kw">private double minHoverClimb;
   class="kw">private double minHoverDrop;
   class="kw">private boolean floatsDown;
   class="kw">private float hoverFreq;
   class="kw">private double maxWalkSpeedAfterHitMultiplier;
   class="kw">private String fenceBlockSet;
   class="kw">private class="kw">final EnumHolder<MotionControllerWalk.DescentAnimationType> descentAnimationType = new EnumHolder<>();
   class="kw">private class="kw">final EnumHolder<MotionControllerWalk.AscentAnimationType> ascentAnimationType = new EnumHolder<>();

   class="kw">public BuilderMotionControllerWalk() {
   }

   @Nonnull
   class="kw">public MotionControllerWalk build(@Nonnull BuilderSupport var1) {
      class="kw">return new MotionControllerWalk(this, var1);
   }

   @Nonnull
   @Override
   class="kw">public String getShortDescription() {
      class="kw">return "Provide walk on ground abilities for NPC";
   }

   @Nonnull
   @Override
   class="kw">public String getLongDescription() {
      class="kw">return "Provide walk on ground abilities for NPC";
   }

   @Nonnull
   @Override
   class="kw">public BuilderDescriptorState getBuilderDescriptorState() {
      class="kw">return BuilderDescriptorState.WorkInProgress;
   }

   @Nonnull
   class="kw">public BuilderMotionControllerWalk readConfig(@Nonnull JsonElement var1) {
      this.getDouble(
         var1, "MaxWalkSpeed", this.maxHorizontalSpeed, 3.0, DoubleSingleValidator.greater0(), BuilderDescriptorState.Stable, "Maximum horizontal speed", null
      );
      this.getDouble(
         var1,
         "MinWalkSpeed",
         var1x -> this.minHorizontalSpeed = var1x,
         0.1,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Minimum horizontal speed",
         null
      );
      this.getDouble(
         var1,
         "MaxFallSpeed",
         var1x -> this.maxVerticalSpeed = var1x,
         8.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Stable,
         "Maximum fall speed",
         null
      );
      this.getDouble(
         var1,
         "MaxSinkSpeedFluid",
         var1x -> this.maxVerticalSpeedFluid = var1x,
         4.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Stable,
         "Maximum sink speed in fluids",
         null
      );
      this.getDouble(var1, "Gravity", var1x -> this.gravity = var1x, 10.0, DoubleSingleValidator.greater0(), BuilderDescriptorState.Stable, "Gravity", null);
      this.getDouble(var1, "Acceleration", this.acceleration, 3.0, DoubleSingleValidator.greater0(), BuilderDescriptorState.Stable, "Acceleration", null);
      this.getDouble(
         var1,
         "MaxRotationSpeed",
         this.maxRotationSpeed,
         360.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Stable,
         "Maximum rotational speed in degrees",
         null
      );
      this.getFloat(
         var1,
         "MaxWalkTurnAngle",
         this.maxMoveTurnAngle,
         90.0,
         DoubleRangeValidator.between(0.0, 180.0),
         BuilderDescriptorState.WorkInProgress,
         "Maximum angle NPC can walk without explicit turning in degrees",
         null
      );
      this.getFloat(
         var1,
         "BlendRestTurnAngle",
         this.blendRestTurnAngle,
         60.0,
         DoubleRangeValidator.between(0.0, 180.0),
         BuilderDescriptorState.WorkInProgress,
         "When NPC is blending heading and turn angle required is larger than this value speed is reduced",
         null
      );
      this.getDouble(
         var1,
         "BlendRestRelativeSpeed",
         this.blendRestRelativeSpeed,
         0.2,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.WorkInProgress,
         "When NPC is blending heading relative speed used when reducing speed",
         null
      );
      this.getDouble(
         var1,
         "MaxClimbHeight",
         this.maxClimbHeight,
         1.3,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Stable,
         "Maximum height NPC can climb",
         null
      );
      this.getDouble(
         var1,
         "JumpHeight",
         this.jumpHeight,
         0.5,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "How high the NPC jumps above climb height",
         null
      );
      this.getDouble(
         var1,
         "MinJumpHeight",
         this.minJumpHeight,
         0.6,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "Minimum height above which a jump will be attempted",
         null
      );
      this.getDouble(
         var1,
         "MinJumpDistance",
         this.minJumpDistance,
         0.2,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "Minimum distance above which a jump will be executed",
         null
      );
      this.getDouble(
         var1,
         "JumpForce",
         this.jumpForce,
         1.5,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "The force multiplier for the upward motion of the jump",
         null
      );
      this.getDouble(
         var1,
         "JumpBlending",
         this.jumpBlending,
         1.0,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.Experimental,
         "The blending of the upwards jump pattern",
         "The blending of the upward jump pattern. 0 is more curved and 1 is linear"
      );
      this.getDouble(
         var1,
         "JumpDescentBlending",
         this.jumpDescentBlending,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "The blending of the jump descent pattern",
         "The blending of the jump descent pattern. 0 is linear while higher values become more curved"
      );
      this.getDouble(
         var1,
         "JumpDescentSteepness",
         this.jumpDescentSteepness,
         1.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "The steepness of the descent portion of the jump",
         null
      );
      this.getEnum(
         var1,
         "AscentAnimationType",
         this.ascentAnimationType,
         MotionControllerWalk.AscentAnimationType.class,
         MotionControllerWalk.AscentAnimationType.Walk,
         BuilderDescriptorState.Stable,
         "The animation to play when walking up a block",
         null
      );
      this.getDouble(
         var1,
         "ClimbSpeedMult",
         this.climbSpeedMult,
         0.0,
         null,
         BuilderDescriptorState.WorkInProgress,
         "Climb speed multiplier (const + multiplier * walkspeed ** power)",
         null
      );
      this.getDouble(
         var1,
         "ClimbSpeedPow",
         this.climbSpeedPow,
         1.0,
         null,
         BuilderDescriptorState.WorkInProgress,
         "Climb speed power (const + multiplier * walkspeed ** power)",
         null
      );
      this.getDouble(
         var1,
         "ClimbSpeedConst",
         this.climbSpeedConst,
         5.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.WorkInProgress,
         "Climb speed constant (const + multiplier * walkspeed ** power)",
         null
      );
      this.getDouble(
         var1,
         "MinDescentAnimationHeight",
         this.minDescentAnimationHeight,
         1.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Stable,
         "The min drop distance to class="kw">switch from the standard walking animation to the specified descent animation",
         null
      );
      this.getDouble(
         var1,
         "DescendFlatness",
         this.descendFlatness,
         0.7,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.WorkInProgress,
         "Relative scale how fast NPC moves forward while climbing down",
         null
      );
      this.getDouble(
         var1,
         "DescendSpeedCompensation",
         this.descendSpeedCompensation,
         0.9,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.WorkInProgress,
         "Factor to compensate forward speed reduction while moving downwards",
         null
      );
      this.getEnum(
         var1,
         "DescentAnimationType",
         this.descentAnimationType,
         MotionControllerWalk.DescentAnimationType.class,
         MotionControllerWalk.DescentAnimationType.Fall,
         BuilderDescriptorState.Experimental,
         "The animation to play when moving down a block",
         null
      );
      this.getDouble(
         var1,
         "DescentSteepness",
         this.descentSteepness,
         1.4,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.Experimental,
         "The relative steepness of the descent",
         null
      );
      this.getDouble(
         var1,
         "DescentBlending",
         this.descentBlending,
         1.8,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.Experimental,
         "The blending of the descent pattern",
         "The blending of the descent pattern. 0 is linear, while higher values become more curved"
      );
      this.getDouble(
         var1,
         "MaxDropHeight",
         this.maxDropHeight,
         3.0,
         DoubleSingleValidator.greater0(),
         BuilderDescriptorState.WorkInProgress,
         "Maximum height NPC considers drop safe",
         null
      );
      this.getDouble(
         var1,
         "MaxDropHeightRelaxedAdjustment",
         this.maxDropHeightRelaxedAdjustment,
         3.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Additional drop height when DROP constraint is relaxed",
         null
      );
      this.getAsset(
         var1,
         "FenceBlockSet",
         var1x -> this.fenceBlockSet = var1x,
         "Fence",
         BlockSetExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Unclimbable blocks",
         null
      );
      this.getDoubleRange(
         var1,
         "JumpRange",
         this.jumpRange,
         DEFAULT_JUMP_RANGE,
         DoubleSequenceValidator.betweenWeaklyMonotonic(0.0, 10.0),
         BuilderDescriptorState.WorkInProgress,
         "Jump distance range",
         null
      );
      this.getDouble(
         var1,
         "MinHover",
         var1x -> this.minHover = var1x,
         0.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Minimum hover height over ground",
         null
      );
      this.getDouble(
         var1,
         "MinHoverClimb",
         var1x -> this.minHoverClimb = var1x,
         0.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Minimum hover height over ground when climbing",
         null
      );
      this.getDouble(
         var1,
         "MinHoverDrop",
         var1x -> this.minHoverDrop = var1x,
         0.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Minimum hover height over ground when dropping",
         null
      );
      this.getBoolean(
         var1,
         "FloatsDown",
         var1x -> this.floatsDown = var1x,
         true,
         BuilderDescriptorState.WorkInProgress,
         "If true NPC floats down when hovering enabled else gravity decides",
         null
      );
      this.getDouble(
         var1,
         "MaxHover",
         var1x -> this.maxHover = var1x,
         0.0,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Maximum hover height over ground",
         null
      );
      this.getFloat(
         var1,
         "HoverFreq",
         var1x -> this.hoverFreq = var1x,
         0.0F,
         DoubleSingleValidator.greaterEqual0(),
         BuilderDescriptorState.WorkInProgress,
         "Hover frequency",
         null
      );
      this.getDouble(
         var1,
         "MinHitSlowdown",
         var1x -> this.maxWalkSpeedAfterHitMultiplier = 1.0 - var1x,
         0.1,
         DoubleRangeValidator.between01(),
         BuilderDescriptorState.Stable,
         "The minimum percentage to slow down by when attacked from behind",
         null
      );
      this.validateDoubleRelation("MinHover", this.minHover, RelationalOperator.LessEqual, "MaxHover", this.maxHover);
      this.validateDoubleRelation("MinHoverClimb", this.minHoverClimb, RelationalOperator.LessEqual, "MinHover", this.minHover);
      this.validateDoubleRelation("MinHoverDrop", this.minHoverDrop, RelationalOperator.LessEqual, "MinHover", this.minHover);
      this.validateDoubleRelation("MinWalkSpeed", this.minHorizontalSpeed, RelationalOperator.LessEqual, this.maxHorizontalSpeed);
      class="kw">return this;
   }

   @Nonnull
   @Override
   class="kw">public Class<MotionController> category() {
      class="kw">return MotionController.class;
   }

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

   class="kw">public double getMinHorizontalSpeed() {
      class="kw">return this.minHorizontalSpeed;
   }

   class="kw">public double getAcceleration(@Nonnull BuilderSupport var1) {
      class="kw">return this.acceleration.get(var1.getExecutionContext());
   }

   class="kw">public double getMaxVerticalSpeed() {
      class="kw">return this.maxVerticalSpeed;
   }

   class="kw">public double getMaxVerticalSpeedFluid() {
      class="kw">return this.maxVerticalSpeedFluid;
   }

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

   class="kw">public float getMaxMoveTurnAngle(@Nonnull BuilderSupport var1) {
      class="kw">return (float) (Math.PI / 180.0) * this.maxMoveTurnAngle.get(var1.getExecutionContext());
   }

   class="kw">public double getMaxRotationSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return (float) (Math.PI / 180.0) * this.maxRotationSpeed.get(var1.getExecutionContext());
   }

   class="kw">public float getBlendRestTurnAngle(@Nonnull BuilderSupport var1) {
      class="kw">return (float) (Math.PI / 180.0) * this.blendRestTurnAngle.get(var1.getExecutionContext());
   }

   class="kw">public double getBlendRestRelativeSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return this.blendRestRelativeSpeed.get(var1.getExecutionContext());
   }

   class="kw">public double getMaxClimbHeight(@Nonnull BuilderSupport var1) {
      class="kw">return this.maxClimbHeight.get(var1.getExecutionContext());
   }

   class="kw">public double getClimbSpeedMult(BuilderSupport var1) {
      class="kw">return this.climbSpeedMult.get(var1.getExecutionContext());
   }

   class="kw">public double getClimbSpeedPow(BuilderSupport var1) {
      class="kw">return this.climbSpeedPow.get(var1.getExecutionContext());
   }

   class="kw">public double getClimbSpeedConst(BuilderSupport var1) {
      class="kw">return this.climbSpeedConst.get(var1.getExecutionContext());
   }

   class="kw">public double getDescendForwardAmount(@Nonnull BuilderSupport var1) {
      class="kw">return this.descendFlatness.get(var1.getExecutionContext());
   }

   class="kw">public double getDescendSpeedCompensation(@Nonnull BuilderSupport var1) {
      class="kw">return this.descendSpeedCompensation.get(var1.getExecutionContext());
   }

   class="kw">public double getMaxDropHeight(@Nonnull BuilderSupport var1) {
      class="kw">return this.maxDropHeight.get(var1.getExecutionContext());
   }

   class="kw">public double getMaxDropHeightRelaxedAdjustment(@Nonnull BuilderSupport var1) {
      class="kw">return this.maxDropHeightRelaxedAdjustment.get(var1.getExecutionContext());
   }

   class="kw">public int getFenceBlockSet() {
      int var1 = BlockSet.getAssetMap().getIndex(this.fenceBlockSet);
      if (var1 == Integer.MIN_VALUE) {
         throw new IllegalArgumentException("Unknown key! " + this.fenceBlockSet);
      } else {
         class="kw">return var1;
      }
   }

   class="kw">public double getMinHover() {
      class="kw">return this.minHover;
   }

   class="kw">public double getMaxHover() {
      class="kw">return this.maxHover;
   }

   class="kw">public float getHoverFreq() {
      class="kw">return this.hoverFreq;
   }

   class="kw">public double getMinHoverClimb() {
      class="kw">return this.minHoverClimb;
   }

   class="kw">public double getMinHoverDrop() {
      class="kw">return this.minHoverDrop;
   }

   class="kw">public boolean isFloatsDown() {
      class="kw">return this.floatsDown;
   }

   class="kw">public double getMaxWalkSpeedAfterHitMultiplier() {
      class="kw">return this.maxWalkSpeedAfterHitMultiplier;
   }

   class="kw">public double getJumpHeight(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpHeight.get(var1.getExecutionContext());
   }

   class="kw">public double getMinJumpHeight(@Nonnull BuilderSupport var1) {
      class="kw">return this.minJumpHeight.get(var1.getExecutionContext());
   }

   class="kw">public double getMinJumpDistance(@Nonnull BuilderSupport var1) {
      class="kw">return this.minJumpDistance.get(var1.getExecutionContext());
   }

   class="kw">public double getJumpForce(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpForce.get(var1.getExecutionContext());
   }

   class="kw">public double getJumpDescentSteepness(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpDescentSteepness.get(var1.getExecutionContext());
   }

   class="kw">public double getJumpBlending(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpBlending.get(var1.getExecutionContext());
   }

   class="kw">public double getJumpDescentBlending(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpDescentBlending.get(var1.getExecutionContext());
   }

   class="kw">public MotionControllerWalk.DescentAnimationType getDescentAnimationType(BuilderSupport var1) {
      class="kw">return this.descentAnimationType.get(var1.getExecutionContext());
   }

   class="kw">public MotionControllerWalk.AscentAnimationType getAscentAnimationType(BuilderSupport var1) {
      class="kw">return this.ascentAnimationType.get(var1.getExecutionContext());
   }

   class="kw">public double getDescentSteepness(@Nonnull BuilderSupport var1) {
      class="kw">return this.descentSteepness.get(var1.getExecutionContext());
   }

   class="kw">public double getDescentBlending(@Nonnull BuilderSupport var1) {
      class="kw">return this.descentBlending.get(var1.getExecutionContext());
   }

   class="kw">public double getMinDescentAnimationHeight(@Nonnull BuilderSupport var1) {
      class="kw">return this.minDescentAnimationHeight.get(var1.getExecutionContext());
   }

   class="kw">public double[] getJumpRange(@Nonnull BuilderSupport var1) {
      class="kw">return this.jumpRange.get(var1.getExecutionContext());
   }

   @Nonnull
   @Override
   class="kw">public SpawnTestResult canSpawn(@Nonnull SpawningContext var1) {
      if (!var1.isOnSolidGround()) {
         class="kw">return SpawnTestResult.FAIL_NO_POSITION;
      }

      if (var1.movementMode == null) {
         var1.movementMode = var1.breathesInAir ? MovementMode.WALK : MovementMode.UNDERWATER_WALK;
      }

      boolean var2 = var1.waterLevel != -1;
      class="kw">switch (var1.movementMode) {
         case WALK:
            if (var2) {
               class="kw">return SpawnTestResult.FAIL_NO_POSITION;
            }
            break;
         case WADE:
            if (!var2) {
               class="kw">return SpawnTestResult.FAIL_NO_POSITION;
            }

            if (!var1.canBreathe(!var1.enableSafeSpawning || var1.breathesInAir, false)) {
               class="kw">return SpawnTestResult.FAIL_NOT_BREATHABLE;
            }
            break;
         case UNDERWATER_WALK:
            if (!var2) {
               class="kw">return SpawnTestResult.FAIL_NO_POSITION;
            }

            if (!var1.canBreathe(false, !var1.enableSafeSpawning || var1.breathesInWater)) {
               class="kw">return SpawnTestResult.FAIL_NOT_BREATHABLE;
            }
            break;
         class="kw">default:
            throw new IllegalStateException("Unexpected value: " + var1.movementMode);
      }

      if (var1.invalidMaterials == -1) {
         var1.invalidMaterials = 20 + class="kw">switch (var1.movementMode) {
            case WALK -> 10;
            case WADE -> 0;
            case UNDERWATER_WALK -> 1;
            class="kw">default -> throw new IllegalStateException("Unexpected movement mode : " + var1.movementMode);
         };
      }

      class="kw">return var1.validatePosition(var1.invalidMaterials) ? SpawnTestResult.TEST_OK : SpawnTestResult.FAIL_INVALID_POSITION;
   }

   @Override
   class="kw">public boolean requiresSpawnDropHeightCheck(@Nonnull SpawningContext var1) {
      class="kw">return true;
   }

   @Override
   class="kw">public void getMovementModes(
      @Nonnull SpawningContext var1, @Nonnull Set<MovementMode> var2, @Nonnull Set<MovementMode> var3, @Nonnull Set<MovementMode> var4
   ) {
      var2.addAll(MotionControllerWalk.SUPPORTED_MOVEMENT_MODES);
      if (var1.breathesInAir) {
         var3.add(MovementMode.WALK);
         var4.add(MovementMode.WALK);
         var4.add(MovementMode.WADE);
      }

      if (var1.breathesInWater) {
         if (!var1.breathesInAir) {
            var3.add(MovementMode.UNDERWATER_WALK);
         }

         var4.add(MovementMode.UNDERWATER_WALK);
      }
   }

   @Nonnull
   @Override
   class="kw">public Class<? class="kw">extends MotionController> getClassType() {
      class="kw">return MotionControllerWalk.class;
   }

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