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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.function.consumer.QuadConsumer;
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.NearestBlockUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.server.core.asset.type.projectile.config.Projectile;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockCollisionProvider;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockContactData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockTracker;
class="kw">import com.hypixel.hytale.server.core.modules.collision.EntityCollisionProvider;
class="kw">import com.hypixel.hytale.server.core.modules.collision.EntityContactData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.IBlockCollisionConsumer;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.Velocity;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.ForceProvider;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.ForceProviderEntity;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.ForceProviderStandardState;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsBodyState;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsBodyStateUpdater;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsBodyStateUpdaterSymplecticEuler;
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.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 java.util.UUID;
class="kw">import java.util.function.BiConsumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

@Deprecated
class="kw">public class SimplePhysicsProvider class="kw">implements IBlockCollisionConsumer {
   class="kw">protected class="kw">static class="kw">final double HIT_WATER_IMPULSE_LOSS = 0.2;
   class="kw">protected class="kw">static class="kw">final double ROTATION_FORCE = 3.0;
   class="kw">protected class="kw">static class="kw">final float SPEED_ROTATION_FACTOR = 2.0F;
   class="kw">protected class="kw">static class="kw">final double SWIMMING_DAMPING_FACTOR = 1.0;
   class="kw">protected class="kw">static class="kw">final double DEFAULT_MOVE_OUT_OF_SOLID_SPEED = 5.0;
   class="kw">protected class="kw">static class="kw">final int WATER_DETECTION_EXTREMA_COUNT = 2;
   class="kw">protected class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">protected class="kw">final BlockCollisionProvider blockCollisionProvider;
   @Nonnull
   class="kw">protected class="kw">final EntityCollisionProvider entityCollisionProvider;
   @Nonnull
   class="kw">protected class="kw">final BlockTracker triggerTracker;
   @Nonnull
   class="kw">protected class="kw">final RestingSupport restingSupport;
   @Nullable
   class="kw">protected World world;
   @Nonnull
   class="kw">protected class="kw">final Vector3d velocity;
   @Nonnull
   class="kw">protected class="kw">final Vector3d position;
   @Nonnull
   class="kw">protected class="kw">final Vector3d movement;
   class="kw">protected boolean bounced;
   class="kw">protected boolean onGround;
   class="kw">protected boolean provideCharacterCollisions;
   class="kw">protected double gravity;
   class="kw">protected double bounciness;
   class="kw">protected boolean sticksVertically;
   class="kw">protected boolean computeYaw = true;
   class="kw">protected boolean computePitch = true;
   class="kw">protected SimplePhysicsProvider.ROTATION_MODE rotationMode = SimplePhysicsProvider.ROTATION_MODE.VelocityDamped;
   class="kw">protected UUID creatorUuid;
   class="kw">protected class="kw">static class="kw">final double minBounceEpsilon = 0.4;
   class="kw">protected class="kw">static class="kw">final double minBounceEpsilonSquared = 0.16000000000000003;
   class="kw">protected class="kw">final Vector3d tempVector = new Vector3d();
   class="kw">protected BiConsumer<Vector3d, ComponentAccessor<EntityStore>> bounceConsumer;
   class="kw">protected QuadConsumer<Ref<EntityStore>, Vector3d, Ref<EntityStore>, ComponentAccessor<EntityStore>> impactConsumer;
   class="kw">protected double moveOutOfSolidSpeed;
   class="kw">protected boolean movedInsideSolid;
   class="kw">protected class="kw">final Vector3d moveOutOfSolidVelocity = new Vector3d();
   class="kw">protected class="kw">final Vector3i contactBlockPosition = new Vector3i();
   class="kw">protected class="kw">final Vector3d contactPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d contactNormal = new Vector3d();
   class="kw">protected double collisionStart;
   class="kw">protected boolean fallingAfterBreak;
   class="kw">protected class="kw">final PhysicsBodyStateUpdater stateUpdater = new PhysicsBodyStateUpdaterSymplecticEuler();
   class="kw">protected class="kw">final PhysicsBodyState stateBefore = new PhysicsBodyState();
   class="kw">protected class="kw">final PhysicsBodyState stateAfter = new PhysicsBodyState();
   class="kw">protected double displacedMass;
   class="kw">protected double subSurfaceVolume;
   class="kw">protected double enterFluid;
   class="kw">protected double leaveFluid;
   class="kw">protected boolean inFluid;
   class="kw">protected int velocityExtremaCount = Integer.MAX_VALUE;
   @Nonnull
   class="kw">protected SimplePhysicsProvider.STATE state = SimplePhysicsProvider.STATE.Active;
   class="kw">protected ForceProviderEntity forceProviderEntity;
   class="kw">protected ForceProvider[] forceProviders;
   class="kw">protected class="kw">final ForceProviderStandardState forceProviderStandardState = new ForceProviderStandardState();
   class="kw">protected double terminalVelocity1;
   class="kw">protected double density1;
   class="kw">protected double terminalVelocity2;
   class="kw">protected double density2;
   class="kw">protected double dragMultiplier;
   class="kw">protected double dragOffset;
   class="kw">protected class="kw">final BlockTracker fluidTracker = new BlockTracker();
   class="kw">protected double hitWaterImpulseLoss = 0.2;
   class="kw">protected double rotationForce = 3.0;
   class="kw">protected float speedRotationFactor = 2.0F;
   class="kw">protected double swimmingDampingFactor = 1.0;
   @Deprecated(forRemoval = true)
   class="kw">protected BoundingBox boundingBox;

