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

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.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
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.SystemGroup;
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.dependency.SystemGroupDependency;
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.spatial.SpatialStructure;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.ComponentUpdate;
class="kw">import com.hypixel.hytale.protocol.ComponentUpdateType;
class="kw">import com.hypixel.hytale.protocol.EntityEffectsUpdate;
class="kw">import com.hypixel.hytale.protocol.ModelUpdate;
class="kw">import com.hypixel.hytale.protocol.PlayerSkinUpdate;
class="kw">import com.hypixel.hytale.protocol.PropUpdate;
class="kw">import com.hypixel.hytale.protocol.packets.entities.EntityUpdates;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.HiddenPlayersManager;
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.EntityScaleComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.PropComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSkinComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.NetworkSendableSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.receiver.IPacketReceiver;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
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.Reference2IntMap;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
class="kw">import java.util.Collections;
class="kw">import java.util.EnumSet;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.locks.StampedLock;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class EntityTrackerSystems {
   @Nonnull
   class="kw">public class="kw">static class="kw">final SystemGroup<EntityStore> FIND_VISIBLE_ENTITIES_GROUP = EntityStore.REGISTRY.registerSystemGroup();
   @Nonnull
   class="kw">public class="kw">static class="kw">final SystemGroup<EntityStore> QUEUE_UPDATE_GROUP = EntityStore.REGISTRY.registerSystemGroup();

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

   class="kw">public class="kw">static boolean despawnAll(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      if (!var0.isValid()) {
         class="kw">return false;
      }

      EntityTrackerSystems.EntityViewer var2 = var1.getComponent(var0, EntityTrackerSystems.EntityViewer.getComponentType());
      if (var2 == null) {
         class="kw">return false;
      }

      int var3 = var2.sent.removeInt(var0);
      EntityUpdates var4 = new EntityUpdates();
      var4.removed = var2.sent.values().toIntArray();
      var2.packetReceiver.writeNoCache(var4);
      clear(var0, var1);
      var2.sent.put(var0, var3);
      class="kw">return true;
   }

   class="kw">public class="kw">static boolean clear(@Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      if (!var0.isValid()) {
         class="kw">return false;
      }

      EntityTrackerSystems.EntityViewer var2 = var1.getComponent(var0, EntityTrackerSystems.EntityViewer.getComponentType());
      if (var2 == null) {
         class="kw">return false;
      }

      ObjectIterator var3 = var2.sent.keySet().iterator();

      while (var3.hasNext()) {
         Ref var4 = (Ref<EntityStore>)var3.next();
         if (var4 != null && var4.isValid()) {
            EntityTrackerSystems.Visible var5 = var1.getComponent(var4, EntityTrackerSystems.Visible.getComponentType());
            if (var5 != null) {
               var5.visibleTo.remove(var0);
            }
         }
      }

      var2.sent.clear();
      class="kw">return true;
   }

   class="kw">public class="kw">static boolean clear(@Nonnull Holder<EntityStore> var0) {
      EntityTrackerSystems.EntityViewer var1 = var0.getComponent(EntityTrackerSystems.EntityViewer.getComponentType());
      if (var1 == null) {
         class="kw">return false;
      }

      var1.sent.clear();
      class="kw">return true;
   }

   class="kw">public class="kw">static class AddToVisible class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Collections.singleton(
         new SystemDependency<>(Order.AFTER, EntityTrackerSystems.EnsureVisibleComponent.class)
      );
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;

