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

class="kw">import com.hypixel.hytale.common.collection.BucketItem;
class="kw">import com.hypixel.hytale.common.collection.BucketItemPool;
class="kw">import com.hypixel.hytale.common.collection.BucketList;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.function.consumer.DoubleQuadObjectConsumer;
class="kw">import com.hypixel.hytale.function.consumer.QuadConsumer;
class="kw">import com.hypixel.hytale.function.consumer.TriConsumer;
class="kw">import com.hypixel.hytale.function.predicate.QuadObjectDoublePredicate;
class="kw">import com.hypixel.hytale.function.predicate.QuadPredicate;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.components.SortBufferProviderResource;
class="kw">import com.hypixel.hytale.server.npc.instructions.ExecutionSupport;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import java.util.Set;
class="kw">import java.util.function.BiPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class EntityList class="kw">extends BucketList<Ref<EntityStore>> {
   class="kw">protected class="kw">static class="kw">final int BUCKET_COUNT = 6;
   class="kw">protected class="kw">static class="kw">final int BUCKET_DISTANCE_NEAR = 5;
   class="kw">protected class="kw">static class="kw">final int BUCKET_DISTANCE_NEARER = 3;
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
   @Nonnull
   class="kw">protected class="kw">final BiPredicate<Ref<EntityStore>, ComponentAccessor<EntityStore>> validator;
   class="kw">protected IntArrayList bucketRanges;
   class="kw">protected int maxDistanceUnsorted;
   class="kw">protected int maxDistanceSorted;
   class="kw">protected int maxDistanceAvoidance;
   class="kw">protected int squaredMaxDistanceSorted;
   class="kw">protected int squaredMaxDistanceAvoidance;
   class="kw">protected int squaredMaxDistanceUnsorted;
   class="kw">protected int searchRadius;

   class="kw">public EntityList(@Nullable BucketItemPool<Ref<EntityStore>> var1, @Nonnull BiPredicate<Ref<EntityStore>, ComponentAccessor<EntityStore>> var2) {
      super(var1);
      this.validator = var2;
      this.bucketRanges = new IntArrayList();
   }

   class="kw">public int getMaxDistanceUnsorted() {
      class="kw">return this.maxDistanceUnsorted;
   }

   class="kw">public int getMaxDistanceSorted() {
      class="kw">return this.maxDistanceSorted;
   }

   class="kw">public int getMaxDistanceAvoidance() {
      class="kw">return this.maxDistanceAvoidance;
   }

   class="kw">public int getSearchRadius() {
      class="kw">return this.searchRadius;
   }

   class="kw">public IntArrayList getBucketRanges() {
      class="kw">return this.bucketRanges;
   }

   @Override
   class="kw">public void reset() {
      this.maxDistanceUnsorted = 0;
      this.maxDistanceSorted = 0;
      this.maxDistanceAvoidance = 0;
      this.squaredMaxDistanceSorted = 0;
      this.squaredMaxDistanceUnsorted = 0;
      this.squaredMaxDistanceAvoidance = 0;
      this.searchRadius = 0;
      this.squaredMaxDistance = 0;
      super.clear();
      this.bucketRanges.clear();
   }

   class="kw">public int requireDistanceSorted(int var1) {
      var1 = MathUtil.fastCeil(var1);
      if (this.maxDistanceSorted < var1) {
         this.maxDistanceSorted = var1;
      }

      addBucketDistance(this.bucketRanges, 6, var1);
      class="kw">return var1;
   }

   class="kw">public int requireDistanceUnsorted(int var1) {
      var1 = MathUtil.fastCeil(var1);
      if (this.maxDistanceUnsorted < var1) {
         this.maxDistanceUnsorted = var1;
      }

      addBucketDistance(this.bucketRanges, 6, var1);
      class="kw">return var1;
   }

   class="kw">public int requireDistanceAvoidance(int var1) {
      var1 = MathUtil.fastCeil(var1);
      if (this.maxDistanceAvoidance < var1) {
         this.maxDistanceAvoidance = var1;
      }

      addBucketDistance(this.bucketRanges, 6, var1);
      class="kw">return var1;
   }