   class="kw">public SimplePhysicsProvider() {
      this.blockCollisionProvider = new BlockCollisionProvider();
      this.blockCollisionProvider.setRequestedCollisionMaterials(6);
      this.blockCollisionProvider.setReportOverlaps(true);
      this.entityCollisionProvider = new EntityCollisionProvider();
      this.triggerTracker = new BlockTracker();
      this.restingSupport = new RestingSupport();
      this.velocity = new Vector3d();
      this.position = new Vector3d();
      this.movement = new Vector3d();
   }

   class="kw">public SimplePhysicsProvider(
      @Nonnull BiConsumer<Vector3d, ComponentAccessor<EntityStore>> var1,
      @Nonnull QuadConsumer<Ref<EntityStore>, Vector3d, Ref<EntityStore>, ComponentAccessor<EntityStore>> var2
   ) {
      this();
      this.bounceConsumer = var1;
      this.impactConsumer = var2;
   }

   class="kw">public void setImpacted(boolean var1) {
      this.state = var1 ? SimplePhysicsProvider.STATE.Inactive : SimplePhysicsProvider.STATE.Active;
   }

   class="kw">public boolean isImpacted() {
      class="kw">return this.state == SimplePhysicsProvider.STATE.Inactive;
   }

   class="kw">public void setResting(boolean var1) {
      if (this.state != SimplePhysicsProvider.STATE.Inactive) {
         this.state = var1 ? SimplePhysicsProvider.STATE.Resting : SimplePhysicsProvider.STATE.Active;
      }
   }

   class="kw">public boolean isResting() {
      class="kw">return this.state == SimplePhysicsProvider.STATE.Resting;
   }

   @Nonnull
   @Override
   class="kw">public IBlockCollisionConsumer.Result onCollision(
      int var1, int var2, int var3, @Nonnull Vector3d var4, @Nonnull BlockContactData var5, @Nonnull BlockData var6, @Nonnull Box var7
   ) {
      BlockMaterial var8 = var6.getBlockType().getMaterial();
      if (this.moveOutOfSolidSpeed > 0.0 && var5.isOverlapping() && var8 == BlockMaterial.Solid) {
         Vector3i var18 = NearestBlockUtil.findNearestBlock(this.position, (var0, var1x) -> {
            WorldChunk var2 = var1x.getChunkIfInMemory(ChunkUtil.indexChunkFromBlock(var0.x(), var0.z()));
            class="kw">return var2 != null && var2.getBlockType(var0).getMaterial() != BlockMaterial.Solid;
         }, this.world);
         boolean var10 = false;
         if (var18 != null) {
            this.tempVector.set(var18.x, var18.y, var18.z);
            this.tempVector.add(0.5, 0.5, 0.5);
            this.tempVector.sub(this.position);
            double var19 = this.tempVector.lengthSquared();
            if (var19 > 1.0E-8) {
               this.tempVector.mul(this.moveOutOfSolidSpeed / Math.sqrt(var19));
               var10 = true;
            }
         }

         if (!var10) {
            this.tempVector.set(0.0, this.moveOutOfSolidSpeed, 0.0);
         }

         this.moveOutOfSolidVelocity.add(this.tempVector);
         this.movedInsideSolid = true;
         class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
      } else if (var6.getFluidId() != 0 && !this.fluidTracker.isTracked(var1, var2, var3)) {
         double var17 = var5.getCollisionStart();
         double var11 = var5.getCollisionEnd();
         if (var17 < this.enterFluid) {
            this.enterFluid = var17;
         }

         if (var11 > this.leaveFluid) {
            this.leaveFluid = var11;
         }

         if (var11 <= var17) {
            class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
         }

         double var13 = 1000.0;
         double var15 = PhysicsMath.volumeOfIntersection(this.boundingBox.getBoundingBox(), this.contactPosition, var7, var1, var2, var3);
         this.subSurfaceVolume += var15;
         this.displacedMass += var15 * var13;
         this.fluidTracker.trackNew(var1, var2, var3);
         class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
      } else {
         if (var5.isOverlapping()) {
            class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
         }

         double var9 = var4.dot(var5.getCollisionNormal());
         if (var8 == BlockMaterial.Solid && var9 == 0.0) {
         }

         if (var9 >= 0.0) {
            class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
         }

         this.contactBlockPosition.set(var1, var2, var3);
         this.contactPosition.set(var5.getCollisionPoint());
         this.contactNormal.set(var5.getCollisionNormal());
         this.collisionStart = var5.getCollisionStart();
         this.bounced = true;
         class="kw">return IBlockCollisionConsumer.Result.STOP;
      }
   }

