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

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.component.Store;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.ComponentContext;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.ISensorEntityCollector;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.ISensorEntityPrioritiser;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.SensorWithEntityFilters;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.entity.builders.BuilderSensorEntityBase;
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.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.role.support.DebugSupport;
class="kw">import com.hypixel.hytale.server.npc.sensorinfo.EntityPositionProvider;
class="kw">import com.hypixel.hytale.server.npc.sensorinfo.InfoProvider;
class="kw">import com.hypixel.hytale.server.npc.util.EntityDetectionUtil;
class="kw">import com.hypixel.hytale.server.npc.util.IEntityByPriorityFilter;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class="kw">abstract class SensorEntityBase class="kw">extends SensorWithEntityFilters {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
   @Nullable
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, NPCEntity> NPC_COMPONENT_TYPE = NPCEntity.getComponentType();
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, Player> PLAYER_COMPONENT_TYPE = Player.getComponentType();
   class="kw">protected class="kw">static class="kw">final ComponentType<EntityStore, DeathComponent> DEATH_COMPONENT_TYPE = DeathComponent.getComponentType();
   class="kw">protected class="kw">final double range;
   class="kw">protected class="kw">final double minRange;
   class="kw">protected class="kw">final boolean useProjectedDistance;
   class="kw">protected class="kw">final boolean lockOnTarget;
   class="kw">protected class="kw">final boolean lockRebind;
   class="kw">protected class="kw">final boolean multiTarget;
   class="kw">protected class="kw">final boolean autoUnlockTarget;
   class="kw">protected class="kw">final boolean onlyLockedTarget;
   class="kw">protected class="kw">final int lockedTargetSlot;
   class="kw">protected class="kw">final int ignoredTargetSlot;
   class="kw">protected class="kw">final ISensorEntityPrioritiser prioritiser;
   class="kw">protected IEntityByPriorityFilter npcPrioritiser;
   class="kw">protected IEntityByPriorityFilter playerPrioritiser;
   @Nullable
   class="kw">protected class="kw">final ISensorEntityCollector collector;
   class="kw">protected int ownRole;
   class="kw">protected class="kw">final EntityPositionProvider positionProvider = new EntityPositionProvider();
   class="kw">protected int currentVisSensorColorIndex = -1;
   class="kw">protected class="kw">final float visViewAngle;
   class="kw">protected class="kw">final boolean includeDead;

   class="kw">public SensorEntityBase(@Nonnull BuilderSensorEntityBase var1, ISensorEntityPrioritiser var2, @Nonnull BuilderSupport var3) {
      super(var1, var1.getFilters(var3, var2, ComponentContext.SensorEntity));
      this.range = var1.getRange(var3);
      this.minRange = var1.getMinRange(var3);
      this.lockOnTarget = var1.isLockOnTarget(var3);
      this.lockRebind = var1.isLockRebind(var3);
      this.multiTarget = var1.isMultiTarget(var3);
      this.autoUnlockTarget = var1.isAutoUnlockTarget(var3);
      this.onlyLockedTarget = var1.isOnlyLockedTarget(var3);
      this.useProjectedDistance = var1.isUseProjectedDistance(var3);
      this.lockedTargetSlot = var1.getLockedTargetSlot(var3);
      this.ignoredTargetSlot = var1.getIgnoredTargetSlot(var3);
      this.prioritiser = var2;
      this.collector = var1.getCollector(var3);
      this.visViewAngle = this.findViewAngleFromFilters();
      this.includeDead = this.hasDeathFilter();
      this.positionProvider.setIncludeDead(this.includeDead);
   }

   @Override
   class="kw">public boolean matches(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, double var3, @Nonnull Store<EntityStore> var5) {
      if (!super.matches(var1, var2, var3, var5)) {
         this.positionProvider.clear();
         this.currentVisSensorColorIndex = -1;
         class="kw">return false;
      }

      TransformComponent var6 = var5.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
      assert var6 != null;
      Vector3d var7 = var6.getPosition();
      this.ownRole = var2.getRoleIndex();
      if (this.multiTarget) {
         this.positionProvider.clearTargets();
      }

      DebugSupport var8 = var2.getDebugSupport();
      if (var8.isVisSensorRanges()) {
         this.currentVisSensorColorIndex = var8.recordSensorRange(this.range, this.minRange, this.visViewAngle);
      } else {
         this.currentVisSensorColorIndex = -1;
      }

      if (this.ignoredTargetSlot == Integer.MIN_VALUE || this.ignoredTargetSlot != this.lockedTargetSlot) {
         Ref var9 = this.filterLockedEntity(var1, var7, var2, var5);
         if (var9 != null) {
            this.collector.init(var1, var2, var5);
            if (!this.collector.terminateOnFirstMatch() || this.multiTarget) {
               this.findPlayerOrEntity(var1, var7, var2, var5);
            }

            this.collector.cleanup();
            Ref var10 = this.positionProvider.setTarget(var9, var5);
            if (this.multiTarget && var10 != null) {
               this.positionProvider.promotePrimary(var10);
            }

            class="kw">return var10 != null;
         }
      }