   class="kw">public void finalizeConfiguration() {
      this.squaredMaxDistanceSorted = this.maxDistanceSorted * this.maxDistanceSorted;
      this.squaredMaxDistanceUnsorted = this.maxDistanceUnsorted * this.maxDistanceUnsorted;
      this.squaredMaxDistanceAvoidance = this.maxDistanceAvoidance * this.maxDistanceAvoidance;
      this.searchRadius = MathUtil.maxValue(this.maxDistanceAvoidance, this.maxDistanceSorted, this.maxDistanceUnsorted);
      this.squaredMaxDistance = this.searchRadius * this.searchRadius;
      if (this.searchRadius != 0) {
         int var1 = this.maxDistanceAvoidance > 0 ? this.maxDistanceAvoidance : -1;
         if (var1 > 0) {
            addBucketDistance(this.bucketRanges, 6, var1);
         }

         if (this.maxDistanceSorted > 3) {
            addBucketDistance(this.bucketRanges, 6, 3, var1);
            if (this.maxDistanceSorted > 5) {
               addBucketDistance(this.bucketRanges, 6, 5, var1);
            }
         }

         super.configureWithPreSortedArray(this.bucketRanges.toIntArray());
      }
   }

   class="kw">public void add(@Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, @Nonnull CommandBuffer<EntityStore> var3) {
      if (this.validator.test(var1, var3)) {
         TransformComponent var4 = var3.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
         assert var4 != null;
         double var5 = var2.distanceSquared(var4.getPosition());
         this.add(var1, var5);
      }
   }

   class="kw">public <T, U, V> void forEachEntity(
      @Nonnull DoubleQuadObjectConsumer<Ref<EntityStore>, T, U, V> var1, T var2, U var3, V var4, double var5, ComponentAccessor<EntityStore> var7
   ) {
      for (BucketList.Bucket var11 : this.buckets) {
         if (!var11.isEmpty()) {
            BucketItem[] var12 = var11.getItems();
            int var13 = 0;

            for (int var14 = var11.size(); var13 < var14; var13++) {
               Ref var15 = this.validateEntityRef(var12[var13], var7);
               if (var15 != null) {
                  var1.accept(var5, var15, var2, var3, var4);
               }
            }
         }
      }
   }

   class="kw">public <T, U, V, R> void forEachEntityUnordered(
      double var1,
      @Nonnull QuadPredicate<Ref<EntityStore>, T, U, ComponentAccessor<EntityStore>> var3,
      @Nonnull QuadConsumer<Ref<EntityStore>, T, V, R> var4,
      T var5,
      U var6,
      V var7,
      R var8,
      ComponentAccessor<EntityStore> var9
   ) {
      int var10 = (int)(var1 * var1);
      int var11 = this.getLastBucketIndex(var10);

      for (int var12 = 0; var12 <= var11; var12++) {
         BucketList.Bucket var13 = this.buckets[var12];
         if (!var13.isEmpty()) {
            BucketItem[] var14 = var13.getItems();
            if (var13.isUnsorted()) {
               int var19 = 0;

               for (int var20 = var13.size(); var19 < var20; var19++) {
                  BucketItem var21 = var14[var19];
                  if (var21.squaredDistance < var10) {
                     Ref var22 = this.validateEntityRef(var21, var9);
                     if (var22 != null && var3.test(var22, var5, var6, var9)) {
                        var4.accept(var22, var5, var7, var8);
                     }
                  }
               }
            } else {
               int var15 = 0;

               for (int var16 = var13.size(); var15 < var16; var15++) {
                  BucketItem var17 = var14[var15];
                  if (var17.squaredDistance >= var10) {
                     break;
                  }

                  Ref var18 = this.validateEntityRef(var17, var9);
                  if (var18 != null && var3.test(var18, var5, var6, var9)) {
                     var4.accept(var18, var5, var7, var8);
                  }
               }
            }
         }
      }
   }

   class="kw">public <T> void forEachEntityAvoidance(
      @Nonnull Set<Ref<EntityStore>> var1, @Nonnull TriConsumer<Ref<EntityStore>, T, CommandBuffer<EntityStore>> var2, T var3, CommandBuffer<EntityStore> var4
   ) {
      int var5 = this.getLastBucketIndex(this.squaredMaxDistanceAvoidance);

      for (int var6 = 0; var6 <= var5; var6++) {
         BucketList.Bucket var7 = this.buckets[var6];
         if (!var7.isEmpty()) {
            BucketItem[] var8 = var7.getItems();
            if (var7.isUnsorted()) {
               int var13 = 0;

               for (int var14 = var7.size(); var13 < var14; var13++) {
                  BucketItem var15 = var8[var13];
                  if (var15.squaredDistance <= this.squaredMaxDistanceAvoidance) {
                     Ref var16 = this.validateEntityRef(var15, var4);
                     if (var16 != null && !var1.contains(var16)) {
                        var2.accept(var16, var3, var4);
                     }
                  }
               }
            } else {
               int var9 = 0;

               for (int var10 = var7.size(); var9 < var10; var9++) {
                  BucketItem var11 = var8[var9];
                  if (var11.squaredDistance > this.squaredMaxDistanceAvoidance) {
                     break;
                  }

                  Ref var12 = this.validateEntityRef(var11, var4);
                  if (var12 != null && !var1.contains(var12)) {
                     var2.accept(var12, var3, var4);
                  }
               }
            }
         }
      }
   }