   @Nonnull
   @Override
   class="kw">public IBlockCollisionConsumer.Result probeCollisionDamage(int var1, int var2, int var3, Vector3d var4, BlockContactData var5, BlockData var6) {
      class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
   }

   @Override
   class="kw">public void onCollisionDamage(int var1, int var2, int var3, Vector3d var4, BlockContactData var5, BlockData var6) {
   }

   @Nonnull
   @Override
   class="kw">public IBlockCollisionConsumer.Result onCollisionSliceFinished() {
      class="kw">return IBlockCollisionConsumer.Result.CONTINUE;
   }

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

   @Nullable
   class="kw">public Ref<EntityStore> tick(
      double var1,
      @Nonnull Velocity var3,
      @Nonnull World var4,
      @Nonnull TransformComponent var5,
      Ref<EntityStore> var6,
      @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      if (this.state == SimplePhysicsProvider.STATE.Inactive) {
         var3.setZero();
         class="kw">return null;
      }

      if (this.state == SimplePhysicsProvider.STATE.Resting) {
         ChunkStore var8 = var4.getChunkStore();
         if (this.forceProviderStandardState.externalForce.lengthSquared() == 0.0 && !this.restingSupport.hasChanged(var8)) {
            class="kw">return null;
         }

         this.state = SimplePhysicsProvider.STATE.Active;
         this.fallingAfterBreak = true;
      }

      this.world = var4;
      this.position.set(var5.getPosition());
      var3.assignVelocityTo(this.velocity);
      double var22 = this.forceProviderEntity.getMass(this.boundingBox.getBoundingBox().getVolume());
      this.forceProviderStandardState.convertToForces(var1, var22);
      this.forceProviderStandardState.updateVelocity(this.velocity);
      if (!(this.velocity.lengthSquared() * var1 * var1 >= 1.0000000000000002E-10) && !(this.forceProviderStandardState.externalForce.lengthSquared() > 0.0)) {
         this.velocity.zero();
      } else {
         this.state = SimplePhysicsProvider.STATE.Active;
      }

      ChunkStore var10 = var4.getChunkStore();
      if (this.state == SimplePhysicsProvider.STATE.Resting && this.restingSupport.hasChanged(var10)) {
         this.state = SimplePhysicsProvider.STATE.Active;
         this.fallingAfterBreak = true;
      }

      this.stateBefore.position.set(this.position);
      this.stateBefore.velocity.set(this.velocity);
      this.forceProviderEntity.setForceProviderStandardState(this.forceProviderStandardState);
      this.stateUpdater.update(this.stateBefore, this.stateAfter, var22, var1, this.onGround, this.forceProviders);
      this.velocity.set(this.stateAfter.velocity);
      this.movement.set(this.velocity).mul(var1);
      if (Double.isFinite(this.movement.x) && Double.isFinite(this.movement.y) && Double.isFinite(this.movement.z)) {
         this.forceProviderStandardState.clear();
         if (this.velocity.lengthSquared() * var1 * var1 >= 1.0000000000000002E-10) {
            this.state = SimplePhysicsProvider.STATE.Active;
         } else {
            this.velocity.zero();
         }

         double var11 = 1.0;
         if (this.provideCharacterCollisions) {
            Ref var13 = null;
            if (this.creatorUuid != null) {
               var13 = var4.getEntityRef(this.creatorUuid);
            }

            var11 = this.entityCollisionProvider.computeNearest(this.boundingBox.getBoundingBox(), this.position, this.movement, var6, var13, var7);
            if (var11 < 0.0 || var11 > 1.0) {
               var11 = 1.0;
            }
         }

         this.bounced = false;
         this.onGround = false;
         this.moveOutOfSolidVelocity.zero();
         this.movedInsideSolid = false;
         this.displacedMass = 0.0;
         this.subSurfaceVolume = 0.0;
         this.enterFluid = Double.MAX_VALUE;
         this.leaveFluid = -Double.MAX_VALUE;
         this.collisionStart = var11;
         this.contactPosition.set(this.position).fma(this.collisionStart, this.movement);
         this.contactNormal.zero();
         this.blockCollisionProvider.cast(var4, this.boundingBox.getBoundingBox(), this.position, this.movement, this, this.triggerTracker, var11);
         this.fluidTracker.reset();
         double var23 = this.displacedMass > 0.0 ? this.displacedMass / this.subSurfaceVolume : 1.2;
         if (this.movedInsideSolid) {
            this.position.fma(var1, this.moveOutOfSolidVelocity);
            this.velocity.set(this.moveOutOfSolidVelocity);
            this.forceProviderStandardState.dragCoefficient = this.getDragCoefficient(var23);
            this.forceProviderStandardState.displacedMass = this.displacedMass;
            this.forceProviderStandardState.gravity = this.gravity;
            this.finishTick(var5, var3);
            class="kw">return null;
         }

         double var15 = this.bounced ? this.collisionStart : 1.0;
         boolean var17 = false;
         if (!this.inFluid && this.enterFluid < this.collisionStart) {
            this.inFluid = true;
            var15 = this.enterFluid;
            this.velocityExtremaCount = 2;
            var17 = true;
         } else if (this.inFluid && this.leaveFluid < this.collisionStart) {
            this.inFluid = false;
            var15 = this.leaveFluid;
            this.velocityExtremaCount = 2;
         }

         if (var15 > 0.0 && var15 < 1.0) {
            this.stateUpdater.update(this.stateBefore, this.stateAfter, var22, var1 * var15, this.onGround, this.forceProviders);
            this.velocity.set(this.stateAfter.velocity);
         }

         if (this.inFluid && this.subSurfaceVolume < this.boundingBox.getBoundingBox().getVolume() && this.velocityExtremaCount > 0) {
            double var18 = this.stateBefore.velocity.y;
            double var20 = this.stateAfter.velocity.y;
            if (var18 * var20 <= 0.0) {
               this.velocityExtremaCount--;
            }
         }

         if (this.isSwimming()) {
            this.forceProviderStandardState.externalForce.y = this.forceProviderStandardState.externalForce.y
               - this.stateAfter.velocity.y * (this.swimmingDampingFactor / var22);
         }

         if (var17) {
            this.forceProviderStandardState.externalImpulse.fma(-this.hitWaterImpulseLoss * var22, this.stateAfter.velocity);
         }

         this.forceProviderStandardState.displacedMass = this.displacedMass;
         this.forceProviderStandardState.dragCoefficient = this.getDragCoefficient(var23);
         this.forceProviderStandardState.gravity = this.gravity;
         if (this.bounced) {
            this.position.set(this.contactPosition);
            computeReflectedVector(this.velocity, this.contactNormal, this.velocity);
            this.velocity.mul(this.bounciness);
            if (this.velocity.lengthSquared() * var1 * var1 < 0.16000000000000003) {
               boolean var25 = this.contactNormal.equals(Vector3dUtil.UP);
               if (this.sticksVertically || var25) {
                  this.state = SimplePhysicsProvider.STATE.Resting;
                  this.restingSupport.rest(var10, this.contactBlockPosition);
                  this.onGround = var25;
                  this.fallingAfterBreak = false;
                  if (this.impactConsumer != null) {
                     this.impactConsumer.accept(var6, this.position, null, var7);
                  }
               }

               this.velocity.zero();
            } else if (this.bounceConsumer != null) {
               this.bounceConsumer.accept(this.position, var7);
            }

            this.rotateBody(var1, var5.getRotation());
            this.finishTick(var5, var3);
            class="kw">return null;
         } else if (this.entityCollisionProvider.getCount() > 0) {
            EntityContactData var24 = this.entityCollisionProvider.getContact(0);
            Ref var19 = var24.getEntityReference();
            this.position.set(var24.getCollisionPoint());
            this.state = SimplePhysicsProvider.STATE.Inactive;
            if (this.impactConsumer != null) {
               this.impactConsumer.accept(var6, this.position, var19, var7);
            }

            this.rotateBody(var1, var5.getRotation());
            this.finishTick(var5, var3);
            class="kw">return var19;
         } else {
            this.position.add(this.movement);
            this.rotateBody(var1, var5.getRotation());
            this.finishTick(var5, var3);
            class="kw">return null;
         }
      } else {
         this.velocity.zero();
         this.movement.zero();
         this.forceProviderStandardState.clear();
         this.finishTick(var5, var3);
         class="kw">return null;
      }
   }

