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

class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
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.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionChain;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.meta.DynamicMetaStore;
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.EntityRefCollisionProvider;
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.interaction.InteractionModule;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.client.SimpleBlockInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.physics.RestingSupport;
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.modules.projectile.ProjectileModule;
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.EntityStore;
class="kw">import java.util.UUID;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;
class="kw">import org.joml.Vector4d;

class="kw">public class StandardPhysicsProvider class="kw">implements IBlockCollisionConsumer, Component<EntityStore> {
   class="kw">public class="kw">static class="kw">final int WATER_DETECTION_EXTREMA_COUNT = 2;
   class="kw">public class="kw">static class="kw">final double MIN_BOUNCE_EPSILON = 0.4;
   class="kw">public class="kw">static class="kw">final double MIN_BOUNCE_EPSILON_SQUARED = 0.16000000000000003;
   @Nonnull
   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 EntityRefCollisionProvider 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 class="kw">final Vector3d nextMovement = new Vector3d();
   class="kw">protected boolean bounced;
   class="kw">protected int bounces = 0;
   @Nullable
   class="kw">protected Vector3i bounceBlockPosition;
   class="kw">protected boolean onGround;
   class="kw">protected boolean provideCharacterCollisions = true;
   @Nullable
   class="kw">protected class="kw">final UUID creatorUuid;
   @Nonnull
   class="kw">protected class="kw">final StandardPhysicsConfig physicsConfig;
   class="kw">protected class="kw">final Vector3d tempVector = new Vector3d();
   @Nullable
   class="kw">protected BounceConsumer bounceConsumer;
   @Nullable
   class="kw">protected ImpactConsumer impactConsumer;
   class="kw">protected boolean movedInsideSolid;
   class="kw">protected class="kw">final Vector3d moveOutOfSolidVelocity = new Vector3d();
   class="kw">protected class="kw">final Vector3d contactPosition = new Vector3d();
   class="kw">protected class="kw">final Vector3d contactNormal = new Vector3d();
   class="kw">protected int contactBlockX;
   class="kw">protected int contactBlockY;
   class="kw">protected int contactBlockZ;
   class="kw">protected boolean contactBlockRecorded;
   class="kw">protected boolean fallingAfterBreak;
   class="kw">protected double collisionStart;
   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 StandardPhysicsProvider.STATE state = StandardPhysicsProvider.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 dragMultiplier;
   class="kw">protected double dragOffset;
   class="kw">protected class="kw">final BlockTracker fluidTracker = new BlockTracker();
   class="kw">protected boolean isSliding;
   @Deprecated(forRemoval = true)
   class="kw">protected BoundingBox boundingBox;

   @Nonnull
   class="kw">public class="kw">static ComponentType<EntityStore, StandardPhysicsProvider> getComponentType() {
      class="kw">return ProjectileModule.get().getStandardPhysicsProviderComponentType();
   }

