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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
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.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.movement.builders.BuilderBodyMotionFind;
class="kw">import com.hypixel.hytale.server.npc.instructions.ExecutionSupport;
class="kw">import com.hypixel.hytale.server.npc.movement.Steering;
class="kw">import com.hypixel.hytale.server.npc.movement.controllers.MotionController;
class="kw">import com.hypixel.hytale.server.npc.movement.steeringforces.SteeringForcePursue;
class="kw">import com.hypixel.hytale.server.npc.navigation.AStarBase;
class="kw">import com.hypixel.hytale.server.npc.navigation.AStarNode;
class="kw">import com.hypixel.hytale.server.npc.navigation.AStarWithTarget;
class="kw">import com.hypixel.hytale.server.npc.sensorinfo.InfoProvider;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class BodyMotionFind class="kw">extends BodyMotionFindWithTarget {
   class="kw">protected class="kw">final double distance;
   class="kw">protected class="kw">final double distanceSquared;
   class="kw">protected class="kw">final boolean reachable;
   class="kw">protected class="kw">final double heightDifferenceMin;
   class="kw">protected class="kw">final double heightDifferenceMax;
   class="kw">protected class="kw">final double abortDistance;
   class="kw">protected class="kw">final double abortDistanceSquared;
   class="kw">protected class="kw">final double switchToSteeringDistance;
   class="kw">protected class="kw">final double switchToSteeringDistanceSquared;
   class="kw">protected class="kw">final SteeringForcePursue seek = new SteeringForcePursue();
   class="kw">protected class="kw">final Vector3d tempDirectionVector = new Vector3d();
   class="kw">protected double effectiveDistanceSquared;

   class="kw">public BodyMotionFind(@Nonnull BuilderBodyMotionFind var1, @Nonnull BuilderSupport var2) {
      super(var1, var2);
      this.reachable = var1.getReachable(var2);
      this.distance = var1.getStopDistance(var2);
      this.distanceSquared = this.distance * this.distance;
      double[] var3 = var1.getHeightDifference(var2);
      this.heightDifferenceMin = var3[0];
      this.heightDifferenceMax = var3[1];
      this.seek.setDistances(var1.getSlowDownDistance(var2), var1.getStopDistance(var2));
      this.seek.setFalloff(var1.getFalloff(var2));
      this.abortDistance = var1.getAbortDistance(var2);
      this.abortDistanceSquared = this.abortDistance * this.abortDistance;
      this.switchToSteeringDistance = var1.getSwitchToSteeringDistance(var2);
      this.switchToSteeringDistanceSquared = this.switchToSteeringDistance * this.switchToSteeringDistance;
   }

   @Override
   class="kw">protected boolean canSwitchToSteering(@Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      TransformComponent var4 = var3.getComponent(var1, TransformComponent.getComponentType());
      assert var4 != null;
      Vector3d var5 = var4.getPosition();
      if (var2.waypointDistanceSquared(var5, this.getLastTargetPosition()) > this.switchToSteeringDistanceSquared) {
         class="kw">return false;
      }

      if (this.dbgMotionState) {
         ((HytaleLogger.Api)NPCPlugin.get().getLogger().at(Level.INFO).every(100)).log("MotionFind: computing canSwitchToSteering");
      }

      class="kw">return this.canReachTarget(var1, var2, var5, this.getLastAccessibleTargetPosition(var2, true, var3), var3);
   }

   @Override
   class="kw">protected boolean shouldSkipSteering(
      @Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, @Nonnull Vector3d var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      Vector3d var5 = this.getLastAccessibleTargetPosition(var2, true, var4);
      this.probeMoveData.setPosition(var3).setTargetPosition(var5);
      var2.probeMove(var1, this.probeMoveData, var4);
      class="kw">return !this.isGoalReached(var1, var2, this.probeMoveData.probePosition, var5, var4);
   }

   @Override
   class="kw">protected boolean computeSteering(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull ExecutionSupport var2,
      @Nonnull Vector3d var3,
      @Nonnull Steering var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      this.seek.setPositions(var3, this.getLastTargetPosition());
      MotionController var6 = var2.getMotionContextSupport().getActiveMotionController();
      this.seek.setComponentSelector(var6.getComponentSelector());
      double var7 = this.desiredAltitudeWeight >= 0.0 ? this.desiredAltitudeWeight : var6.getDesiredAltitudeWeight();
      class="kw">return this.scaleSteering(var1, var2, this.seek, var4, var7, var5);
   }