   class="kw">protected void finishTick(@Nonnull TransformComponent var1, @Nonnull Velocity var2) {
      var1.setPosition(this.position);
      var2.set(this.velocity);
      this.world = null;
      this.entityCollisionProvider.clear();
   }

   class="kw">protected void rotateBody(double var1, @Nonnull Rotation3f var3) {
      if (this.isComputeYaw() || this.isComputePitch()) {
         double var4 = this.stateAfter.velocity.x;
         double var6 = this.stateAfter.velocity.z;
         if (var4 * var4 + var6 * var6 <= 1.0000000000000002E-10) {
            if (this.fallingAfterBreak && this.isComputePitch() && this.stateAfter.velocity.y * this.stateAfter.velocity.y > 1.0000000000000002E-10) {
               float var12 = PhysicsMath.pitchFromDirection(var4, this.stateAfter.velocity.y, var6);
               float var13 = var3.pitch();
               float var14 = PhysicsMath.normalizeTurnAngle(var12 - var13);
               float var15 = (float)(this.velocity.lengthSquared() * var1 * this.speedRotationFactor);
               if (var14 > var15) {
                  var14 = var15;
               } else if (var14 < -var15) {
                  var14 = -var15;
               }

               var3.setPitch(var13 + var14);
            }
         } else {
            class="kw">switch (this.rotationMode) {
               case None:
               class="kw">default:
                  break;
               case Velocity:
                  if (this.isComputeYaw()) {
                     var3.setYaw(PhysicsMath.normalizeTurnAngle(PhysicsMath.headingFromDirection(var4, var6)));
                  }

                  if (this.isComputePitch()) {
                     var3.setPitch(PhysicsMath.pitchFromDirection(var4, this.stateAfter.velocity.y, var6));
                  }
                  break;
               case VelocityDamped:
                  if (this.isComputeYaw()) {
                     var3.setYaw(PhysicsMath.normalizeTurnAngle(PhysicsMath.headingFromDirection(var4, var6)));
                  }

                  if (this.isComputePitch()) {
                     float var8 = var3.pitch();
                     float var9 = PhysicsMath.pitchFromDirection(var4, this.velocity.y, var6);
                     float var10 = PhysicsMath.normalizeTurnAngle(var9 - var8);
                     float var11 = (float)(this.velocity.lengthSquared() * var1 * this.speedRotationFactor);
                     if (var10 > var11) {
                        var9 = var8 + var11;
                        var10 = var11;
                     } else if (var10 < -var11) {
                        var9 = var8 - var11;
                        var10 = -var11;
                     }

                     var3.setPitch(var9);
                     this.forceProviderStandardState.externalForce.fma(var10 * -this.rotationForce, this.stateAfter.velocity);
                  }
            }
         }
      }
   }

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

