class="kw">package com.hypixel.hytale.server.core.universe.world.chunk.systems;

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
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.Holder;
class="kw">import com.hypixel.hytale.component.NonTicking;
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.RootDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
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.component.system.tick.RunWhenPausedSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.protocol.CachedPacket;
class="kw">import com.hypixel.hytale.protocol.packets.world.ServerSetBlock;
class="kw">import com.hypixel.hytale.protocol.packets.world.ServerSetBlocks;
class="kw">import com.hypixel.hytale.protocol.packets.world.SetBlockCmd;
class="kw">import com.hypixel.hytale.protocol.packets.world.SetChunk;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.ChunkTracker;
class="kw">import com.hypixel.hytale.server.core.modules.migrations.ChunkColumnMigrationSystem;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkColumn;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.EntityChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
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.EntitySection;
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 it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectListIterator;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.Iterator;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ChunkSystems {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final int MAX_CHANGES_PER_PACKET = 1024;

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

   class="kw">public class="kw">static class EnsureSection class="kw">extends HolderSystem<ChunkStore> {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(
         ChunkSection.getComponentType(),
         Query.or(Query.not(BlockSection.getComponentType()), Query.not(EntitySection.getComponentType()), Query.not(BlockComponentSection.getComponentType()))
      );

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         var1.ensureComponent(BlockSection.getComponentType());
         var1.ensureComponent(EntitySection.getComponentType());
         var1.ensureComponent(BlockComponentSection.getComponentType());
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

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

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

   class="kw">public class="kw">static class LoadBlockSection class="kw">extends HolderSystem<ChunkStore> {
      class="kw">public LoadBlockSection() {
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         BlockSection var4 = var1.getComponent(BlockSection.getComponentType());
         assert var4 != null;
         var4.loaded = true;
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return BlockSection.getComponentType();
      }
   }

   class="kw">public class="kw">static class MigrateBlockComponentChunk class="kw">extends ChunkColumnMigrationSystem {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(ChunkColumn.getComponentType(), BlockComponentChunk.getComponentType());

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         ChunkColumn var4 = var1.getComponent(ChunkColumn.getComponentType());
         assert var4 != null;
         BlockComponentChunk var5 = var1.getComponent(BlockComponentChunk.getComponentType());
         assert var5 != null;
         Holder[] var6 = var4.getSectionHolders();
         if (var6 != null) {
            var1.removeComponent(BlockComponentChunk.getComponentType());
            Int2ObjectMap var7 = var5.takeEntityHolders();
            if (var7 != null) {
               ObjectIterator var8 = var7.int2ObjectEntrySet().iterator();

               while (var8.hasNext()) {
                  Entry var9 = (Entry<Holder<ChunkStore>>)var8.next();
                  int var10 = var9.getIntKey();
                  int var11 = xFromBlockInColumn(var10);
                  int var12 = yFromBlockInColumn(var10);
                  int var13 = zFromBlockInColumn(var10);
                  int var14 = ChunkUtil.chunkCoordinate(var12);
                  if (var14 < var6.length && var6[var14] != null) {
                     BlockComponentSection var15 = var6[var14].ensureAndGetComponent(BlockComponentSection.getComponentType());
                     short var16 = (short)ChunkUtil.indexBlock(var11, var12, var13);
                     if (var15.hasBlockComponents(var16)) {
                        ChunkSystems.LOGGER
                           .at(Level.WARNING)
                           .log("Dropping block components at (%d, %d, %d): the section already has block components", var11, var12, var13);
                     } else {
                        var15.addBlockHolder(var16, (Holder<ChunkStore>)var9.getValue());
                     }
                  } else {
                     ChunkSystems.LOGGER
                        .at(Level.WARNING)
                        .log("Dropping block components at (%d, %d, %d): the column has no section %d", var11, var12, var13, var14);
                  }
               }
            }
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

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

      class="kw">private class="kw">static int xFromBlockInColumn(int var0) {
         class="kw">return var0 & 31;
      }

      class="kw">private class="kw">static int yFromBlockInColumn(int var0) {
         class="kw">return var0 >> 10 & ChunkUtil.HEIGHT_MASK;
      }

      class="kw">private class="kw">static int zFromBlockInColumn(int var0) {
         class="kw">return var0 >> 5 & 31;
      }
   }

   class="kw">public class="kw">static class MigrateEntityChunk class="kw">extends ChunkColumnMigrationSystem {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(ChunkColumn.getComponentType(), EntityChunk.getComponentType());

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         ChunkColumn var4 = var1.getComponent(ChunkColumn.getComponentType());
         assert var4 != null;
         EntityChunk var5 = var1.getComponent(EntityChunk.getComponentType());
         assert var5 != null;
         Holder[] var6 = var4.getSectionHolders();
         if (var6 != null) {
            var1.removeComponent(EntityChunk.getComponentType());
            Holder[] var7 = var5.takeEntityHolders();
            if (var7 != null && var7.length != 0) {
               ObjectArrayList var8 = new ObjectArrayList(var7);

               for (int var9 = 0; var9 < var6.length; var9++) {
                  Holder var10 = var6[var9];
                  if (var10 != null) {
                     EntitySection var11 = var10.ensureAndGetComponent(EntitySection.getComponentType());
                     if (var8.isEmpty()) {
                        break;
                     }

                     ObjectListIterator var12 = var8.iterator();

                     while (var12.hasNext()) {
                        Holder var13 = (Holder<EntityStore>)var12.next();
                        TransformComponent var14 = var13.getComponent(TransformComponent.getComponentType());
                        if (var14 == null) {
                           var11.addEntityHolder(var13);
                           var12.remove();
                        } else if (ChunkUtil.chunkCoordinate(var14.getPosition().y) == var9) {
                           var11.addEntityHolder(var13);
                           var12.remove();
                        }
                     }
                  }
               }
            }
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

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

   class="kw">public class="kw">static class OnChunkLoad class="kw">extends RefSystem<ChunkStore> {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(ChunkColumn.getComponentType(), WorldChunk.getComponentType());

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

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

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         ChunkColumn var5 = var4.getComponent(var1, ChunkColumn.getComponentType());
         assert var5 != null;
         Ref[] var6 = var5.getSections();
         Holder[] var7 = new Holder[var6.length];

         for (int var8 = 0; var8 < var6.length; var8++) {
            Ref var9 = var6[var8];
            var7[var8] = ChunkStore.REGISTRY.newHolder();
            var4.removeEntity(var9, var7[var8], var2);
         }

         var5.putSectionHolders(var7);
         Arrays.fill(var6, null);
      }

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

   class="kw">public class="kw">static class OnNonTicking class="kw">extends RefChangeSystem<ChunkStore, NonTicking<ChunkStore>> {
      class="kw">private class="kw">final Archetype<ChunkStore> archetype = Archetype.of(WorldChunk.getComponentType(), ChunkColumn.getComponentType());

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

      @Nonnull
      @Override
      class="kw">public ComponentType<ChunkStore, NonTicking<ChunkStore>> componentType() {
         class="kw">return ChunkStore.REGISTRY.getNonTickingComponentType();
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull NonTicking<ChunkStore> var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         ChunkColumn var5 = var4.getComponent(var1, ChunkColumn.getComponentType());
         assert var5 != null;
         Ref[] var6 = var5.getSections();

         for (int var7 = 0; var7 < var6.length; var7++) {
            Ref var8 = var6[var7];
            var4.ensureComponent(var8, ChunkStore.REGISTRY.getNonTickingComponentType());
         }
      }

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

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<ChunkStore> var1, @Nonnull NonTicking<ChunkStore> var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         ChunkColumn var5 = var4.getComponent(var1, ChunkColumn.getComponentType());
         assert var5 != null;
         Ref[] var6 = var5.getSections();

         for (int var7 = 0; var7 < var6.length; var7++) {
            Ref var8 = var6[var7];
            var4.tryRemoveComponent(var8, ChunkStore.REGISTRY.getNonTickingComponentType());
         }
      }

      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.archetype;
      }
   }

   class="kw">public class="kw">static class ReplicateChanges class="kw">extends EntityTickingSystem<ChunkStore> class="kw">implements RunWhenPausedSystem<ChunkStore> {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> QUERY = Query.and(ChunkSection.getComponentType(), BlockSection.getComponentType());

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

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<ChunkStore> var3, @Nonnull Store<ChunkStore> var4, @Nonnull CommandBuffer<ChunkStore> var5) {
         BlockSection var6 = var3.getComponent(var2, BlockSection.getComponentType());
         assert var6 != null;
         IntOpenHashSet var7 = var6.getAndClearChangedPositions();
         if (!var7.isEmpty()) {
            ChunkSection var8 = var3.getComponent(var2, ChunkSection.getComponentType());
            assert var8 != null;
            Collection var9 = var4.getExternalData().getWorld().getPlayerRefs();
            if (var9.isEmpty()) {
               var7.clear();
            } else if (var7.size() >= 1024) {
               ObjectArrayList var23 = new ObjectArrayList(var9);
               CompletableFuture var25 = var6.getCachedChunkPacket(var8.getX(), var8.getY(), var8.getZ());
               var25.thenAccept(var2x -> {
                  Iterator var3 = var23.iterator();

                  while (var3.hasNext()) {
                     PlayerRef var4 = (PlayerRef)var3.next();
                     Ref var5 = var4.getReference();
                     if (var5 != null) {
                        ChunkTracker var6 = var4.getChunkTracker();
                        if (var6.isLoaded(var8.getX(), var8.getY(), var8.getZ())) {
                           var4.getPacketHandler().writeNoCache(var2x);
                        }
                     }
                  }
               }).exceptionally(var0 -> {
                  if (var0 != null) {
                     ((HytaleLogger.Api)ChunkSystems.LOGGER.at(Level.SEVERE).withCause(var0)).log("Exception when compressing chunk fluids:");
                  }

                  class="kw">return null;
               });
               var7.clear();
            } else {
               if (var7.size() == 1) {
                  int var10 = var7.iterator().nextInt();
                  int var11 = ChunkUtil.minBlock(var8.getX()) + ChunkUtil.xFromIndex(var10);
                  int var12 = ChunkUtil.minBlock(var8.getY()) + ChunkUtil.yFromIndex(var10);
                  int var13 = ChunkUtil.minBlock(var8.getZ()) + ChunkUtil.zFromIndex(var10);
                  int var14 = var6.get(var10);
                  int var15 = var6.getFiller(var10);
                  int var16 = var6.getRotationIndex(var10);
                  ServerSetBlock var17 = new ServerSetBlock(var11, var12, var13, var14, (short)var15, (byte)var16);

                  for (PlayerRef var19 : var9) {
                     Ref var20 = var19.getReference();
                     if (var20 != null) {
                        ChunkTracker var21 = var19.getChunkTracker();
                        if (var21.isLoaded(var8.getX(), var8.getY(), var8.getZ())) {
                           var19.getPacketHandler().writeNoCache(var17);
                        }
                     }
                  }
               } else {
                  SetBlockCmd[] var22 = new SetBlockCmd[var7.size()];
                  IntIterator var24 = var7.intIterator();
                  int var26 = 0;

                  while (var24.hasNext()) {
                     int var27 = var24.nextInt();
                     int var29 = var6.get(var27);
                     int var31 = var6.getFiller(var27);
                     int var33 = var6.getRotationIndex(var27);
                     var22[var26++] = new SetBlockCmd((short)var27, var29, (short)var31, (byte)var33);
                  }

                  ServerSetBlocks var28 = new ServerSetBlocks(var8.getX(), var8.getY(), var8.getZ(), var22);

                  for (PlayerRef var32 : var9) {
                     Ref var34 = var32.getReference();
                     if (var34 != null) {
                        ChunkTracker var35 = var32.getChunkTracker();
                        if (var35.isLoaded(var8.getX(), var8.getY(), var8.getZ())) {
                           var32.getPacketHandler().writeNoCache(var28);
                        }
                     }
                  }
               }

               var7.clear();
            }
         }
      }

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

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