      class="kw">public AddToVisible(
         @Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1, @Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var2
      ) {
         this.entityViewerComponentType = var1;
         this.visibleComponentType = var2;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var3.getReferenceTo(var2);
         EntityTrackerSystems.EntityViewer var7 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var7 != null;

         for (Ref var9 : var7.visible) {
            if (var9 != null && var9.isValid()) {
               EntityTrackerSystems.Visible var10 = var5.getComponent(var9, this.visibleComponentType);
               if (var10 != null) {
                  var10.addViewerParallel(var6, var7);
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class ClearEntityViewers class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Collections.singleton(
         new SystemGroupDependency<>(Order.BEFORE, EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP)
      );
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;

      class="kw">public ClearEntityViewers(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1) {
         this.entityViewerComponentType = var1;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.EntityViewer var6 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var6 != null;
         var6.visible.clear();
         var6.lodExcludedCount = 0;
         var6.hiddenCount = 0;
      }
   }

   class="kw">public class="kw">static class ClearPreviouslyVisible class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(
         new SystemDependency<>(Order.AFTER, EntityTrackerSystems.ClearEntityViewers.class),
         new SystemGroupDependency<EntityStore>(Order.AFTER, EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP)
      );
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;

      class="kw">public ClearPreviouslyVisible(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1) {
         this.visibleComponentType = var1;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         Map var7 = var6.previousVisibleTo;
         var6.previousVisibleTo = var6.visibleTo;
         var6.visibleTo = var7;
         var6.visibleTo.clear();
         var6.newlyVisibleTo.clear();
      }
   }

   class="kw">public class="kw">static class CollectVisible class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public CollectVisible(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1) {
         this.entityViewerComponentType = var1;
         this.query = Archetype.of(var1, TransformComponent.getComponentType());
         this.dependencies = Collections.singleton(new SystemDependency<>(Order.AFTER, NetworkSendableSpatialSystem.class));
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         TransformComponent var6 = var3.getComponent(var2, TransformComponent.getComponentType());
         assert var6 != null;
         Vector3d var7 = var6.getPosition();
         EntityTrackerSystems.EntityViewer var8 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var8 != null;
         SpatialStructure var9 = var4.getResource(EntityModule.get().getNetworkSendableSpatialResourceType()).getSpatialStructure();
         List var10 = SpatialResource.getThreadLocalReferenceList();
         var9.collect(var7, var8.viewRadiusBlocks, var10);
         var8.visible.addAll(var10);
      }
   }

   class="kw">public class="kw">static class EffectControllerSystem class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EffectControllerComponent> effectControllerComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public EffectControllerSystem(
         @Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1, @Nonnull ComponentType<EntityStore, EffectControllerComponent> var2
      ) {
         this.visibleComponentType = var1;
         this.effectControllerComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.QUEUE_UPDATE_GROUP;
      }

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         EffectControllerComponent var7 = var3.getComponent(var2, this.effectControllerComponentType);
         assert var7 != null;
         Ref var8 = var3.getReferenceTo(var2);
         if (!var6.newlyVisibleTo.isEmpty()) {
            queueFullUpdate(var8, var7, var6.newlyVisibleTo);
         }

         if (var7.consumeNetworkOutdated()) {
            queueUpdatesFor(var8, var7, var6.visibleTo, var6.newlyVisibleTo);
         }
      }

      class="kw">private class="kw">static void queueFullUpdate(
         @Nonnull Ref<EntityStore> var0, @Nonnull EffectControllerComponent var1, @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var2
      ) {
         EntityEffectsUpdate var3 = new EntityEffectsUpdate();
         var3.entityEffectUpdates = var1.createInitUpdates();

         for (EntityTrackerSystems.EntityViewer var5 : var2.values()) {
            var5.queueUpdate(var0, var3);
         }
      }