   class="kw">public boolean isSwimming() {
      class="kw">return this.velocityExtremaCount <= 0;
   }

   class="kw">public class="kw">static void computeReflectedVector(@Nonnull Vector3d var0, @Nonnull Vector3d var1, @Nonnull Vector3d var2) {
      var2.set(var0);
      double var3 = var1.lengthSquared();
      if (var3 != 0.0) {
         double var5 = var0.dot(var1) / var3;
         var2.fma(-2.0 * var5, var1);
      }
   }

   class="kw">public boolean isProvidingCharacterCollisions() {
      class="kw">return this.provideCharacterCollisions;
   }

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

   class="kw">public void setGravity(double var1, @Nonnull BoundingBox var3) {
      this.gravity = var1;
      this.recomputeDragFactors(var3);
   }

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

   class="kw">public void setTerminalVelocities(double var1, double var3, @Nonnull BoundingBox var5) {
      this.setTerminalVelocities(var1, 1.2, var3, 998.0, var5);
   }

   class="kw">public void setTerminalVelocities(double var1, double var3, double var5, double var7, @Nonnull BoundingBox var9) {
      this.terminalVelocity1 = var1;
      this.density1 = var3;
      this.terminalVelocity2 = var5;
      this.density2 = var7;
      this.recomputeDragFactors(var9);
   }