   @Override
   class="kw">public boolean canComputeMotion(
      @Nonnull Ref<EntityStore> var1, @Nonnull ExecutionSupport var2, @Nullable InfoProvider var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      if (super.canComputeMotion(var1, var2, var3, var4)
         && (
            !(this.abortDistance > 0.0)
               || !(
                  var2.getMotionContextSupport().getActiveMotionController().waypointDistanceSquared(var1, this.getLastTargetPosition(), var4)
                     >= this.abortDistanceSquared
               )
         )) {
         if (this.selfBoundingBox != null && this.adjustRangeByHitboxSize) {
            double var5 = this.distance + Math.max(this.selfBoundingBox.width(), this.selfBoundingBox.depth());
            if (this.targetBoundingBox != null) {
               var5 += Math.max(this.targetBoundingBox.width(), this.targetBoundingBox.depth());
            }

            this.effectiveDistanceSquared = var5 * var5;
         } else {
            this.effectiveDistanceSquared = this.distanceSquared;
         }

         class="kw">return this.selfBoundingBox != null;
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">protected boolean isGoalReached(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull MotionController var2,
      @Nonnull Vector3d var3,
      @Nonnull Vector3d var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      double var6 = var4.y - var3.y;
      if (!(var6 < this.heightDifferenceMin) && !(var6 > this.heightDifferenceMax)) {
         class="kw">return var2.waypointDistanceSquared(var3, var4) > this.effectiveDistanceSquared
            ? false
            : !this.reachable || this.canReachTarget(var1, var2, var3, var4, var5);
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public boolean isGoalReached(
      @Nonnull Ref<EntityStore> var1, AStarBase var2, @Nonnull AStarNode var3, @Nonnull MotionController var4, @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      AStarWithTarget var6 = (AStarWithTarget)var2;
      class="kw">return this.isGoalReached(var1, var4, var3.getPosition(), var6.getTargetPosition(), var5);
   }

   @Override
   class="kw">public float estimateToGoal(@Nonnull AStarBase var1, @Nonnull Vector3d var2, MotionController var3) {
      class="kw">return (float)((AStarWithTarget)var1).getTargetPosition().distance(var2);
   }

   @Override
   class="kw">public void findBestPath(@Nonnull AStarBase var1, MotionController var2) {
      var1.buildBestPath(AStarNode::getEstimateToGoal, (var0, var1x) -> var1x < var0, Float.MAX_VALUE);
   }

   @Override
   class="kw">protected void onThrottling(MotionController var1, @Nonnull Ref<EntityStore> var2, @Nonnull Steering var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      super.onThrottling(var1, var2, var3, var4);
      this.lookAtTarget(var2, var3, var4);
   }

   @Override
   class="kw">protected void onDeferring(MotionController var1, @Nonnull Ref<EntityStore> var2, @Nonnull Steering var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      super.onDeferring(var1, var2, var3, var4);
      this.lookAtTarget(var2, var3, var4);
   }

   class="kw">protected void lookAtTarget(@Nonnull Ref<EntityStore> var1, @Nonnull Steering var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      TransformComponent var4 = var3.getComponent(var1, TransformComponent.getComponentType());
      assert var4 != null;
      Vector3d var5 = var4.getPosition();
      Rotation3f var6 = var4.getRotation();
      this.tempDirectionVector.set(this.getLastTargetPosition()).sub(var5);
      var2.setYaw(NPCPhysicsMath.headingFromDirection(this.tempDirectionVector.x, this.tempDirectionVector.z, var6.yaw()));
      var2.setPitch(NPCPhysicsMath.pitchFromDirection(this.tempDirectionVector.x, this.tempDirectionVector.y, this.tempDirectionVector.z, var6.pitch()));
   }

   class="kw">protected boolean canReachTarget(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull MotionController var2,
      @Nonnull Vector3d var3,
      @Nonnull Vector3d var4,
      @Nonnull ComponentAccessor<EntityStore> var5
   ) {
      if (this.isBoundingBoxesOverlapping(var3, var4)) {
         class="kw">return true;
      }

      Vector3d var6 = this.tempDirectionVector.set(var4).sub(var3);
      var2.probeMove(var1, var3, var6, this.probeMoveData, var5);
      class="kw">return this.isBoundingBoxesOverlapping(this.probeMoveData.probePosition, var4);
   }

   class="kw">protected boolean isBoundingBoxesOverlapping(@Nonnull Vector3d var1, @Nonnull Vector3d var2) {
      class="kw">return this.targetBoundingBox == null
         ? this.containsPosition(var1, var2)
         : containsPosition(
               var1.x, this.selfBoundingBox.min.x - this.targetBoundingBox.max.x, this.selfBoundingBox.max.x - this.targetBoundingBox.min.x, var2.x
            )
            && containsPosition(
               var1.y, this.selfBoundingBox.min.y - this.targetBoundingBox.max.y, this.selfBoundingBox.max.y - this.targetBoundingBox.min.y, var2.y
            )
            && containsPosition(
               var1.z, this.selfBoundingBox.min.z - this.targetBoundingBox.max.z, this.selfBoundingBox.max.z - this.targetBoundingBox.min.z, var2.z
            );
   }

   class="kw">protected boolean containsPosition(@Nonnull Vector3d var1, @Nonnull Vector3d var2) {
      class="kw">return containsPosition(var1.x, this.selfBoundingBox.min.x, this.selfBoundingBox.max.x, var2.x)
         && containsPosition(var1.y, this.selfBoundingBox.min.y, this.selfBoundingBox.max.y, var2.y)
         && containsPosition(var1.z, this.selfBoundingBox.min.z, this.selfBoundingBox.max.z, var2.z);
   }

   class="kw">protected class="kw">static boolean containsPosition(double var0, double var2, double var4, double var6) {
      var6 -= var0;
      class="kw">return var6 >= var2 && var6 < var4;
   }

   @Override
   class="kw">public double getDesiredTargetDistance() {
      class="kw">return this.distance;
   }

   @Nullable
   @Override
   class="kw">public Ref<EntityStore> getDesiredTargetEntity() {
      class="kw">return this.lastDesiredTargetEntity;
   }
}