      if (this.onlyLockedTarget) {
         this.positionProvider.clear();
         class="kw">return false;
      }

      this.collector.init(var1, var2, var5);
      Ref var11 = this.findPlayerOrEntity(var1, var7, var2, var5);
      this.collector.cleanup();
      if (var11 == null) {
         this.positionProvider.clear();
         class="kw">return false;
      }

      this.positionProvider.setTarget(var11, var5);
      if (this.multiTarget) {
         this.positionProvider.promotePrimary(var11);
      }

      if (this.lockOnTarget) {
         var2.getMarkedEntitySupport().setMarkedEntity(this.lockedTargetSlot, var11, this.lockRebind, var5);
      }

      class="kw">return true;
   }

   @Override
   class="kw">public void done() {
      this.positionProvider.clear();
   }

   @Override
   class="kw">public InfoProvider getSensorInfo() {
      class="kw">return this.positionProvider;
   }

   @Override
   class="kw">public void registerWithSupport(@Nonnull ExecutionSupport var1) {
      super.registerWithSupport(var1);
      if (this.isGetPlayers()) {
         var1.getPositionCache().requirePlayerDistanceSorted(this.range);
      }

      if (this.isGetNPCs()) {
         var1.getPositionCache().requireEntityDistanceSorted(this.range);
      }

      this.prioritiser.registerWithSupport(var1);
      this.collector.registerWithSupport(var1);
   }

   @Override
   class="kw">public void motionControllerChanged(
      @Nullable Ref<EntityStore> var1, @Nonnull NPCEntity var2, MotionController var3, @Nullable ComponentAccessor<EntityStore> var4
   ) {
      super.motionControllerChanged(var1, var2, var3, var4);
      this.prioritiser.motionControllerChanged(var1, var2, var3, var4);
      this.collector.motionControllerChanged(var1, var2, var3, var4);
   }

   @Override
   class="kw">public void loaded(ExecutionSupport var1) {
      super.loaded(var1);
      this.prioritiser.loaded(var1);
      this.collector.loaded(var1);
   }

   @Override
   class="kw">public void spawned(ExecutionSupport var1) {
      super.spawned(var1);
      this.prioritiser.spawned(var1);
      this.collector.spawned(var1);
   }

   @Override
   class="kw">public void unloaded(ExecutionSupport var1) {
      super.unloaded(var1);
      this.prioritiser.unloaded(var1);
      this.collector.unloaded(var1);
   }

   @Override
   class="kw">public void removed(ExecutionSupport var1) {
      super.removed(var1);
      this.prioritiser.removed(var1);
      this.collector.removed(var1);
   }

   @Override
   class="kw">public void teleported(ExecutionSupport var1, World var2, World var3) {
      super.teleported(var1, var2, var3);
      this.prioritiser.teleported(var1, var2, var3);
      this.collector.teleported(var1, var2, var3);
   }

   class="kw">protected void initialisePrioritiser() {
      this.npcPrioritiser = this.isGetNPCs() ? this.prioritiser.getNPCPrioritiser() : null;
      this.playerPrioritiser = this.isGetPlayers() ? this.prioritiser.getPlayerPrioritiser() : null;
   }

   class="kw">protected class="kw">abstract boolean isGetPlayers();

   class="kw">protected class="kw">abstract boolean isGetNPCs();

   class="kw">protected boolean isExcludingOwnType() {
      class="kw">return false;
   }

   @Nullable
   class="kw">protected Ref<EntityStore> filterLockedEntity(
      @Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, @Nonnull ExecutionSupport var3, @Nonnull Store<EntityStore> var4
   ) {
      Ref var5 = this.lockedTargetSlot >= 0 ? var3.getMarkedEntitySupport().getMarkedEntityRef(this.lockedTargetSlot) : null;
      if (var5 == null) {
         class="kw">return null;
      }

      if (this.filterEntityWithRange(var1, var5, var2, var3, var4)) {
         class="kw">return var5;
      }

      if (this.autoUnlockTarget) {
         var3.getMarkedEntitySupport().clearMarkedEntity(this.lockedTargetSlot);
      }

      class="kw">return null;
   }

   class="kw">protected boolean filterEntityWithRange(
      @Nonnull Ref<EntityStore> var1, @Nonnull Ref<EntityStore> var2, @Nonnull Vector3d var3, @Nonnull ExecutionSupport var4, @Nonnull Store<EntityStore> var5
   ) {
      Player var6 = var5.getComponent(var2, Player.getComponentType());
      if (var6 != null) {
         if (!this.isGetPlayers()) {
            class="kw">return false;
         }

         if (!EntityDetectionUtil.isDetectableByNPCs(var2, var5, var6)) {
            class="kw">return false;
         }
      } else {
         if (!var5.getArchetype(var2).contains(NPC_COMPONENT_TYPE)) {
            class="kw">return false;
         }

         if (!this.isGetNPCs()) {
            class="kw">return false;
         }
      }

      TransformComponent var7 = var5.getComponent(var2, TRANSFORM_COMPONENT_TYPE);
      assert var7 != null;
      Vector3d var8 = var7.getPosition();
      double var9 = this.useProjectedDistance
         ? var4.getMotionContextSupport().getActiveMotionController().getSquaredDistance(var3, var8, true)
         : var3.distanceSquared(var8);
      class="kw">return !(var9 < this.minRange * this.minRange) && !(var9 > this.range * this.range) ? this.filterEntity(var1, var2, var4, var5) : false;
   }