   @Nonnull
   @Deprecated
   class="kw">public SimplePhysicsProvider setImpactSlowdown(double var1) {
      class="kw">return this;
   }

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

   class="kw">public boolean isComputeYaw() {
      class="kw">return this.computeYaw;
   }

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

   class="kw">public boolean isComputePitch() {
      class="kw">return this.computePitch;
   }

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

   class="kw">public void setCreatorId(UUID var1) {
      this.creatorUuid = var1;
   }

   class="kw">public void initialize(@Nullable Projectile var1, @Nonnull BoundingBox var2) {
      if (var1 != null) {
         this.boundingBox = var2;
         this.forceProviderEntity = new ForceProviderEntity(var2);
         this.forceProviders = new ForceProvider[]{this.forceProviderEntity};
         this.setGravity(var1.getGravity(), var2);
         double var3 = var1.getTerminalVelocity();
         this.setTerminalVelocities(var3, var3 * var1.getWaterTerminalVelocityMultiplier(), var2);
         this.hitWaterImpulseLoss = var1.getWaterHitImpulseLoss();
         this.rotationForce = var1.getDampingRotation();
         this.speedRotationFactor = (float)var1.getRotationSpeedVelocityRatio();
         this.swimmingDampingFactor = var1.getSwimmingDampingFactor();
         this.rotationMode = var1.getRotationMode();
         this.setBounciness(var1.getBounciness() * (1.0 - var1.getImpactSlowdown()));
         this.setImpactSlowdown(var1.getImpactSlowdown());
         this.setSticksVertically(var1.isSticksVertically());
         this.setComputeYaw(var1.isComputeYaw());
         this.setComputePitch(var1.isComputePitch());
         this.forceProviderEntity.setDensity(var1.getDensity());
      }
   }

   @Nonnull
   class="kw">public Vector3d getVelocity() {
      class="kw">return this.velocity;
   }

   class="kw">public void addVelocity(float var1, float var2, float var3) {
      this.forceProviderStandardState.externalVelocity.add(var1, var2, var3);
   }

   class="kw">public void setVelocity(@Nonnull Vector3d var1) {
      this.forceProviderStandardState.nextTickVelocity.set(var1);
   }

   class="kw">public void setMoveOutOfSolid(boolean var1) {
      this.setMoveOutOfSolid(var1 ? 5.0 : 0.0);
   }

   class="kw">public void setMoveOutOfSolid(double var1) {
      this.moveOutOfSolidSpeed = Math.max(0.0, var1);
   }

   class="kw">protected double getDragCoefficient(double var1) {
      class="kw">return this.dragMultiplier * var1 + this.dragOffset;
   }

   class="kw">protected void recomputeDragFactors(@Nonnull BoundingBox var1) {
      Box var2 = var1.getBoundingBox();
      double var3 = var2.width() * var2.depth();
      double var5 = this.forceProviderEntity.getMass(var2.getVolume());
      double var7 = PhysicsMath.computeDragCoefficient(this.terminalVelocity1, var3, var5, this.gravity);
      double var9 = PhysicsMath.computeDragCoefficient(this.terminalVelocity2, var3, var5, this.gravity);
      this.dragMultiplier = (var9 - var7) / (this.density2 - this.density1);
      this.dragOffset = var7 - this.dragMultiplier * this.density1;
   }

   class="kw">public enum ROTATION_MODE {
      None,
      Velocity,
      VelocityDamped;

      ROTATION_MODE() {
      }
   }

   class="kw">public enum STATE {
      Active,
      Resting,
      Inactive;

      STATE() {
      }
   }
}