   class="kw">public <T, U> void forEachEntityAvoidance(
      @Nonnull Set<Ref<EntityStore>> var1,
      @Nonnull QuadConsumer<Ref<EntityStore>, T, U, CommandBuffer<EntityStore>> var2,
      T var3,
      U var4,
      CommandBuffer<EntityStore> var5
   ) {
      int var6 = this.getLastBucketIndex(this.squaredMaxDistanceAvoidance);

      for (int var7 = 0; var7 <= var6; var7++) {
         BucketList.Bucket var8 = this.buckets[var7];
         if (!var8.isEmpty()) {
            BucketItem[] var9 = var8.getItems();
            if (var8.isUnsorted()) {
               int var14 = 0;

               for (int var15 = var8.size(); var14 < var15; var14++) {
                  BucketItem var16 = var9[var14];
                  if (var16.squaredDistance <= this.squaredMaxDistanceAvoidance) {
                     Ref var17 = this.validateEntityRef(var16, var5);
                     if (var17 != null && !var1.contains(var17)) {
                        var2.accept(var17, var3, var4, var5);
                     }
                  }
               }
            } else {
               int var10 = 0;

               for (int var11 = var8.size(); var10 < var11; var10++) {
                  BucketItem var12 = var9[var10];
                  if (var12.squaredDistance > this.squaredMaxDistanceAvoidance) {
                     break;
                  }

                  Ref var13 = this.validateEntityRef(var12, var5);
                  if (var13 != null && !var1.contains(var13)) {
                     var2.accept(var13, var3, var4, var5);
                  }
               }
            }
         }
      }
   }

   class="kw">public <S, T> int countEntitiesInRange(
      double var1,
      double var3,
      int var5,
      @Nonnull QuadPredicate<S, Ref<EntityStore>, T, ComponentAccessor<EntityStore>> var6,
      S var7,
      T var8,
      ComponentAccessor<EntityStore> var9
   ) {
      int var10 = (int)(var1 * var1);
      int var11 = this.getFirstBucketIndex(var10);
      if (var11 < 0) {
         class="kw">return 0;
      }

      int var12 = (int)(var3 * var3);
      int var13 = this.getLastBucketIndex(var12);
      int var14 = 0;

      for (int var15 = var11; var15 <= var13 && var14 < var5; var15++) {
         BucketList.Bucket var16 = this.buckets[var15];
         if (!var16.isEmpty()) {
            BucketItem[] var17 = var16.getItems();
            if (var16.isUnsorted()) {
               int var18 = 0;

               for (int var19 = var16.size(); var18 < var19; var18++) {
                  BucketItem var20 = var17[var18];
                  double var21 = var20.squaredDistance;
                  if (!(var21 < var10) && !(var21 >= var12)) {
                     Ref var23 = this.validateEntityRef(var20, var9);
                     if (var23 != null && var6.test(var7, var23, var8, var9)) {
                        if (++var14 >= var5) {
                           class="kw">return var14;
                        }
                     }
                  }
               }
            } else {
               int var24 = 0;

               for (int var25 = var16.size(); var24 < var25; var24++) {
                  BucketItem var26 = var17[var24];
                  double var27 = var26.squaredDistance;
                  if (!(var27 < var10)) {
                     if (var27 >= var12) {
                        class="kw">return var14;
                     }

                     Ref var28 = this.validateEntityRef(var26, var9);
                     if (var28 != null && var6.test(var7, var28, var8, var9)) {
                        if (++var14 >= var5) {
                           class="kw">return var14;
                        }
                     }
                  }
               }
            }
         }
      }

      class="kw">return var14;
   }