   class="kw">public StandardPhysicsProvider(@Nonnull BoundingBox var1, @Nullable UUID var2, @Nonnull StandardPhysicsConfig var3, @Nonnull Vector3d var4, boolean var5) {
      this.creatorUuid = var2;
      this.physicsConfig = var3;
      this.blockCollisionProvider = new BlockCollisionProvider();
      this.blockCollisionProvider.setRequestedCollisionMaterials(6);
      this.blockCollisionProvider.setReportOverlaps(true);
      this.entityCollisionProvider = new EntityRefCollisionProvider();
      this.triggerTracker = new BlockTracker();
      this.restingSupport = new RestingSupport();
      this.velocity = new Vector3d();
      this.position = new Vector3d();
      this.movement = new Vector3d();
      this.boundingBox = var1;
      this.forceProviderEntity = new ForceProviderEntity(var1);
      this.forceProviderEntity.setDensity(var3.density);
      this.forceProviders = new ForceProvider[]{this.forceProviderEntity};
      this.forceProviderStandardState.nextTickVelocity.set(var4);
      this.recomputeDragFactors(var1);
      if (!var5) {
         this.impactConsumer = (var2x, var3x, var4x, var5x, var6, var7) -> {
            if (var2 != null) {
               Ref var8 = var7.getExternalData().getRefFromUUID(var2);
               if (var8 != null && var8.isValid()) {
                  InteractionManager var9 = var7.getComponent(var8, InteractionModule.get().getInteractionManagerComponent());
                  if (var9 == null) {
                     var7.removeEntity(var2x, RemoveReason.REMOVE);
                  } else {
                     InteractionContext var10 = InteractionContext.forProxyEntity(var9, var8, var2x, var7);
                     DynamicMetaStore var11 = var10.getMetaStore();
                     BlockPosition var12 = var4x != null ? new BlockPosition(var4x.x, var4x.y, var4x.z) : this.getContactBlock();
                     if (var12 == null) {
                        var12 = new BlockPosition((int)var3x.x, (int)var3x.y, (int)var3x.z);
                     }

                     World var13 = var7.getExternalData().getWorld();
                     var11.putMetaObject(Interaction.TARGET_ENTITY, var5x);
                     var11.putMetaObject(Interaction.HIT_LOCATION, new Vector4d(var3x.x, var3x.y, var3x.z, 1.0));
                     var11.putMetaObject(Interaction.HIT_DETAIL, var6);
                     var11.putMetaObject(Interaction.TARGET_BLOCK_RAW, var12);
                     var11.putMetaObject(Interaction.TARGET_BLOCK, SimpleBlockInteraction.resolveBaseBlockPosition(var13, var12));
                     InteractionType var14 = var5x != null ? InteractionType.ProjectileHit : InteractionType.ProjectileMiss;
                     String var15 = var10.getRootInteractionId(var14);
                     if (var15 != null) {
                        RootInteraction var16 = RootInteraction.getRootInteractionOrUnknown(var15);
                        if (var16 != null) {
                           InteractionChain var17 = var9.initChain(var14, var10, var16, true);
                           var9.queueExecuteChain(var17);
                        }
                     }
                  }
               } else {
                  var7.removeEntity(var2x, RemoveReason.REMOVE);
               }
            }
         };
         this.bounceConsumer = (var1x, var2x, var3x) -> {
            if (var2 != null) {
               Ref var4 = var3x.getExternalData().getRefFromUUID(var2);
               if (var4 != null && var4.isValid()) {
                  InteractionManager var5 = var3x.getComponent(var4, InteractionModule.get().getInteractionManagerComponent());
                  if (var5 == null) {
                     var3x.removeEntity(var1x, RemoveReason.REMOVE);
                  } else {
                     InteractionContext var6 = InteractionContext.forProxyEntity(var5, var4, var1x, var3x);
                     var6.getMetaStore().putMetaObject(Interaction.HIT_LOCATION, new Vector4d(var2x.x, var2x.y, var2x.z, 1.0));
                     InteractionType var7 = InteractionType.ProjectileBounce;
                     String var8 = var6.getRootInteractionId(var7);
                     if (var8 != null) {
                        RootInteraction var9 = RootInteraction.getRootInteractionOrUnknown(var8);
                        if (var9 != null) {
                           InteractionChain var10 = var5.initChain(var7, var6, var9, true);
                           var5.queueExecuteChain(var10);
                        }
                     }
                  }
               } else {
                  var3x.removeEntity(var1x, RemoveReason.REMOVE);
               }
            }
         };
      }
   }

