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

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
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.component.Store;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.Color;
class="kw">import com.hypixel.hytale.protocol.MovementSettings;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.protocol.packets.entities.ApplyKnockback;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementManager;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionResult;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
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.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
class="kw">import com.hypixel.hytale.server.core.modules.physics.util.PhysicsMath;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.ParticleUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.PositionUtil;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;

class="kw">public class KnockbackPredictionSystems {
   class="kw">public class="kw">static boolean DEBUG_KNOCKBACK_POSITION = false;
   class="kw">public class="kw">static class="kw">final float DEFAULT_BLOCK_DRAG = 0.82F;
   class="kw">public class="kw">static class="kw">final float AIR_DENSITY = 0.001225F;
   class="kw">public class="kw">static class="kw">final float COLLISION_PADDING = 1.0E-4F;
   class="kw">public class="kw">static class="kw">final float MAX_CYCLE_MOVEMENT = 0.25F;
   class="kw">public class="kw">static class="kw">final float TIME_STEP = 0.016666668F;
   class="kw">public class="kw">static class="kw">final int MAX_JUMP_COMBOS = 3;

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

   class="kw">public class="kw">static class CaptureKnockbackInput class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(PlayerInput.getComponentType(), KnockbackSimulation.getComponentType());
      class="kw">private class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(new SystemDependency<>(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class));

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

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return QUERY;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return DEPENDENCIES;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         KnockbackSimulation var6 = var3.getComponent(var2, KnockbackSimulation.getComponentType());
         assert var6 != null;
         PlayerInput var7 = var3.getComponent(var2, PlayerInput.getComponentType());
         assert var7 != null;
         List var8 = var7.getMovementUpdateQueue();
         Vector3d var9 = var6.getClientPosition();
         Vector3d var10 = var6.getClientLastPosition();
         Vector3d var11 = var6.getRelativeMovement();
         var10.set(var9);
         boolean var12 = false;
         if (!var8.isEmpty()) {
            int var13 = 0;

            while (var13 < var8.size()) {
               class="kw">switch ((PlayerInput.InputUpdate)var8.get(var13)) {
                  case PlayerInput.AbsoluteMovement var16:
                     var9.set(var16.getX(), var16.getY(), var16.getZ());
                     var8.remove(var13);
                     break;
                  case PlayerInput.RelativeMovement var17:
                     var9.add(var17.getX(), var17.getY(), var17.getZ());
                     var8.remove(var13);
                     break;
                  case PlayerInput.WishMovement var18:
                     var12 = true;
                     var11.set(var18.getX(), var18.getY(), var18.getZ());
                     var8.remove(var13);
                     break;
                  case PlayerInput.SetMovementStates var19:
                     MovementStates var20 = var19.movementStates();
                     if (var20.jumping) {
                        var6.setWasJumping(true);
                     }

                     var6.setClientMovementStates(var20);
                     var8.remove(var13);
                     break;
                  case null:
                  class="kw">default:
                     var13++;
               }
            }

            if (!var12) {
               var11.set(var9).sub(var10);
               if (var6.hadWishMovement()) {
                  var6.setClientFinished(true);
               }
            } else {
               var6.setHadWishMovement(true);
            }
         }
      }
   }

   class="kw">public class="kw">static class ClearOnRemove class="kw">extends RefSystem<EntityStore> {
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, KnockbackSimulation> KNOCKBACK_SIMULATION_COMPONENT_TYPE = KnockbackSimulation.getComponentType();

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

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return KNOCKBACK_SIMULATION_COMPONENT_TYPE;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         var3.removeComponent(var1, KNOCKBACK_SIMULATION_COMPONENT_TYPE);
      }
   }

   class="kw">public class="kw">static class ClearOnTeleport class="kw">extends RefChangeSystem<EntityStore, Teleport> {
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, Teleport> TELEPORT_COMPONENT_TYPE = Teleport.getComponentType();
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, KnockbackSimulation> KNOCKBACK_SIMULATION_COMPONENT_TYPE = KnockbackSimulation.getComponentType();

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

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return KNOCKBACK_SIMULATION_COMPONENT_TYPE;
      }

      @Nonnull
      @Override
      class="kw">public ComponentType<EntityStore, Teleport> componentType() {
         class="kw">return TELEPORT_COMPONENT_TYPE;
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull Teleport var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         var4.removeComponent(var1, KNOCKBACK_SIMULATION_COMPONENT_TYPE);
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1, Teleport var2, @Nonnull Teleport var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull Teleport var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }
   }

   class="kw">private enum CollisionAxis {
      X,
      Y,
      Z;

      CollisionAxis() {
      }
   }

   class="kw">public class="kw">static class InitKnockback class="kw">extends RefChangeSystem<EntityStore, KnockbackSimulation> {
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         Player.getComponentType(), TransformComponent.getComponentType(), KnockbackSimulation.getComponentType(), MovementStatesComponent.getComponentType()
      );

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

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return QUERY;
      }

      @Nonnull
      @Override
      class="kw">public ComponentType<EntityStore, KnockbackSimulation> componentType() {
         class="kw">return KnockbackSimulation.getComponentType();
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull KnockbackSimulation var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         TransformComponent var5 = var4.getComponent(var1, TransformComponent.getComponentType());
         assert var5 != null;
         var2.getClientPosition().set(var5.getPosition());
         var2.getSimPosition().set(var5.getPosition());
         MovementStatesComponent var6 = var4.getComponent(var1, MovementStatesComponent.getComponentType());
         assert var6 != null;
         var2.setClientMovementStates(new MovementStates(var6.getMovementStates()));
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         KnockbackSimulation var2,
         @Nonnull KnockbackSimulation var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull KnockbackSimulation var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         Player var5 = var4.getComponent(var1, Player.getComponentType());
         assert var5 != null;
         Vector3d var6 = var2.getClientPosition();
         var5.moveTo(var1, var6.x, var6.y, var6.z, var4);
         MovementStatesComponent var7 = var4.getComponent(var1, MovementStatesComponent.getComponentType());
         assert var7 != null;
         var7.setMovementStates(var2.getClientMovementStates());
      }
   }

   @Deprecated
   class="kw">public class="kw">static class SimulateKnockback class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, BoundingBox> BOUNDING_BOX_COMPONENT_TYPE = BoundingBox.getComponentType();
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         Player.getComponentType(),
         TransformComponent.getComponentType(),
         KnockbackSimulation.getComponentType(),
         BOUNDING_BOX_COMPONENT_TYPE,
         MovementStatesComponent.getComponentType(),
         MovementManager.getComponentType(),
         PlayerRef.getComponentType()
      );
      class="kw">private class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(new SystemDependency<>(Order.AFTER, PlayerSystems.ProcessPlayerInput.class));

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

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return QUERY;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return DEPENDENCIES;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         KnockbackSimulation var6 = var3.getComponent(var2, KnockbackSimulation.getComponentType());
         assert var6 != null;
         TransformComponent var7 = var3.getComponent(var2, TransformComponent.getComponentType());
         assert var7 != null;
         Player var8 = var3.getComponent(var2, Player.getComponentType());
         assert var8 != null;
         World var9 = var4.getExternalData().getWorld();
         float var10 = var6.getRemainingTime();
         var10 -= var1;
         var6.setRemainingTime(var10);
         if (!(var10 < 0.0F) && !var3.getArchetype().contains(DeathComponent.getComponentType())) {
            if (KnockbackPredictionSystems.DEBUG_KNOCKBACK_POSITION) {
               Vector3d var11 = var6.getClientPosition();
               SpatialResource var12 = var4.getResource(EntityModule.get().getPlayerSpatialResourceType());
               List var13 = SpatialResource.getThreadLocalReferenceList();
               var12.getSpatialStructure().collect(var11, 75.0, var13);
               Color var14 = var6.hadWishMovement() ? new Color((byte)-1, (byte)0, (byte)0) : new Color((byte)0, (byte)0, (byte)-1);
               ParticleUtil.spawnParticleEffect("Example_Simple", var11, 0.0F, 0.0F, 0.0F, 1.0F, var14, var13, var5);
            }

            var6.setTickBuffer(var6.getTickBuffer() + var1);
            MovementStates var29 = var6.getClientMovementStates();

            while (var6.getTickBuffer() >= 0.016666668F) {
               var6.setTickBuffer(var6.getTickBuffer() - 0.016666668F);
               Vector3d var30 = var6.getRelativeMovement();
               Vector3d var31 = var6.getRequestedVelocity();
               Vector3d var32 = var6.getSimPosition();
               Vector3d var15 = var6.getSimVelocity();
               MovementStatesComponent var16 = var3.getComponent(var2, MovementStatesComponent.getComponentType());
               assert var16 != null;
               MovementStates var17 = var16.getMovementStates();
               MovementManager var18 = var3.getComponent(var2, MovementManager.getComponentType());
               assert var18 != null;
               MovementSettings var19 = var18.getSettings();
               BoundingBox var20 = var3.getComponent(var2, BOUNDING_BOX_COMPONENT_TYPE);
               assert var20 != null;
               Box var21 = var20.getBoundingBox();
               if (var29.flying) {
                  var6.setRemainingTime(0.0F);
                  class="kw">return;
               }

               if (var29.climbing && !var29.onGround) {
                  var6.setRemainingTime(0.0F);
                  class="kw">return;
               }

               if (var29.swimming) {
                  var6.setRemainingTime(0.0F);
                  class="kw">return;
               }

               int var22 = var19.invertedGravity ? 1 : -1;
               double var23 = var22 * PhysicsMath.getTerminalVelocity(var19.mass, 0.001225F, Math.abs(var21.width() * var21.depth()), var19.dragCoefficient);
               double var25 = PhysicsMath.getAcceleration(var15.y, var23) * 0.016666668F;
               if (var15.y < var23 && var25 > 0.0) {
                  var15.y = Math.min(var15.y + var25, var23);
               } else if (var15.y > var23 && var25 < 0.0) {
                  var15.y = Math.max(var15.y + var25, var23);
               }

               if (var17.onGround) {
                  var17.falling = false;
                  if (var6.wasOnGround() && var6.consumeWasJumping()) {
                     var15.y = var19.jumpForce;
                     var17.onGround = false;
                     var6.setJumpCombo(Math.min(var6.getJumpCombo() + 1, 3));
                  }
               } else {
                  Vector3d var27 = new Vector3d(var32);
                  var27.y += 0.1F;
                  var17.falling = var15.y < 0.0 && CollisionModule.get().validatePosition(var9, var21, var27, new CollisionResult()) != 0;
                  if (var17.falling) {
                     var17.jumping = false;
                     var17.swimJumping = false;
                  }
               }

               if (var6.getJumpCombo() != 0 && (var17.onGround && var6.wasOnGround() || var15.x == 0.0 || var15.z == 0.0)) {
                  var6.setJumpCombo(0);
               }

               float var33 = this.computeMoveForce(var6, var17, var19);
               if (!var17.flying && var6.getRequestedVelocityChangeType() != null) {
                  class="kw">switch (var6.getRequestedVelocityChangeType()) {
                     case Add:
                        var15.add(var31.x * 0.18F * var19.velocityResistance, var31.y, var31.z * 0.18F * var19.velocityResistance);
                        break;
                     case Set:
                        var15.set(var31);
                  }

                  PlayerRef var34 = var3.getComponent(var2, PlayerRef.getComponentType());
                  assert var34 != null;
                  var34.getPacketHandler()
                     .write(
                        new ApplyKnockback(
                           PositionUtil.toPositionPacket(var7.getPosition()),
                           (float)var31.x,
                           (float)var31.y,
                           (float)var31.z,
                           var6.getRequestedVelocityChangeType()
                        )
                     );
               }

               var31.zero();
               var6.setRequestedVelocityChangeType(null);
               Vector3d var35 = var6.getMovementOffset();
               var35.zero();
               if (var6.hadWishMovement()) {
                  float var24 = this.convertWishMovement(var6, var17, var19);
                  var15.fma(var24, var30);
               } else {
                  var35.fma(var33, var30);
                  var30.zero();
               }

               var35.fma(0.016666668F, var15);
               this.applyMovementOffset(var9, var21, var6, var17, var35);
               Ref var36 = var3.getReferenceTo(var2);
               if (var10 < 0.2F) {
                  Vector3d var37 = var6.getClientPosition().lerp(var32, var10 / 0.2F, new Vector3d());
                  var8.moveTo(var36, var37.x, var37.y, var37.z, var5);
               } else {
                  var8.moveTo(var36, var32.x, var32.y, var32.z, var5);
               }
            }
         } else {
            var5.removeComponent(var3.getReferenceTo(var2), KnockbackSimulation.getComponentType());
         }
      }

      class="kw">private float convertWishMovement(@Nonnull KnockbackSimulation var1, @Nonnull MovementStates var2, @Nonnull MovementSettings var3) {
         MovementStates var4 = var1.getClientMovementStates();
         if (var4 == null) {
            var4 = var2;
         }

         Vector3d var5 = var1.getSimVelocity();
         float var6 = (float)Math.sqrt(var5.x * var5.x + var5.z * var5.z);
         float var7 = 0.0F;
         float var8 = 1.0F;
         if (!var2.flying && !var2.climbing) {
            var7 = !var2.onGround && !var2.swimming
               ? convertToNewRange(var6, var3.airDragMinSpeed, var3.airDragMaxSpeed, var3.airDragMin, var3.airDragMax)
               : 0.82F;
            var8 = !var2.onGround && !var2.swimming
               ? convertToNewRange(var6, var3.airFrictionMinSpeed, var3.airFrictionMaxSpeed, var3.airFrictionMax, var3.airFrictionMin)
               : 1.0F - var7;
         }

         float var9 = 0.0F;
         float var10 = 1.0F;
         if (!var4.flying && !var4.climbing) {
            var9 = !var4.onGround && !var4.swimming
               ? convertToNewRange(var6, var3.airDragMinSpeed, var3.airDragMaxSpeed, var3.airDragMin, var3.airDragMax)
               : 0.82F;
            var10 = !var4.onGround && !var4.swimming
               ? convertToNewRange(var6, var3.airFrictionMinSpeed, var3.airFrictionMaxSpeed, var3.airFrictionMax, var3.airFrictionMin)
               : 1.0F - var9;
         }

         class="kw">return var8 / var10;
      }

      class="kw">private float computeMoveForce(@Nonnull KnockbackSimulation var1, @Nonnull MovementStates var2, @Nonnull MovementSettings var3) {
         float var4 = 0.0F;
         float var5 = 1.0F;
         Vector3d var6 = var1.getSimVelocity();
         float var7 = (float)Math.sqrt(var6.x * var6.x + var6.z * var6.z);
         if (!var2.flying && !var2.climbing) {
            var4 = !var2.onGround && !var2.swimming
               ? convertToNewRange(var7, var3.airDragMinSpeed, var3.airDragMaxSpeed, var3.airDragMin, var3.airDragMax)
               : 0.82F;
            var5 = !var2.onGround && !var2.swimming
               ? convertToNewRange(var7, var3.airFrictionMinSpeed, var3.airFrictionMaxSpeed, var3.airFrictionMax, var3.airFrictionMin) / (1.0F - var4)
               : 1.0F;
         }

         var6.x *= var4;
         var6.z *= var4;
         class="kw">return var5;
      }

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

      class="kw">public void applyMovementOffset(
         @Nonnull World var1, @Nonnull Box var2, @Nonnull KnockbackSimulation var3, @Nonnull MovementStates var4, @Nonnull Vector3d var5
      ) {
         int var6 = (int)Math.ceil(var5.length() / 0.25);
         Vector3d var7 = var6 == 1 ? var5 : new Vector3d(var5).mul(1.0F / var6);
         var3.setWasOnGround(var4.onGround);

         for (int var8 = 0; var8 < var6; var8++) {
            this.doMoveCycle(var1, var2, var3, var4, var7);
         }

         if (var4.onGround) {
            var3.getSimVelocity().y = 0.0;
         }
      }

      class="kw">private void doMoveCycle(@Nonnull World var1, @Nonnull Box var2, @Nonnull KnockbackSimulation var3, @Nonnull MovementStates var4, @Nonnull Vector3d var5) {
         Vector3d var6 = var3.getSimPosition();
         Vector3d var7 = var3.getSimVelocity();
         Vector3d var8 = var3.getCheckPosition();
         var8.set(var6);
         CollisionResult var9 = var3.getCollisionResult();
         var9.reset();
         var8.y = var8.y + var5.y;
         boolean var10 = this.checkCollision(var3, var1, var2, var8, var5, KnockbackPredictionSystems.CollisionAxis.Y, var9);
         if (var4.onGround && var5.y < 0.0) {
            if (!var10) {
               var4.onGround = false;
            } else {
               var8.y = var8.y - var5.y;
            }
         } else if (var10) {
            if (var5.y <= 0.0) {
               var4.onGround = true;
               var8.y = var8.y - var5.y;
            } else {
               var4.onGround = false;
               var8.y = var8.y - var5.y;
            }

            var7.y = 0.0;
         } else {
            var4.onGround = false;
         }

         if (var5.x != 0.0) {
            var8.x = var8.x + var5.x;
            var9.reset();
            boolean var11 = this.checkCollision(var3, var1, var2, var8, var5, KnockbackPredictionSystems.CollisionAxis.Y, var9);
            if (var11) {
               var8.x = var8.x - var5.x;
            }
         }

         if (var5.z != 0.0) {
            var8.z = var8.z + var5.z;
            var9.reset();
            boolean var12 = this.checkCollision(var3, var1, var2, var8, var5, KnockbackPredictionSystems.CollisionAxis.Y, var9);
            if (var12) {
               var8.z = var8.z - var5.z;
            }
         }

         var6.set(var8);
      }

      class="kw">private boolean checkCollision(
         @Nonnull KnockbackSimulation var1,
         @Nonnull World var2,
         @Nonnull Box var3,
         @Nonnull Vector3d var4,
         Vector3d var5,
         KnockbackPredictionSystems.CollisionAxis var6,
         @Nonnull CollisionResult var7
      ) {
         Vector3d var8 = var1.getTempPosition();
         var8.set(var4);
         var8.add(0.0, 1.0E-4F, 0.0);
         class="kw">return CollisionModule.get().validatePosition(var2, var3, var8, var7) != 0;
      }
   }
}