      class="kw">private class="kw">static void queueUpdatesFor(
         @Nonnull Ref<EntityStore> var0,
         @Nonnull EffectControllerComponent var1,
         @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var2,
         @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var3
      ) {
         EntityEffectsUpdate var4 = new EntityEffectsUpdate();
         var4.entityEffectUpdates = var1.consumeChanges();
         if (!var3.isEmpty()) {
            for (Entry var8 : var2.entrySet()) {
               if (!var3.containsKey(var8.getKey())) {
                  var8.getValue().queueUpdate(var0, var4);
               }
            }
         } else {
            for (EntityTrackerSystems.EntityViewer var6 : var2.values()) {
               var6.queueUpdate(var0, var4);
            }
         }
      }
   }

   class="kw">public class="kw">static class EnsureVisibleComponent class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Collections.singleton(
         new SystemDependency<>(Order.AFTER, EntityTrackerSystems.ClearPreviouslyVisible.class)
      );
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;

      class="kw">public EnsureVisibleComponent(
         @Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1, @Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var2
      ) {
         this.entityViewerComponentType = var1;
         this.visibleComponentType = var2;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.EntityViewer var6 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var6 != null;

         for (Ref var8 : var6.visible) {
            if (var8 != null && var8.isValid() && !var5.getArchetype(var8).contains(this.visibleComponentType)) {
               var5.ensureComponent(var8, this.visibleComponentType);
            }
         }
      }
   }

   class="kw">public class="kw">static class EntityModel class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, ModelComponent> modelComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public EntityModel(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1) {
         this.visibleComponentType = var1;
         this.modelComponentType = ModelComponent.getComponentType();
         this.query = Query.and(var1, this.modelComponentType);
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.QUEUE_UPDATE_GROUP;
      }

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         ModelComponent var7 = var3.getComponent(var2, this.modelComponentType);
         assert var7 != null;
         float var8 = 0.0F;
         boolean var9 = false;
         EntityScaleComponent var10 = var3.getComponent(var2, EntityScaleComponent.getComponentType());
         if (var10 != null) {
            var8 = var10.getScale();
            var9 = var10.consumeNetworkOutdated();
         }

         Ref var11 = var3.getReferenceTo(var2);
         boolean var12 = var3.getComponent(var2, PropComponent.getComponentType()) != null;
         boolean var13 = var7.consumeNetworkOutdated();
         if (var13 || var9) {
            queueUpdatesFor(var11, var7, var8, var12, var6.visibleTo);
         } else if (!var6.newlyVisibleTo.isEmpty()) {
            queueUpdatesFor(var11, var7, var8, var12, var6.newlyVisibleTo);
         }
      }

      class="kw">private class="kw">static void queueUpdatesFor(
         @Nonnull Ref<EntityStore> var0,
         @Nullable ModelComponent var1,
         float var2,
         boolean var3,
         @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var4
      ) {
         ModelUpdate var5 = new ModelUpdate(var1 != null ? var1.getModel().toPacket() : null, var2);

         for (EntityTrackerSystems.EntityViewer var7 : var4.values()) {
            var7.queueUpdate(var0, var5);
         }

         if (var3) {
            PropUpdate var9 = new PropUpdate();

            for (EntityTrackerSystems.EntityViewer var8 : var4.values()) {
               var8.queueUpdate(var0, var9);
            }
         }
      }
   }

   class="kw">public class="kw">static class EntitySkin class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerSkinComponent> playerSkinComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public EntitySkin(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1, @Nonnull ComponentType<EntityStore, PlayerSkinComponent> var2) {
         this.visibleComponentType = var1;
         this.playerSkinComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.QUEUE_UPDATE_GROUP;
      }

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         PlayerSkinComponent var7 = var3.getComponent(var2, this.playerSkinComponentType);
         assert var7 != null;
         if (var7.consumeNetworkOutdated()) {
            queueUpdatesFor(var3.getReferenceTo(var2), var7, var6.visibleTo);
         } else if (!var6.newlyVisibleTo.isEmpty()) {
            queueUpdatesFor(var3.getReferenceTo(var2), var7, var6.newlyVisibleTo);
         }
      }

      class="kw">private class="kw">static void queueUpdatesFor(
         @Nonnull Ref<EntityStore> var0, @Nonnull PlayerSkinComponent var1, @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var2
      ) {
         PlayerSkinUpdate var3 = new PlayerSkinUpdate();
         var3.skin = var1.getPlayerSkin();

         for (EntityTrackerSystems.EntityViewer var5 : var2.values()) {
            var5.queueUpdate(var0, var3);
         }
      }
   }

   class="kw">public class="kw">static class EntityUpdate {
      @Nonnull
      class="kw">private class="kw">final StampedLock removeLock = new StampedLock();
      @Nonnull
      class="kw">private class="kw">final EnumSet<ComponentUpdateType> removed;
      @Nonnull
      class="kw">private class="kw">final StampedLock updatesLock = new StampedLock();
      @Nonnull
      class="kw">private class="kw">final List<ComponentUpdate> updates;

      class="kw">public EntityUpdate() {
         this.removed = EnumSet.noneOf(ComponentUpdateType.class);
         this.updates = new ObjectArrayList();
      }

      class="kw">public EntityUpdate(@Nonnull EntityTrackerSystems.EntityUpdate var1) {
         this.removed = EnumSet.copyOf(var1.removed);
         this.updates = new ObjectArrayList(var1.updates);
      }

      @Nonnull
      class="kw">public EntityTrackerSystems.EntityUpdate clone() {
         class="kw">return new EntityTrackerSystems.EntityUpdate(this);
      }

      class="kw">public void queueRemove(@Nonnull ComponentUpdateType var1) {
         long var2 = this.removeLock.writeLock();

         try {
            this.removed.add(var1);
         } class="kw">finally {
            this.removeLock.unlockWrite(var2);
         }
      }

      class="kw">public void queueUpdate(@Nonnull ComponentUpdate var1) {
         long var2 = this.updatesLock.writeLock();

         try {
            this.updates.add(var1);
         } class="kw">finally {
            this.updatesLock.unlockWrite(var2);
         }
      }

      @Nullable
      class="kw">public ComponentUpdateType[] toRemovedArray() {
         class="kw">return this.removed.isEmpty() ? null : this.removed.toArray(ComponentUpdateType[]::new);
      }

      @Nullable
      class="kw">public ComponentUpdate[] toUpdatesArray() {
         class="kw">return this.updates.isEmpty() ? null : this.updates.toArray(ComponentUpdate[]::new);
      }
   }

   class="kw">public class="kw">static class EntityViewer class="kw">implements Component<EntityStore> {
      class="kw">public int viewRadiusBlocks;
      @Nonnull
      class="kw">public IPacketReceiver packetReceiver;
      @Nonnull
      class="kw">public Set<Ref<EntityStore>> visible;
      @Nonnull
      class="kw">public Map<Ref<EntityStore>, EntityTrackerSystems.EntityUpdate> updates;
      @Nonnull
      class="kw">public Reference2IntMap<Ref<EntityStore>> sent;
      class="kw">public int lodExcludedCount;
      class="kw">public int hiddenCount;

      class="kw">public class="kw">static ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> getComponentType() {
         class="kw">return EntityModule.get().getEntityViewerComponentType();
      }

      class="kw">public EntityViewer(int var1, @Nonnull IPacketReceiver var2) {
         this.viewRadiusBlocks = var1;
         this.packetReceiver = var2;
         this.visible = new ReferenceOpenHashSet();
         this.updates = new ConcurrentHashMap<>();
         this.sent = new Reference2IntOpenHashMap();
         this.sent.defaultReturnValue(-1);
      }

      class="kw">public EntityViewer(@Nonnull EntityTrackerSystems.EntityViewer var1) {
         this.viewRadiusBlocks = var1.viewRadiusBlocks;
         this.packetReceiver = var1.packetReceiver;
         this.visible = new ReferenceOpenHashSet(var1.visible);
         this.updates = new ConcurrentHashMap<>(var1.updates.size());

         for (Entry var3 : var1.updates.entrySet()) {
            this.updates.put(var3.getKey(), var3.getValue().clone());
         }

         this.sent = new Reference2IntOpenHashMap(var1.sent);
         this.sent.defaultReturnValue(-1);
      }

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

      class="kw">public void queueRemove(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentUpdateType var2) {
         if (!this.visible.contains(var1)) {
            throw new IllegalArgumentException("Entity is not visible!");
         }

         this.updates.computeIfAbsent(var1, var0 -> new EntityTrackerSystems.EntityUpdate()).queueRemove(var2);
      }

      class="kw">public void queueUpdate(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentUpdate var2) {
         if (!this.visible.contains(var1)) {
            throw new IllegalArgumentException("Entity is not visible!");
         }

         this.updates.computeIfAbsent(var1, var0 -> new EntityTrackerSystems.EntityUpdate()).queueUpdate(var2);
      }
   }

   class="kw">public class="kw">static class HideFromPlayer class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerRef> playerRefComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerSettings> playerSettingsComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, UUIDComponent> uuidComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public HideFromPlayer(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1) {
         this.entityViewerComponentType = var1;
         this.playerRefComponentType = PlayerRef.getComponentType();
         this.playerSettingsComponentType = EntityModule.get().getPlayerSettingsComponentType();
         this.uuidComponentType = EntityModule.get().getUuidComponentType();
         this.query = Query.and(var1, this.playerRefComponentType, this.playerSettingsComponentType);
         this.dependencies = Collections.singleton(new SystemDependency<>(Order.AFTER, EntityTrackerSystems.CollectVisible.class));
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP;
      }

      @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 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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         PlayerSettings var6 = var3.getComponent(var2, this.playerSettingsComponentType);
         assert var6 != null;
         if (!var6.showEntityMarkers()) {
            EntityTrackerSystems.EntityViewer var7 = var3.getComponent(var2, this.entityViewerComponentType);
            assert var7 != null;
            PlayerRef var8 = var3.getComponent(var2, this.playerRefComponentType);
            assert var8 != null;
            HiddenPlayersManager var9 = var8.getHiddenPlayersManager();
            Iterator var10 = var7.visible.iterator();

            while (var10.hasNext()) {
               Ref var11 = var10.next();
               if (!var11.isValid()) {
                  var10.remove();
               } else if (var5.getArchetype(var11).contains(this.playerRefComponentType)) {
                  UUIDComponent var12 = var5.getComponent(var11, this.uuidComponentType);
                  if (var12 != null && var9.isPlayerHidden(var12.getUuid())) {
                     var7.hiddenCount++;
                     var10.remove();
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class LODCull class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">public class="kw">static class="kw">final double ENTITY_LOD_RATIO_DEFAULT = 3.5E-5;
      class="kw">public class="kw">static double ENTITY_LOD_RATIO = 3.5E-5;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, BoundingBox> boundingBoxComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies;

      class="kw">public LODCull(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1) {
         this.entityViewerComponentType = var1;
         this.boundingBoxComponentType = BoundingBox.getComponentType();
         this.query = Query.and(var1, TransformComponent.getComponentType());
         this.dependencies = Collections.singleton(new SystemDependency<>(Order.AFTER, EntityTrackerSystems.CollectVisible.class));
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.FIND_VISIBLE_ENTITIES_GROUP;
      }

      @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 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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.EntityViewer var6 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var6 != null;
         TransformComponent var7 = var3.getComponent(var2, TransformComponent.getComponentType());
         assert var7 != null;
         Vector3d var8 = var7.getPosition();
         Iterator var9 = var6.visible.iterator();

         while (var9.hasNext()) {
            Ref var10 = var9.next();
            if (!var10.isValid()) {
               var9.remove();
            } else {
               BoundingBox var11 = var5.getComponent(var10, this.boundingBoxComponentType);
               if (var11 != null) {
                  TransformComponent var12 = var5.getComponent(var10, TransformComponent.getComponentType());
                  if (var12 != null) {
                     double var13 = var12.getPosition().distanceSquared(var8);
                     double var15 = var11.getBoundingBox().getMaximumThickness();
                     if (var15 < ENTITY_LOD_RATIO * var13) {
                        var6.lodExcludedCount++;
                        var9.remove();
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class RemoveEmptyVisibleComponent class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(
         new SystemDependency<>(Order.AFTER, EntityTrackerSystems.AddToVisible.class),
         new SystemGroupDependency<EntityStore>(Order.BEFORE, EntityTrackerSystems.QUEUE_UPDATE_GROUP)
      );
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;

      class="kw">public RemoveEmptyVisibleComponent(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1) {
         this.visibleComponentType = var1;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.Visible var6 = var3.getComponent(var2, this.visibleComponentType);
         assert var6 != null;
         if (var6.visibleTo.isEmpty()) {
            var5.removeComponent(var3.getReferenceTo(var2), this.visibleComponentType);
         }
      }
   }

   class="kw">public class="kw">static class RemoveVisibleComponent class="kw">extends HolderSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType;

      class="kw">public RemoveVisibleComponent(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.Visible> var1) {
         this.visibleComponentType = var1;
      }

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

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
         var1.removeComponent(this.visibleComponentType);
      }
   }

   class="kw">public class="kw">static class SendPackets class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">public class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
      @Nonnull
      class="kw">public class="kw">static class="kw">final ThreadLocal<IntList> INT_LIST_THREAD_LOCAL = ThreadLocal.withInitial(IntArrayList::new);
      @Nonnull
      class="kw">public class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(new SystemGroupDependency<>(Order.AFTER, EntityTrackerSystems.QUEUE_UPDATE_GROUP));
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> entityViewerComponentType;

      class="kw">public SendPackets(@Nonnull ComponentType<EntityStore, EntityTrackerSystems.EntityViewer> var1) {
         this.entityViewerComponentType = var1;
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityStore.SEND_PACKET_GROUP;
      }

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

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

      @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<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityTrackerSystems.EntityViewer var6 = var3.getComponent(var2, this.entityViewerComponentType);
         assert var6 != null;
         IntList var7 = INT_LIST_THREAD_LOCAL.get();
         var7.clear();
         int var8 = var6.updates.size();
         var6.updates.entrySet().removeIf(var0 -> !var0.getKey().isValid());
         if (var8 != var6.updates.size()) {
            ((HytaleLogger.Api)LOGGER.atWarning()).log("Removed %d invalid updates for removed entities.", var8 - var6.updates.size());
         }

         ObjectIterator var9 = var6.sent.reference2IntEntrySet().iterator();

         while (var9.hasNext()) {
            it.unimi.dsi.fastutil.objects.Reference2IntMap.Entry var10 = (it.unimi.dsi.fastutil.objects.Reference2IntMap.Entry<Ref<EntityStore>>)var9.next();
            Ref var11 = (Ref<EntityStore>)var10.getKey();
            if (var11 == null || !var11.isValid() || !var6.visible.contains(var11)) {
               var7.add(var10.getIntValue());
               var9.remove();
               if (var6.updates.remove(var11) != null) {
                  ((HytaleLogger.Api)LOGGER.atSevere()).log("Entity can't be removed and also receive an update! %s", var11);
               }
            }
         }

         if (!var7.isEmpty() || !var6.updates.isEmpty()) {
            Iterator iteratorx = var6.updates.keySet().iterator();

            while (iteratorx.hasNext()) {
               Ref var17 = iteratorx.next();
               if (var17 == null || !var17.isValid() || var17.getStore() != var4) {
                  iteratorx.remove();
               } else if (!var6.sent.containsKey(var17)) {
                  NetworkId var19 = var5.getComponent(var17, NetworkId.getComponentType());
                  assert var19 != null;
                  int var12 = var19.getId();
                  if (var12 == -1) {
                     throw new IllegalArgumentException("Invalid entity network id: " + var17);
                  }

                  var6.sent.put(var17, var12);
               }
            }

            EntityUpdates var16 = new EntityUpdates();
            var16.removed = !var7.isEmpty() ? var7.toIntArray() : null;
            var16.updates = new com.hypixel.hytale.protocol.EntityUpdate[var6.updates.size()];
            int var18 = 0;

            for (Entry var21 : var6.updates.entrySet()) {
               com.hypixel.hytale.protocol.EntityUpdate var13 = var16.updates[var18++] = new com.hypixel.hytale.protocol.EntityUpdate();
               var13.networkId = var6.sent.getInt(var21.getKey());
               EntityTrackerSystems.EntityUpdate var14 = var21.getValue();
               var13.removed = var14.toRemovedArray();
               var13.updates = var14.toUpdatesArray();
            }

            var6.updates.clear();
            var6.packetReceiver.writeNoCache(var16);
         }
      }
   }

   class="kw">public class="kw">static class Visible class="kw">implements Component<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final StampedLock lock = new StampedLock();
      @Nonnull
      class="kw">public Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> previousVisibleTo = new Reference2ObjectOpenHashMap();
      @Nonnull
      class="kw">public Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> visibleTo = new Reference2ObjectOpenHashMap();
      @Nonnull
      class="kw">public Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> newlyVisibleTo = new Reference2ObjectOpenHashMap();

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

      @Nonnull
      class="kw">public class="kw">static ComponentType<EntityStore, EntityTrackerSystems.Visible> getComponentType() {
         class="kw">return EntityModule.get().getVisibleComponentType();
      }

      @Nonnull
      @Override
      class="kw">public Component<EntityStore> clone() {
         class="kw">return new EntityTrackerSystems.Visible();
      }

      class="kw">public void addViewerParallel(@Nonnull Ref<EntityStore> var1, @Nonnull EntityTrackerSystems.EntityViewer var2) {
         long var3 = this.lock.writeLock();

         try {
            this.visibleTo.put(var1, var2);
            if (!this.previousVisibleTo.containsKey(var1)) {
               this.newlyVisibleTo.put(var1, var2);
            }
         } class="kw">finally {
            this.lock.unlockWrite(var3);
         }
      }
   }
}