   @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.physicsConfig.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 var20 = this.tempVector.lengthSquared();
            if (var20 > 1.0E-8) {
               this.tempVector.mul(this.physicsConfig.moveOutOfSolidSpeed / Math.sqrt(var20));
               var10 = true;
            }
         }

         if (!var10) {
            this.tempVector.set(0.0, this.physicsConfig.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 var19 = var5.getCollisionEnd();
         if (var17 < this.enterFluid) {
            this.enterFluid = var17;
         }

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

         if (var19 <= 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.contactPosition.set(var5.getCollisionPoint());
         this.contactNormal.set(var5.getCollisionNormal());
         if (this.physicsConfig.allowRolling) {
            Vector3d var11 = new Vector3d(this.stateBefore.position).add(this.movement).sub(this.contactPosition);
            if (!var11.equals(Vector3dUtil.ZERO)) {
               double var12 = var11.dot(this.contactNormal);
               this.nextMovement.set(var11);
               this.nextMovement.fma(-var12, this.contactNormal);
               this.isSliding = true;
            }
         }

         this.contactBlockX = var1;
         this.contactBlockY = var2;
         this.contactBlockZ = var3;
         this.contactBlockRecorded = true;
         this.collisionStart = var5.getCollisionStart();
         this.bounced = true;
         this.bounceBlockPosition = new Vector3i(var1, var2, var3);
         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() {
   }

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

   class="kw">public void rotateBody(double var1, @Nonnull Rotation3f var3) {
      if (this.physicsConfig.computeYaw || this.physicsConfig.computePitch) {
         double var4 = this.stateAfter.velocity.x;
         double var6 = this.stateAfter.velocity.z;
         double var8 = var4 * var4 + var6 * var6;
         if (!Double.isNaN(var8)) {
            if (var8 <= 1.0000000000000002E-10) {
               if (this.fallingAfterBreak
                  && this.physicsConfig.computePitch
                  && this.stateAfter.velocity.y * this.stateAfter.velocity.y > 1.0000000000000002E-10) {
                  float var14 = PhysicsMath.pitchFromDirection(var4, this.stateAfter.velocity.y, var6);
                  float var15 = var3.pitch();
                  float var16 = PhysicsMath.normalizeTurnAngle(var14 - var15);
                  float var17 = (float)(this.velocity.lengthSquared() * var1 * this.physicsConfig.speedRotationFactor);
                  if (var16 > var17) {
                     var16 = var17;
                  } else if (var16 < -var17) {
                     var16 = -var17;
                  }

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

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

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

                        var3.setPitch(var11);
                        this.forceProviderStandardState.externalForce.fma(var12 * -this.physicsConfig.rotationForce, this.stateAfter.velocity);
                     }
                     break;
                  case VelocityRoll:
                     var3.setYaw(PhysicsMath.normalizeTurnAngle(PhysicsMath.headingFromDirection(var4, var6)));
                     var3.setPitch(var3.pitch() - (float)this.stateBefore.velocity.length() * this.physicsConfig.rollingSpeed);
               }
            }
         }
      }
   }

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

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

   class="kw">public 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.physicsConfig.terminalVelocityAir, var3, var5, this.physicsConfig.gravity);
      double var9 = PhysicsMath.computeDragCoefficient(this.physicsConfig.terminalVelocityWater, var3, var5, this.physicsConfig.gravity);
      this.dragMultiplier = (var9 - var7) / (this.physicsConfig.densityWater - this.physicsConfig.densityAir);
      this.dragOffset = var7 - this.dragMultiplier * this.physicsConfig.densityAir;
   }

   @Nonnull
   class="kw">public StandardPhysicsProvider.STATE getState() {
      class="kw">return this.state;
   }

   class="kw">public void setState(@Nonnull StandardPhysicsProvider.STATE var1) {
      this.state = var1;
   }

   @Nonnull
   class="kw">public StandardPhysicsConfig getPhysicsConfig() {
      class="kw">return this.physicsConfig;
   }

   @Nonnull
   class="kw">public ForceProviderStandardState getForceProviderStandardState() {
      class="kw">return this.forceProviderStandardState;
   }

   @Nonnull
   class="kw">public RestingSupport getRestingSupport() {
      class="kw">return this.restingSupport;
   }

   class="kw">public void setWorld(@Nullable World var1) {
      this.world = var1;
   }

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

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

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

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

   @Nonnull
   class="kw">public ForceProviderEntity getForceProviderEntity() {
      class="kw">return this.forceProviderEntity;
   }

   @Nonnull
   class="kw">public ForceProvider[] getForceProviders() {
      class="kw">return this.forceProviders;
   }

   @Nonnull
   class="kw">public PhysicsBodyStateUpdater getStateUpdater() {
      class="kw">return this.stateUpdater;
   }

   @Nonnull
   class="kw">public PhysicsBodyState getStateBefore() {
      class="kw">return this.stateBefore;
   }

   @Nonnull
   class="kw">public PhysicsBodyState getStateAfter() {
      class="kw">return this.stateAfter;
   }

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

   @Nullable
   class="kw">public UUID getCreatorUuid() {
      class="kw">return this.creatorUuid;
   }

   @Nonnull
   class="kw">public EntityRefCollisionProvider getEntityCollisionProvider() {
      class="kw">return this.entityCollisionProvider;
   }

   class="kw">public boolean isBounced() {
      class="kw">return this.bounced;
   }

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

   class="kw">public int getBounces() {
      class="kw">return this.bounces;
   }

   class="kw">public void incrementBounces() {
      this.bounces++;
   }

   @Nullable
   class="kw">public Vector3i bounceBlockPosition() {
      class="kw">return this.bounceBlockPosition;
   }

   class="kw">public void clearBounced() {
      this.bounceBlockPosition = null;
      this.bounced = false;
   }

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

   class="kw">public boolean isMovedInsideSolid() {
      class="kw">return this.movedInsideSolid;
   }

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

   @Nullable
   class="kw">public BlockPosition getContactBlock() {
      class="kw">return this.contactBlockRecorded ? new BlockPosition(this.contactBlockX, this.contactBlockY, this.contactBlockZ) : null;
   }

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

   class="kw">public double getDisplacedMass() {
      class="kw">return this.displacedMass;
   }

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

   class="kw">public double getSubSurfaceVolume() {
      class="kw">return this.subSurfaceVolume;
   }

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

   class="kw">public double getEnterFluid() {
      class="kw">return this.enterFluid;
   }

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

   class="kw">public double getLeaveFluid() {
      class="kw">return this.leaveFluid;
   }

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

   class="kw">public double getCollisionStart() {
      class="kw">return this.collisionStart;
   }

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

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

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

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

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

   @Nonnull
   class="kw">public BlockCollisionProvider getBlockCollisionProvider() {
      class="kw">return this.blockCollisionProvider;
   }

   @Nonnull
   class="kw">public BlockTracker getTriggerTracker() {
      class="kw">return this.triggerTracker;
   }

   @Nonnull
   class="kw">public BlockTracker getFluidTracker() {
      class="kw">return this.fluidTracker;
   }

   class="kw">public boolean isInFluid() {
      class="kw">return this.inFluid;
   }

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

   class="kw">public int getVelocityExtremaCount() {
      class="kw">return this.velocityExtremaCount;
   }

   class="kw">public void setVelocityExtremaCount(int var1) {
      this.velocityExtremaCount = var1;
   }

   class="kw">public void decrementVelocityExtremaCount() {
      this.velocityExtremaCount--;
   }

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

   @Nullable
   class="kw">public ImpactConsumer getImpactConsumer() {
      class="kw">return this.impactConsumer;
   }

   class="kw">public void setImpactConsumer(@Nullable ImpactConsumer var1) {
      this.impactConsumer = var1;
   }

   @Nullable
   class="kw">public BounceConsumer getBounceConsumer() {
      class="kw">return this.bounceConsumer;
   }

   class="kw">public void setBounceConsumer(@Nullable BounceConsumer var1) {
      this.bounceConsumer = var1;
   }

   @Nonnull
   @Override
   class="kw">public Component<EntityStore> clone() {
      class="kw">return this;
   }

   class="kw">public enum STATE {
      ACTIVE,
      RESTING,
      INACTIVE;

      STATE() {
      }
   }
}