   @Nullable
   class="kw">public Ref<EntityStore> getClosestEntityInRange(
      double var1, double var3, @Nonnull Predicate<Ref<EntityStore>> var5, @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      int var7 = (int)(var1 * var1);
      int var8 = this.getFirstBucketIndex(var7);
      if (var8 < 0) {
         class="kw">return null;
      }

      int var9 = (int)(var3 * var3);
      int var10 = this.getLastBucketIndex(var9);
      BucketList.SortBufferProvider var11 = var6.getResource(SortBufferProviderResource.getResourceType()).getSortBufferProvider();

      for (int var12 = var8; var12 <= var10; var12++) {
         BucketList.Bucket var13 = this.buckets[var12];
         if (!var13.isEmpty()) {
            if (var13.isUnsorted()) {
               var13.sort(var11);
            }

            BucketItem[] var14 = var13.getItems();
            int var15 = 0;

            for (int var16 = var13.size(); var15 < var16; var15++) {
               BucketItem var17 = var14[var15];
               double var18 = var17.squaredDistance;
               if (!(var18 < var7)) {
                  if (var18 >= var9) {
                     class="kw">return null;
                  }

                  Ref var20 = this.validateEntityRef(var17, var6);
                  if (var20 != null && var5.test(var20)) {
                     class="kw">return var20;
                  }
               }
            }
         }
      }

      class="kw">return null;
   }

   @Nullable
   class="kw">public <S, T> Ref<EntityStore> getClosestEntityInRange(
      @Nullable Ref<EntityStore> var1,
      double var2,
      double var4,
      @Nonnull QuadPredicate<S, Ref<EntityStore>, ExecutionSupport, T> var6,
      ExecutionSupport var7,
      S var8,
      T var9,
      @Nonnull ComponentAccessor<EntityStore> var10
   ) {
      int var11 = (int)(var2 * var2);
      int var12 = this.getFirstBucketIndex(var11);
      if (var12 < 0) {
         class="kw">return null;
      }

      int var13 = (int)(var4 * var4);
      int var14 = this.getLastBucketIndex(var13);
      BucketList.SortBufferProvider var15 = var10.getResource(SortBufferProviderResource.getResourceType()).getSortBufferProvider();
      if (var1 == null) {
         for (int var16 = var12; var16 <= var14; var16++) {
            BucketList.Bucket var17 = this.buckets[var16];
            if (!var17.isEmpty()) {
               if (var17.isUnsorted()) {
                  var17.sort(var15);
               }

               BucketItem[] var18 = var17.getItems();
               int var19 = 0;

               for (int var20 = var17.size(); var19 < var20; var19++) {
                  BucketItem var21 = var18[var19];
                  double var22 = var21.squaredDistance;
                  if (!(var22 < var11)) {
                     if (var22 >= var13) {
                        class="kw">return null;
                     }

                     Ref var24 = this.validateEntityRef(var21, var10);
                     if (var24 != null && var6.test(var8, var24, var7, var9)) {
                        class="kw">return var24;
                     }
                  }
               }
            }
         }
      } else {
         for (int var25 = var12; var25 <= var14; var25++) {
            BucketList.Bucket var26 = this.buckets[var25];
            if (!var26.isEmpty()) {
               if (var26.isUnsorted()) {
                  var26.sort(var15);
               }

               BucketItem[] var27 = var26.getItems();
               int var28 = 0;

               for (int var29 = var26.size(); var28 < var29; var28++) {
                  BucketItem var30 = var27[var28];
                  double var31 = var30.squaredDistance;
                  if (!(var31 < var11)) {
                     if (var31 >= var13) {
                        class="kw">return null;
                     }

                     Ref var32 = this.validateEntityRef(var30, var10);
                     if (var32 != null && !var32.equals(var1) && var6.test(var8, var32, var7, var9)) {
                        class="kw">return var32;
                     }
                  }
               }
            }
         }
      }

      class="kw">return null;
   }