   class="kw">protected boolean filterEntity(
      @Nonnull Ref<EntityStore> var1, @Nonnull Ref<EntityStore> var2, @Nonnull ExecutionSupport var3, @Nonnull Store<EntityStore> var4
   ) {
      if (!this.includeDead && var4.getArchetype(var2).contains(DEATH_COMPONENT_TYPE)) {
         class="kw">return false;
      }

      NPCEntity var5 = var4.getComponent(var2, NPC_COMPONENT_TYPE);
      class="kw">return this.isExcludingOwnType() && var5 != null && this.ownRole == var5.getRoleIndex() ? false : this.matchesFilters(var1, var2, var3, var4);
   }

   class="kw">protected boolean filterPrioritisedPlayer(
      @Nonnull Ref<EntityStore> var1, @Nonnull Ref<EntityStore> var2, @Nonnull ExecutionSupport var3, @Nonnull Store<EntityStore> var4
   ) {
      class="kw">return this.filterPrioritisedEntity(var1, var2, var3, var4, this.playerPrioritiser);
   }

   class="kw">protected boolean filterPrioritisedNPC(
      @Nonnull Ref<EntityStore> var1, @Nonnull Ref<EntityStore> var2, @Nonnull ExecutionSupport var3, @Nonnull Store<EntityStore> var4
   ) {
      class="kw">return this.filterPrioritisedEntity(var1, var2, var3, var4, this.npcPrioritiser);
   }

   class="kw">protected boolean filterPrioritisedEntity(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull ExecutionSupport var3,
      @Nonnull Store<EntityStore> var4,
      @Nonnull IEntityByPriorityFilter var5
   ) {
      boolean var6 = this.filterEntity(var1, var2, var3, var4);
      if (!var6) {
         this.collector.collectNonMatching(var2, var4);
         this.recordEntityVisData(var2, var3, false);
         class="kw">return false;
      }

      boolean var7 = var5.test(var1, var2, var4);
      if (var7) {
         this.collector.collectMatching(var1, var2, var4);
         if (this.multiTarget) {
            this.positionProvider.addTarget(var2, var4);
         }
      } else {
         this.collector.collectNonMatching(var2, var4);
      }

      this.recordEntityVisData(var2, var3, var7);
      class="kw">return this.collector.terminateOnFirstMatch() && !this.multiTarget && var7;
   }

   class="kw">private void recordEntityVisData(@Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, boolean var3) {
      if (this.currentVisSensorColorIndex >= 0) {
         var2.getDebugSupport().recordEntityCheck(var1, this.currentVisSensorColorIndex, var3);
      }
   }

   @Nullable
   class="kw">protected Ref<EntityStore> findPlayerOrEntity(
      @Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, @Nonnull ExecutionSupport var3, @Nonnull Store<EntityStore> var4
   ) {
      Ref var5 = null;
      Ref var6 = null;
      Ref var7 = this.ignoredTargetSlot >= 0 ? var3.getMarkedEntitySupport().getMarkedEntityRef(this.ignoredTargetSlot) : null;
      if (this.isGetPlayers()) {
         this.playerPrioritiser.init(var3);
         var3.getPositionCache()
            .processPlayersInRange(
               var1,
               this.minRange,
               this.range,
               this.useProjectedDistance,
               var7,
               var3,
               (var0, var1x, var2x, var3x) -> var0.filterPrioritisedPlayer(var3x, var1x, var2x, var3x.getStore()),
               this,
               var1,
               var4
            );
         var5 = this.playerPrioritiser.getHighestPriorityTarget();
         this.playerPrioritiser.cleanup();
      }

      if (this.isGetNPCs()) {
         this.npcPrioritiser.init(var3);
         var3.getPositionCache()
            .processNPCsInRange(
               var1,
               this.minRange,
               this.range,
               this.useProjectedDistance,
               var7,
               var3,
               (var0, var1x, var2x, var3x) -> var0.filterPrioritisedNPC(var3x, var1x, var2x, var3x.getStore()),
               this,
               var1,
               var4
            );
         var6 = this.npcPrioritiser.getHighestPriorityTarget();
         this.npcPrioritiser.cleanup();
      }

      Ref var8;
      if (var6 == null) {
         var8 = var5;
      } else if (var5 == null) {
         var8 = var6;
      } else {
         var8 = this.prioritiser.pickTarget(var1, var3, var2, var5, var6, this.useProjectedDistance, var4);
      }

      class="kw">return var8;
   }
}