class="kw">package com.hypixel.hytale.server.npc.systems;

class="kw">import com.hypixel.hytale.common.collection.BucketItemPool;
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.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.ResourceType;
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.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.CachedStatsComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.system.PlayerSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.flock.FlockMembership;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.decisionmaker.stateevaluator.StateEvaluator;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.npc.instructions.ExecutionSupport;
class="kw">import com.hypixel.hytale.server.npc.instructions.Instruction;
class="kw">import com.hypixel.hytale.server.npc.role.Role;
class="kw">import com.hypixel.hytale.server.npc.role.support.EntityList;
class="kw">import com.hypixel.hytale.server.npc.role.support.PositionCache;
class="kw">import com.hypixel.hytale.server.npc.statetransition.StateTransitionController;
class="kw">import com.hypixel.hytale.server.spawning.SpawningPlugin;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import java.util.function.Consumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

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

   class="kw">public class="kw">static void initialisePositionCache(@Nonnull ExecutionSupport var0, @Nonnull Role var1, @Nullable StateEvaluator var2, double var3) {
      PositionCache var5 = var0.getPositionCache();
      var5.reset(true);
      if (var1.isAvoidingEntities()) {
         double var6 = var1.getCollisionProbeDistance();
         var5.requireEntityDistanceAvoidance(var6);
         var5.requirePlayerDistanceAvoidance(var6);
      }

      if (var1.isApplySeparation()) {
         double var8 = var1.getSeparationDistance();
         var5.requireEntityDistanceAvoidance(var8);
         var5.requirePlayerDistanceAvoidance(var8);
      }

      if (var3 > 0.0) {
         var5.requireEntityDistanceAvoidance(var3);
         var5.requirePlayerDistanceAvoidance(var3);
      }

      registerInstructionsWithCache(var0, var1.getRootInstruction(), var1.getInteractionInstruction(), var1.getDeathInstruction(), var2);
   }

   class="kw">public class="kw">static void registerInstructionsWithCache(
      @Nonnull ExecutionSupport var0, @Nonnull Instruction var1, @Nullable Instruction var2, @Nullable Instruction var3, @Nullable StateEvaluator var4
   ) {
      PositionCache var5 = var0.getPositionCache();
      var1.registerWithSupport(var0);
      if (var2 != null) {
         var2.registerWithSupport(var0);
         var5.requirePlayerDistanceUnsorted(10.0);
      }

      if (var3 != null) {
         var3.registerWithSupport(var0);
      }

      StateTransitionController var6 = var0.getStateSupport().getStateTransitionController();
      if (var6 != null) {
         var6.registerWithSupport(var0);
      }

      if (var4 != null) {
         var4.setupNPC(var0);
      }

      for (Consumer var9 : var5.getExternalRegistrations()) {
         var9.accept(var0);
      }

      var5.finalizeConfiguration();
   }

   class="kw">public class="kw">static class OnFlockJoinSystem class="kw">extends RefChangeSystem<EntityStore, FlockMembership> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, FlockMembership> flockMembershipComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, StateEvaluator> stateEvaluatorComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public OnFlockJoinSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1, @Nonnull ComponentType<EntityStore, FlockMembership> var2) {
         this.flockMembershipComponentType = var2;
         this.npcComponentType = var1;
         this.stateEvaluatorComponentType = StateEvaluator.getComponentType();
         this.query = Archetype.of(var1, var2);
      }

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

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

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull FlockMembership var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         NPCEntity var5 = var3.getComponent(var1, this.npcComponentType);
         assert var5 != null;
         Role var6 = var5.getRole();
         ExecutionSupport var7 = var6.acquireExecutionSupport(var1, var3);

         try {
            PositionCacheSystems.initialisePositionCache(var7, var6, var3.getComponent(var1, this.stateEvaluatorComponentType), var6.getFlockInfluenceRange());
         } class="kw">finally {
            var7.clearForReuse();
         }
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         FlockMembership var2,
         @Nonnull FlockMembership var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         NPCEntity var6 = var4.getComponent(var1, this.npcComponentType);
         assert var6 != null;
         Role var7 = var6.getRole();
         ExecutionSupport var8 = var7.acquireExecutionSupport(var1, var4);

         try {
            PositionCacheSystems.initialisePositionCache(var8, var7, var4.getComponent(var1, this.stateEvaluatorComponentType), var7.getFlockInfluenceRange());
         } class="kw">finally {
            var8.clearForReuse();
         }
      }

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

   class="kw">public class="kw">static class RoleActivateSystem class="kw">extends HolderSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, StateEvaluator> stateEvaluatorComponentType;

      class="kw">public RoleActivateSystem(@Nonnull ComponentType<EntityStore, NPCEntity> var1, @Nonnull ComponentType<EntityStore, StateEvaluator> var2) {
         this.npcComponentType = var1;
         this.stateEvaluatorComponentType = var2;
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         NPCEntity var4 = var1.getComponent(this.npcComponentType);
         assert var4 != null;
         Role var5 = var4.getRole();
         double var6;
         if (var1.getComponent(FlockMembership.getComponentType()) != null) {
            var6 = var5.getFlockInfluenceRange();
         } else {
            var6 = 0.0;
         }

         StateEvaluator var8 = var1.getComponent(this.stateEvaluatorComponentType);
         if (var8 != null) {
            var8.setupNPC(var1);
         }

         ExecutionSupport var9 = ExecutionSupport.acquire();
         var9.populateFromHolder(var1);

         try {
            PositionCacheSystems.initialisePositionCache(var9, var5, var8, var6);
         } class="kw">finally {
            var9.clearForReuse();
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
         PositionCache var4 = var1.getComponent(PositionCache.getComponentType());
         assert var4 != null;
         var4.reset(false);
      }

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

   class="kw">public class="kw">static class UpdateSystem class="kw">extends SteppableTickingSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ThreadLocal<BucketItemPool<Ref<EntityStore>>> BUCKET_POOL_THREAD_LOCAL = ThreadLocal.withInitial(BucketItemPool::new);
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType;
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> playerSpatialResource;
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> npcSpatialResource;
      @Nonnull
      class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> itemSpatialResource;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.AFTER, PlayerSpatialSystem.class, OrderPriority.CLOSEST),
         new SystemDependency<>(Order.BEFORE, RoleSystems.PreBehaviourSupportTickSystem.class)
      );

      class="kw">public UpdateSystem(@Nonnull ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var1) {
         this.transformComponentType = TransformComponent.getComponentType();
         this.playerSpatialResource = EntityModule.get().getPlayerSpatialResourceType();
         this.npcSpatialResource = var1;
         this.itemSpatialResource = EntityModule.get().getItemSpatialResourceType();
         this.query = Query.and(PositionCache.getComponentType(), this.transformComponentType);
      }

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

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

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

      @Override
      class="kw">public void steppedTick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var3.getReferenceTo(var2);
         PositionCache var7 = var3.getComponent(var2, PositionCache.getComponentType());
         assert var7 != null;
         var7.setBenchmarking(NPCPlugin.get().isBenchmarkingSensorSupport());
         CachedStatsComponent var8 = var3.getComponent(var2, CachedStatsComponent.getComponentType());
         if (var8 != null) {
            var7.setCouldBreathe(var8.isCanBreathe());
         }

         if (var7.tickPositionCacheNextUpdate(var1)) {
            var7.resetPositionCacheNextUpdate();
            TransformComponent var9 = var3.getComponent(var2, this.transformComponentType);
            assert var9 != null;
            Vector3d var10 = var9.getPosition();
            EntityList var11 = var7.getPlayers();
            if (var11.getSearchRadius() > 0) {
               SpatialResource var12 = var4.getResource(this.playerSpatialResource);
               var11.setBucketItemPool(BUCKET_POOL_THREAD_LOCAL.get());
               if (var7.isBenchmarking()) {
                  long var13 = System.nanoTime();
                  addEntities(var6, var10, var11, var12, var5);
                  long var15 = System.nanoTime();
                  NPCPlugin.get()
                     .collectSensorSupportPlayerList(
                        var7.getRoleIndex(), var15 - var13, var11.getMaxDistanceSorted(), var11.getMaxDistanceUnsorted(), var11.getMaxDistanceAvoidance(), 0
                     );
               } else {
                  addEntities(var6, var10, var11, var12, var5);
               }
            }

            EntityList var20 = var7.getNpcs();
            if (var20.getSearchRadius() > 0) {
               SpatialResource var21 = var4.getResource(this.npcSpatialResource);
               var20.setBucketItemPool(BUCKET_POOL_THREAD_LOCAL.get());
               if (var7.isBenchmarking()) {
                  long var14 = System.nanoTime();
                  addEntities(var6, var10, var20, var21, var5);
                  long var16 = System.nanoTime();
                  NPCPlugin.get()
                     .collectSensorSupportEntityList(
                        var7.getRoleIndex(), var16 - var14, var20.getMaxDistanceSorted(), var20.getMaxDistanceUnsorted(), var20.getMaxDistanceAvoidance(), 0
                     );
               } else {
                  addEntities(var6, var10, var20, var21, var5);
               }
            }

            double var22 = var7.getMaxDroppedItemDistance();
            if (var22 > 0.0) {
               SpatialResource var23 = var4.getResource(this.itemSpatialResource);
               List var25 = var7.getDroppedItemList();
               var25.clear();
               var23.getSpatialStructure().ordered(var10, (int)var22 + 1, var25);
            }

            double var24 = var7.getMaxSpawnMarkerDistance();
            if (var24 > 0.0) {
               SpatialResource var17 = var4.getResource(SpawningPlugin.get().getSpawnMarkerSpatialResource());
               List var18 = var7.getSpawnMarkerList();
               var18.clear();
               var17.getSpatialStructure().collect(var10, (int)var24 + 1, var18);
            }

            int var26 = var7.getMaxSpawnBeaconDistance();
            if (var26 > 0) {
               SpatialResource var27 = var4.getResource(SpawningPlugin.get().getManualSpawnBeaconSpatialResource());
               List var19 = var7.getSpawnBeaconList();
               var19.clear();
               var27.getSpatialStructure().ordered(var10, var26 + 1, var19);
            }
         }
      }

      class="kw">private class="kw">static void addEntities(
         @Nonnull Ref<EntityStore> var0,
         @Nonnull Vector3d var1,
         @Nonnull EntityList var2,
         @Nonnull SpatialResource<Ref<EntityStore>, EntityStore> var3,
         @Nonnull CommandBuffer<EntityStore> var4
      ) {
         List var5 = SpatialResource.getThreadLocalReferenceList();
         var3.getSpatialStructure().collect(var1, var2.getSearchRadius(), var5);

         for (Ref var7 : var5) {
            if (var7.isValid() && !var7.equals(var0)) {
               var2.add(var7, var1, var4);
            }
         }
      }
   }
}