class="kw">package com.hypixel.hytale.builtin.blockphysics;

class="kw">import com.hypixel.hytale.builtin.blocktick.system.ChunkBlockTickSystem;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.DisableProcessingAssert;
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.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.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.blocktype.component.BlockPhysics;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.AbstractCachedAccessor;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
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 java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BlockPhysicsSystems {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final int MAX_SUPPORT_RADIUS = 14;

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

   class="kw">public class="kw">static class CachedAccessor class="kw">extends AbstractCachedAccessor {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ThreadLocal<BlockPhysicsSystems.CachedAccessor> THREAD_LOCAL = ThreadLocal.withInitial(BlockPhysicsSystems.CachedAccessor::new);
      class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Registry REGISTRY = new AbstractCachedAccessor.Registry();
      class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<BlockPhysics> PHYSICS_COMPONENT = REGISTRY.forSection(BlockPhysics::getComponentType);
      class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<FluidSection> FLUID_COMPONENT = REGISTRY.forSection(FluidSection::getComponentType);
      class="kw">private class="kw">static class="kw">final AbstractCachedAccessor.Key<BlockSection> BLOCK_COMPONENT = REGISTRY.forSection(BlockSection::getComponentType);
      class="kw">protected BlockSection selfBlockSection;
      class="kw">protected BlockPhysics selfPhysics;
      class="kw">protected FluidSection selfFluidSection;
      class="kw">protected Ref<ChunkStore> selfSectionReference;

      class="kw">protected CachedAccessor() {
         super(REGISTRY);
      }

      @Nonnull
      class="kw">public class="kw">static BlockPhysicsSystems.CachedAccessor of(
         ComponentAccessor<ChunkStore> var0,
         Ref<ChunkStore> var1,
         BlockSection var2,
         BlockPhysics var3,
         FluidSection var4,
         int var5,
         int var6,
         int var7,
         int var8
      ) {
         BlockPhysicsSystems.CachedAccessor var9 = THREAD_LOCAL.get();
         var9.init(var0, var5, var6, var7, var8);
         var9.insertSectionComponent(PHYSICS_COMPONENT, var3, var5, var6, var7);
         var9.insertSectionComponent(FLUID_COMPONENT, var4, var5, var6, var7);
         var9.insertSectionComponent(BLOCK_COMPONENT, var2, var5, var6, var7);
         var9.selfSectionReference = var1;
         var9.insertSection(var1, var5, var6, var7);
         var9.selfBlockSection = var2;
         var9.selfPhysics = var3;
         var9.selfFluidSection = var4;
         class="kw">return var9;
      }

      @Nullable
      class="kw">public BlockPhysics getBlockPhysics(int var1, int var2, int var3) {
         class="kw">return this.getComponentSection(var1, var2, var3, PHYSICS_COMPONENT);
      }

      @Nullable
      class="kw">public BlockPhysics getBlockPhysicsAtBlock(int var1, int var2, int var3) {
         class="kw">return this.getComponentSectionAtBlock(var1, var2, var3, PHYSICS_COMPONENT);
      }

      @Nullable
      class="kw">public FluidSection getFluidSection(int var1, int var2, int var3) {
         class="kw">return this.getComponentSection(var1, var2, var3, FLUID_COMPONENT);
      }

      @Nullable
      class="kw">public FluidSection getFluidSectionAtBlock(int var1, int var2, int var3) {
         class="kw">return this.getComponentSectionAtBlock(var1, var2, var3, FLUID_COMPONENT);
      }

      @Nullable
      class="kw">public BlockSection getBlockSection(int var1, int var2, int var3) {
         class="kw">return this.getComponentSection(var1, var2, var3, BLOCK_COMPONENT);
      }

      @Nullable
      class="kw">public BlockSection getBlockSectionAtBlock(int var1, int var2, int var3) {
         class="kw">return this.getComponentSectionAtBlock(var1, var2, var3, BLOCK_COMPONENT);
      }

      class="kw">public void performBlockUpdate(int var1, int var2, int var3, int var4) {
         for (int var5 = -1; var5 < 2; var5++) {
            int var6 = var1 + var5;

            for (int var7 = -1; var7 < 2; var7++) {
               int var8 = var3 + var7;

               for (int var9 = -1; var9 < 2; var9++) {
                  int var10 = var2 + var9;
                  BlockPhysics var11 = this.getBlockPhysics(ChunkUtil.chunkCoordinate(var6), ChunkUtil.chunkCoordinate(var10), ChunkUtil.chunkCoordinate(var8));
                  int var12 = var11 != null ? var11.get(var6, var10, var8) : 0;
                  if (var12 <= var4) {
                     BlockSection var13 = this.getBlockSection(
                        ChunkUtil.chunkCoordinate(var6), ChunkUtil.chunkCoordinate(var10), ChunkUtil.chunkCoordinate(var8)
                     );
                     if (var13 != null) {
                        var13.setTicking(var6, var10, var8, true);
                     }
                  }
               }
            }
         }
      }

      class="kw">public void performBlockUpdate(int var1, int var2, int var3) {
         for (int var4 = -1; var4 < 2; var4++) {
            int var5 = var1 + var4;

            for (int var6 = -1; var6 < 2; var6++) {
               int var7 = var3 + var6;

               for (int var8 = -1; var8 < 2; var8++) {
                  int var9 = var2 + var8;
                  BlockSection var10 = this.getBlockSection(ChunkUtil.chunkCoordinate(var5), ChunkUtil.chunkCoordinate(var9), ChunkUtil.chunkCoordinate(var7));
                  if (var10 != null) {
                     var10.setTicking(var5, var9, var7, true);
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class Ticking class="kw">extends EntityTickingSystem<ChunkStore> class="kw">implements DisableProcessingAssert {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(
         ChunkSection.getComponentType(), BlockSection.getComponentType(), BlockPhysics.getComponentType(), FluidSection.getComponentType()
      );
      @Nonnull
      class="kw">private class="kw">static class="kw">final Set<Dependency<ChunkStore>> DEPENDENCIES = Set.of(
         new SystemDependency<>(Order.AFTER, ChunkBlockTickSystem.PreTick.class), new SystemDependency<>(Order.BEFORE, ChunkBlockTickSystem.Ticking.class)
      );

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

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

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

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<ChunkStore> var3, @Nonnull Store<ChunkStore> var4, @Nonnull CommandBuffer<ChunkStore> var5) {
         ChunkSection var6 = var3.getComponent(var2, ChunkSection.getComponentType());
         assert var6 != null;

         try {
            BlockSection var7 = var3.getComponent(var2, BlockSection.getComponentType());
            if (var7 == null) {
               class="kw">return;
            }

            if (var7.getTickingBlocksCountCopy() <= 0) {
               class="kw">return;
            }

            BlockPhysics var8 = var3.getComponent(var2, BlockPhysics.getComponentType());
            if (var8 == null) {
               class="kw">return;
            }

            FluidSection var9 = var3.getComponent(var2, FluidSection.getComponentType());
            if (var9 == null) {
               class="kw">return;
            }

            Ref var10 = var6.getChunkColumnReference();
            if (var10 == null || !var10.isValid()) {
               class="kw">return;
            }

            WorldChunk var11 = var5.getComponent(var10, WorldChunk.getComponentType());
            if (var11 == null) {
               class="kw">return;
            }

            BlockPhysicsSystems.CachedAccessor var12 = BlockPhysicsSystems.CachedAccessor.of(
               var5, var3.getReferenceTo(var2), var7, var8, var9, var6.getX(), var6.getY(), var6.getZ(), 14
            );
            var7.forEachTicking(
               var11,
               var12,
               var6.getY(),
               (var0, var1x, var2x, var3x, var4x, var5x) -> {
                  BlockPhysics var6 = var1x.selfPhysics;
                  boolean var7 = var6.isDeco(var2x, var3x, var4x);
                  BlockType var8 = BlockType.getAssetMap().getAsset(var5x);
                  if (var8 == null || var5x == 0) {
                     class="kw">return BlockTickStrategy.IGNORED;
                  }

                  if (var7) {
                     class="kw">return BlockTickStrategy.IGNORED;
                  }

                  World var9 = var0.getWorld();
                  Store var10 = var9.getEntityStore().getStore();
                  int var11 = var0.getX() << 5 | var2x;
                  int var12 = var3x;
                  int var13 = var0.getZ() << 5 | var4x;
                  int var14 = var1x.selfBlockSection.getFiller(var2x, var3x, var4x);
                  int var15 = var1x.selfBlockSection.getRotationIndex(var2x, var3x, var4x);

                  class="kw">return class="kw">switch (BlockPhysicsUtil.applyBlockPhysics(
                     var10,
                     var1x,
                     var1x.selfSectionReference,
                     var1x.selfBlockSection,
                     var1x.selfPhysics,
                     var1x.selfFluidSection,
                     var11,
                     var12,
                     var13,
                     var8,
                     var15,
                     var14
                  )) {
                     case WAITING_CHUNK -> BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
                     case VALID -> BlockTickStrategy.IGNORED;
                     case INVALID -> BlockTickStrategy.SLEEP;
                  };
               }
            );
         } catch (Exception var13) {
            ((HytaleLogger.Api)BlockPhysicsSystems.LOGGER.at(Level.SEVERE).withCause(var13)).log("Failed to tick chunk: %s", var6);
         }
      }
   }
}