   @Nullable
   class="kw">public <S, T> Ref<EntityStore> getClosestEntityInRangeProjected(
      @Nonnull Ref<EntityStore> var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull MotionController var3,
      double var4,
      double var6,
      @Nonnull QuadPredicate<S, Ref<EntityStore>, ExecutionSupport, T> var8,
      ExecutionSupport var9,
      S var10,
      T var11,
      @Nonnull ComponentAccessor<EntityStore> var12
   ) {
      int var13 = (int)(var4 * var4);
      int var14 = this.getFirstBucketIndex(var13);
      if (var14 < 0) {
         class="kw">return null;
      }

      int var15 = (int)(var6 * var6);
      int var16 = this.getLastBucketIndex(var15);
      Vector3d var17 = var12.getComponent(var1, TRANSFORM_COMPONENT_TYPE).getPosition();
      BucketList.SortBufferProvider var18 = var12.getResource(SortBufferProviderResource.getResourceType()).getSortBufferProvider();
      if (var2 == null) {
         for (int var19 = var14; var19 <= var16; var19++) {
            BucketList.Bucket var20 = this.buckets[var19];
            if (!var20.isEmpty()) {
               if (var20.isUnsorted()) {
                  var20.sort(var18);
               }

               BucketItem[] var21 = var20.getItems();
               int var22 = 0;

               for (int var23 = var20.size(); var22 < var23; var22++) {
                  BucketItem var24 = var21[var22];
                  Ref var25 = this.validateEntityRef(var24, var12);
                  if (var25 != null) {
                     double var26 = var3.waypointDistanceSquared(var12.getComponent(var25, TRANSFORM_COMPONENT_TYPE).getPosition(), var17);
                     if (!(var26 < var13)) {
                        if (var26 >= var15) {
                           class="kw">return null;
                        }

                        if (var8.test(var10, var25, var9, var11)) {
                           class="kw">return var25;
                        }
                     }
                  }
               }
            }
         }
      } else {
         for (int var28 = var14; var28 <= var16; var28++) {
            BucketList.Bucket var29 = this.buckets[var28];
            if (!var29.isEmpty()) {
               if (var29.isUnsorted()) {
                  var29.sort(var18);
               }

               BucketItem[] var30 = var29.getItems();
               int var31 = 0;

               for (int var32 = var29.size(); var31 < var32; var31++) {
                  BucketItem var33 = var30[var31];
                  Ref var34 = this.validateEntityRef(var33, var12);
                  if (var34 != null && !var34.equals(var2)) {
                     double var35 = var3.waypointDistanceSquared(var12.getComponent(var34, TRANSFORM_COMPONENT_TYPE).getPosition(), var17);
                     if (!(var35 < var13)) {
                        if (var35 >= var15) {
                           class="kw">return null;
                        }

                        if (var8.test(var10, var34, var9, var11)) {
                           class="kw">return var34;
                        }
                     }
                  }
               }
            }
         }
      }

      class="kw">return null;
   }

   class="kw">public <S, T> boolean testAnyEntity(
      double var1,
      @Nonnull QuadObjectDoublePredicate<S, Ref<EntityStore>, T, ComponentAccessor<EntityStore>> var3,
      S var4,
      T var5,
      ComponentAccessor<EntityStore> var6
   ) {
      class="kw">return this.testAnyEntityDistanceSquared(var1 * var1, var3, var4, var5, var1, var6);
   }

   class="kw">public <S, T> boolean testAnyEntityDistanceSquared(
      double var1,
      @Nonnull QuadObjectDoublePredicate<S, Ref<EntityStore>, T, ComponentAccessor<EntityStore>> var3,
      S var4,
      T var5,
      ComponentAccessor<EntityStore> var6
   ) {
      class="kw">return this.testAnyEntityDistanceSquared(var1, var3, var4, var5, var1, var6);
   }

   class="kw">public <S, T> boolean testAnyEntityDistanceSquared(
      double var1,
      @Nonnull QuadObjectDoublePredicate<S, Ref<EntityStore>, T, ComponentAccessor<EntityStore>> var3,
      S var4,
      T var5,
      double var6,
      ComponentAccessor<EntityStore> var8
   ) {
      int var9 = this.getLastBucketIndex((int)var1);

      for (int var10 = 0; var10 <= var9; var10++) {
         BucketList.Bucket var11 = this.buckets[var10];
         if (!var11.isEmpty()) {
            BucketItem[] var12 = var11.getItems();
            if (var11.isUnsorted()) {
               int var17 = 0;

               for (int var18 = var11.size(); var17 < var18; var17++) {
                  BucketItem var19 = var12[var17];
                  if (var19.squaredDistance < var1) {
                     Ref var20 = this.validateEntityRef(var19, var8);
                     if (var20 != null && var3.test(var4, var20, var5, var8, var6)) {
                        class="kw">return true;
                     }
                  }
               }

               class="kw">return false;
            }

            int var13 = 0;

            for (int var14 = var11.size(); var13 < var14; var13++) {
               BucketItem var15 = var12[var13];
               if (var15.squaredDistance >= var1) {
                  break;
               }

               Ref var16 = this.validateEntityRef(var15, var8);
               if (var16 != null && var3.test(var4, var16, var5, var8, var6)) {
                  class="kw">return true;
               }
            }
         }
      }

      class="kw">return false;
   }

   @Nullable
   class="kw">protected Ref<EntityStore> validateEntityRef(@Nonnull BucketItem<Ref<EntityStore>> var1, ComponentAccessor<EntityStore> var2) {
      Ref var3 = var1.item;
      class="kw">return var3 != null && var3.isValid() && this.validator.test(var3, var2) ? var3 : null;
   }
}