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

class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Ref;
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.OrderPriority;
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.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockCollisionProvider;
class="kw">import com.hypixel.hytale.server.core.modules.collision.BlockTracker;
class="kw">import com.hypixel.hytale.server.core.modules.collision.EntityContactData;
class="kw">import com.hypixel.hytale.server.core.modules.collision.EntityRefCollisionProvider;
class="kw">import com.hypixel.hytale.server.core.modules.collision.TangiableEntitySpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.TransformSystems;
class="kw">import com.hypixel.hytale.server.core.modules.physics.RestingSupport;
class="kw">import com.hypixel.hytale.server.core.modules.physics.SimplePhysicsProvider;
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.projectile.config.StandardPhysicsConfig;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.config.StandardPhysicsProvider;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
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.Set;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class StandardPhysicsTickSystem class="kw">extends EntityTickingSystem<EntityStore> {
   @Nonnull
   class="kw">private class="kw">final Query<EntityStore> query = Query.and(
      StandardPhysicsProvider.getComponentType(),
      TransformComponent.getComponentType(),
      HeadRotation.getComponentType(),
      Velocity.getComponentType(),
      BoundingBox.getComponentType()
   );
   @Nonnull
   class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
      new SystemDependency<>(Order.AFTER, TangiableEntitySpatialSystem.class, OrderPriority.CLOSEST),
      new SystemDependency<>(Order.BEFORE, TransformSystems.EntityTrackerUpdate.class)
   );

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

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

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

   @Override
   class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5) {
      TimeResource var6 = var4.getResource(TimeResource.getResourceType());
      float var7 = var6.getTimeDilationModifier();
      World var8 = var4.getExternalData().getWorld();
      var1 = 1.0F / var8.getTps();
      var1 *= var7;
      StandardPhysicsProvider var9 = var3.getComponent(var2, StandardPhysicsProvider.getComponentType());
      assert var9 != null;
      Velocity var10 = var3.getComponent(var2, Velocity.getComponentType());
      assert var10 != null;
      TransformComponent var11 = var3.getComponent(var2, TransformComponent.getComponentType());
      assert var11 != null;
      BoundingBox var12 = var3.getComponent(var2, BoundingBox.getComponentType());
      assert var12 != null;
      StandardPhysicsConfig var13 = var9.getPhysicsConfig();
      Ref var14 = var3.getReferenceTo(var2);
      if (var9.getState() == StandardPhysicsProvider.STATE.INACTIVE) {
         var10.setZero();
      } else {
         ForceProviderStandardState var15 = var9.getForceProviderStandardState();
         RestingSupport var16 = var9.getRestingSupport();
         if (var9.getState() == StandardPhysicsProvider.STATE.RESTING) {
            ChunkStore var17 = var8.getChunkStore();
            if (var15.externalForce.lengthSquared() == 0.0 && !var16.hasChanged(var17)) {
               class="kw">return;
            }

            var9.setState(StandardPhysicsProvider.STATE.ACTIVE);
            var9.setFallingAfterBreak(true);
         }

         Vector3d var54 = var9.getPosition();
         Vector3d var18 = var9.getVelocity();
         Vector3d var19 = var9.getMovement();
         Box var20 = var12.getBoundingBox();
         PhysicsBodyState var21 = var9.getStateBefore();
         PhysicsBodyState var22 = var9.getStateAfter();
         ForceProviderEntity var23 = var9.getForceProviderEntity();
         PhysicsBodyStateUpdater var24 = var9.getStateUpdater();
         ForceProvider[] var25 = var9.getForceProviders();
         Vector3d var26 = var9.getMoveOutOfSolidVelocity();
         double var27 = var13.getGravity();
         int var29 = var13.getBounceCount();
         boolean var30 = var13.isAllowRolling();
         var9.setWorld(var8);
         var54.set(var11.getPosition());
         var10.assignVelocityTo(var18);
         double var31 = var23.getMass(var20.getVolume());
         var15.convertToForces(var1, var31);
         var15.updateVelocity(var18);
         if (!(var18.lengthSquared() * var1 * var1 >= 1.0000000000000002E-10) && !(var15.externalForce.lengthSquared() > 0.0)) {
            var18.zero();
         } else {
            var9.setState(StandardPhysicsProvider.STATE.ACTIVE);
         }

         ChunkStore var33 = var8.getChunkStore();
         if (var9.getState() == StandardPhysicsProvider.STATE.RESTING && var16.hasChanged(var33)) {
            var9.setState(StandardPhysicsProvider.STATE.ACTIVE);
            var9.setFallingAfterBreak(true);
         }

         var21.position.set(var54);
         var21.velocity.set(var18);
         var23.setForceProviderStandardState(var15);
         var24.update(var21, var22, var31, var1, var9.isOnGround(), var25);
         var18.set(var22.velocity);
         var19.set(var18).mul(var1);
         var15.clear();
         if (var18.lengthSquared() * var1 * var1 >= 1.0000000000000002E-10) {
            var9.setState(StandardPhysicsProvider.STATE.ACTIVE);
         } else {
            var18.zero();
         }

         EntityRefCollisionProvider var34 = var9.getEntityCollisionProvider();
         BlockCollisionProvider var35 = var9.getBlockCollisionProvider();
         BlockTracker var36 = var9.getTriggerTracker();
         Vector3d var37 = var9.getContactPosition();
         Vector3d var38 = var9.getContactNormal();
         Vector3d var39 = var9.getNextMovement();
         double var40 = 1.0;
         if (var9.isProvidesCharacterCollisions()) {
            Ref var42 = null;
            if (var9.getCreatorUuid() != null) {
               var42 = var4.getExternalData().getRefFromUUID(var9.getCreatorUuid());
            }

            var40 = var34.computeNearest(var5, var20, var54, var19, var14, var42);
            if (var40 < 0.0 || var40 > 1.0) {
               var40 = 1.0;
            }
         }

         var9.setBounced(false);
         var9.setOnGround(false);
         var26.zero();
         var9.setMovedInsideSolid(false);
         var9.setDisplacedMass(0.0);
         var9.setSubSurfaceVolume(0.0);
         var9.setEnterFluid(Double.MAX_VALUE);
         var9.setLeaveFluid(-Double.MAX_VALUE);
         var9.setCollisionStart(var40);
         var37.set(var54).fma(var9.getCollisionStart(), var19);
         var38.zero();
         var9.setSliding(true);
         Vector3d var55 = new Vector3d(var54);
         var39.zero();

         while (var9.isSliding() && !var19.equals(Vector3dUtil.ZERO)) {
            var37.set(var55).fma(var9.getCollisionStart(), var19);
            var9.setSliding(false);
            var35.cast(var8, var20, var55, var19, var9, var36, var40);
            var19.set(var39);
            var55.set(var37);
         }

         var19.set(var55).add(var39).sub(var54);
         var9.getFluidTracker().reset();
         double var43 = var9.getDisplacedMass() > 0.0 ? var9.getDisplacedMass() / var9.getSubSurfaceVolume() : 1.2;
         if (var9.isMovedInsideSolid()) {
            var54.fma(var1, var26);
            var18.set(var26);
            var15.dragCoefficient = var9.getDragCoefficient(var43);
            var15.displacedMass = var9.getDisplacedMass();
            var15.gravity = var27;
            var9.finishTick(var11, var10);
         } else {
            double var45 = var9.isBounced() ? var9.getCollisionStart() : 1.0;
            boolean var47 = false;
            if (!var9.isInFluid() && var9.getEnterFluid() < var9.getCollisionStart()) {
               var9.setInFluid(true);
               var45 = var9.getEnterFluid();
               var9.setVelocityExtremaCount(2);
               var47 = true;
            } else if (var9.isInFluid() && var9.getLeaveFluid() < var9.getCollisionStart()) {
               var9.setInFluid(false);
               var45 = var9.getLeaveFluid();
               var9.setVelocityExtremaCount(2);
            }

            if (var45 > 0.0 && var45 < 1.0) {
               var24.update(var21, var22, var31, var1 * var45, var9.isOnGround(), var25);
               var18.set(var22.velocity);
            }

            if (var9.isInFluid() && var9.getSubSurfaceVolume() < var20.getVolume() && var9.getVelocityExtremaCount() > 0) {
               double var48 = var21.velocity.y;
               double var50 = var22.velocity.y;
               if (var48 * var50 <= 0.0) {
                  var9.decrementVelocityExtremaCount();
               }
            }

            if (var9.isSwimming()) {
               var15.externalForce.y = var15.externalForce.y - var22.velocity.y * (var13.getSwimmingDampingFactor() / var31);
            }

            if (var47) {
               var15.externalImpulse.fma(-var13.getHitWaterImpulseLoss() * var31, var22.velocity);
            }

            var15.displacedMass = var9.getDisplacedMass();
            var15.dragCoefficient = var9.getDragCoefficient(var43);
            var15.gravity = var27;
            if (var34.getCount() > 0) {
               EntityContactData var57 = var34.getContact(0);
               Ref var58 = var57.getEntityReference();
               Vector3i var59 = var9.bounceBlockPosition();
               var54.set(var57.getCollisionPoint());
               var9.setState(StandardPhysicsProvider.STATE.INACTIVE);
               if (var9.getImpactConsumer() != null) {
                  var9.getImpactConsumer().onImpact(var14, var54, var59, var58, var57.getCollisionDetailName(), var5);
               }

               var9.rotateBody(var1, var11.getRotation());
               var9.clearBounced();
               var9.finishTick(var11, var10);
            } else if (!var9.isBounced()) {
               var54.add(var19);
               var9.rotateBody(var1, var11.getRotation());
               var9.finishTick(var11, var10);
            } else {
               var54.set(var37);
               var9.incrementBounces();
               SimplePhysicsProvider.computeReflectedVector(var18, var38, var18);
               if (var29 == -1 || var9.getBounces() <= var29) {
                  var18.mul(var13.getBounciness());
               }

               if ((var29 == -1 || var9.getBounces() <= var29) && !(var18.lengthSquared() * var1 * var1 < var13.getBounceLimit() * var13.getBounceLimit())) {
                  if (var9.getBounceConsumer() != null) {
                     var9.getBounceConsumer().onBounce(var14, var54, var5);
                  }
               } else {
                  boolean var56 = var38.equals(Vector3dUtil.UP);
                  if (!var30 && (var13.isSticksVertically() || var56)) {
                     Vector3i var49 = var9.bounceBlockPosition();
                     var9.setState(StandardPhysicsProvider.STATE.RESTING);
                     var16.rest(var33, var49);
                     var9.setOnGround(var56);
                     if (var9.getImpactConsumer() != null) {
                        var9.getImpactConsumer().onImpact(var14, var54, var49, null, null, var5);
                     }

                     var9.clearBounced();
                  }

                  if (var30) {
                     var18.y = 0.0;
                     var18.mul(var13.getRollingFrictionFactor());
                     var9.setOnGround(var56);
                  } else {
                     var18.zero();
                  }
               }

               var9.rotateBody(var1, var11.getRotation());
               var9.finishTick(var11, var10);
            }
         }
      }
   }
}