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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionConfig;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.movement.constraints.RelaxedConstraint;
class="kw">import com.hypixel.hytale.server.npc.util.NPCPhysicsMath;
class="kw">import java.util.Arrays;
class="kw">import java.util.EnumSet;
class="kw">import java.util.function.IntPredicate;
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">import org.joml.Vector3dc;

class="kw">public class ProbeMoveData {
   @Nonnull
   class="kw">public class="kw">final Vector3d probePosition;
   @Nonnull
   class="kw">public class="kw">final Vector3d probeDirection;
   @Nonnull
   class="kw">public class="kw">final Vector3d initialPosition;
   @Nonnull
   class="kw">public class="kw">final Vector3d targetPosition;
   @Nonnull
   class="kw">public class="kw">final Vector3d directionComponentSelector;
   class="kw">private class="kw">final EnumSet<RelaxedConstraint> relaxedConstraints = EnumSet.noneOf(RelaxedConstraint.class);
   @Nullable
   class="kw">private Predicate<CollisionConfig> blockCollisionFilter;
   @Nullable
   class="kw">private IntPredicate breathableBlockOverride;
   class="kw">public boolean edgeBlocked;
   class="kw">public boolean isSavingSegments;
   class="kw">public int segmentCount;
   @Nullable
   class="kw">public ProbeMoveData.Segment[] segments;
   class="kw">public boolean debugCollision;

   class="kw">public ProbeMoveData() {
      this.probeDirection = new Vector3d();
      this.probePosition = new Vector3d();
      this.initialPosition = new Vector3d();
      this.targetPosition = new Vector3d();
      this.directionComponentSelector = new Vector3d();
   }

   class="kw">public void setSaveSegments(boolean var1) {
      this.isSavingSegments = var1;
      if (this.isSavingSegments && this.segments == null) {
         this.segments = new ProbeMoveData.Segment[6];

         for (int var2 = 0; var2 < this.segments.length; var2++) {
            this.segments[var2] = new ProbeMoveData.Segment();
         }
      }
   }

   @Nonnull
   class="kw">public EnumSet<RelaxedConstraint> getRelaxedConstraints() {
      class="kw">return this.relaxedConstraints;
   }

   class="kw">public void setRelaxedConstraints(@Nonnull EnumSet<RelaxedConstraint> var1) {
      this.relaxedConstraints.clear();
      this.relaxedConstraints.addAll(var1);
   }

   @Nullable
   class="kw">public Predicate<CollisionConfig> getBlockCollisionFilter() {
      class="kw">return this.blockCollisionFilter;
   }

   class="kw">public void setBlockCollisionFilter(@Nullable Predicate<CollisionConfig> var1) {
      this.blockCollisionFilter = var1;
   }

   @Nullable
   class="kw">public IntPredicate getBreathableBlockOverride() {
      class="kw">return this.breathableBlockOverride;
   }

   class="kw">public void setBreathableBlockOverride(@Nullable IntPredicate var1) {
      this.breathableBlockOverride = var1;
   }

   @Nonnull
   class="kw">public ProbeMoveData setPosition(@Nonnull Vector3dc var1) {
      this.probePosition.set(var1);
      this.initialPosition.set(var1);
      class="kw">return this;
   }

   @Nonnull
   class="kw">public ProbeMoveData setDirection(@Nonnull Vector3dc var1) {
      this.probeDirection.set(var1);
      this.targetPosition.set(this.probePosition).add(this.probeDirection);
      class="kw">return this;
   }

   @Nonnull
   class="kw">public ProbeMoveData setTargetPosition(@Nonnull Vector3dc var1) {
      this.targetPosition.set(var1);
      this.probeDirection.set(var1).sub(this.probePosition);
      class="kw">return this;
   }

   class="kw">public boolean canAdvance(@Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, double var3, @Nonnull ComponentAccessor<EntityStore> var5) {
      double var6 = var3 * this.probeDirection.length();
      class="kw">return this.canAdvanceAbs(var1, var2, var6, var5);
   }

   class="kw">public boolean canAdvanceAbs(@Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, double var3, @Nonnull ComponentAccessor<EntityStore> var5) {
      double var6 = var2.probeMove(var1, this, var5);
      class="kw">return var6 >= var3;
   }

   class="kw">public boolean canMoveTo(
      @Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, double var3, double var5, @Nonnull ComponentAccessor<EntityStore> var7
   ) {
      if (!this.canMoveTo(var1, var2, var3, var7)) {
         class="kw">return false;
      }

      if (!var2.is2D()) {
         class="kw">return true;
      }

      double var8 = NPCPhysicsMath.getProjectedDifference(this.targetPosition, this.probePosition, var2.getComponentSelector());
      class="kw">return Math.abs(var8) <= var5;
   }

   class="kw">public boolean canMoveTo(@Nonnull Ref<EntityStore> var1, @Nonnull MotionController var2, double var3, @Nonnull ComponentAccessor<EntityStore> var5) {
      var2.probeMove(var1, this, var5);
      class="kw">return var2.waypointDistanceSquared(this.targetPosition, this.probePosition) <= var3 * var3;
   }

   class="kw">public boolean computePosition(double var1, @Nonnull Vector3d var3) {
      if (this.segmentCount < 2) {
         class="kw">return false;
      }

      if (var1 <= 0.0) {
         var3.set(this.segments[0].position);
         class="kw">return true;
      }

      int var4 = 1;
      ProbeMoveData.Segment var5 = this.segments[0];
      ProbeMoveData.Segment var6 = null;

      while (var4 < this.segmentCount) {
         var6 = var5;
         var5 = this.segments[var4];
         if (var5.distance >= var1) {
            break;
         }

         var4++;
      }

      if (var5.distance <= var1) {
         var3.set(var5.position);
         class="kw">return true;
      } else if (var5.type.canInterpolate()) {
         double var7 = (var1 - var6.distance) / (var5.distance - var6.distance);
         NPCPhysicsMath.lerp(var6.position, var5.position, var7, var3);
         class="kw">return true;
      } else {
         var3.set(var6.position);
         class="kw">return true;
      }
   }

   class="kw">public boolean locateSegmentAtDistance(double var1, @Nonnull ProbeMoveData.SegmentLocation var3) {
      var3.reset();
      if (this.segmentCount <= 0 || this.segments == null) {
         class="kw">return false;
      }

      if (var1 <= 0.0) {
         var3.segmentIndex = 0;
         var3.previousSegmentIndex = -1;
         var3.lambda = 0.0;
         var3.segmentType = this.segments[0].type;
         class="kw">return true;
      }

      int var4 = 1;
      ProbeMoveData.Segment var5 = this.segments[0];
      ProbeMoveData.Segment var6 = null;

      while (var4 < this.segmentCount) {
         var6 = var5;
         var5 = this.segments[var4];
         if (var5.distance >= var1) {
            break;
         }

         var4++;
      }

      if (var4 >= this.segmentCount) {
         var3.segmentIndex = this.segmentCount - 1;
         var3.previousSegmentIndex = Math.max(0, this.segmentCount - 2);
         var3.lambda = 1.0;
         var3.segmentType = this.segments[var3.segmentIndex].type;
         class="kw">return true;
      }

      var3.segmentIndex = var4;
      var3.previousSegmentIndex = var4 - 1;
      var3.segmentType = var5.type;
      if (!(var5.distance <= var1) && var6 != null) {
         double var7 = var5.distance - var6.distance;
         if (Math.abs(var7) <= 1.0E-6) {
            var3.lambda = 1.0;
            class="kw">return true;
         } else {
            var3.lambda = (var1 - var6.distance) / var7;
            class="kw">return true;
         }
      } else {
         var3.lambda = 1.0;
         class="kw">return true;
      }
   }

   class="kw">public boolean startProbing() {
      this.edgeBlocked = false;
      if (this.isSavingSegments) {
         this.segmentCount = 0;
      }

      class="kw">return this.isSavingSegments;
   }

   class="kw">public void addStartSegment(@Nonnull Vector3dc var1, boolean var2) {
      this.newSegment().initAsStartSegment(var1, var2);
   }

   class="kw">public void addEndSegment(@Nonnull Vector3dc var1, boolean var2, double var3) {
      this.newSegment().initAsEndSegment(var1, var2, var3);
   }

   class="kw">public void addBlockedGroundSegment(@Nonnull Vector3dc var1, double var2, @Nonnull Vector3dc var4, int var5) {
      this.newSegment().initAsBlockedGroundSegment(var1, var2, var4, var5);
   }

   class="kw">public void addHitGroundSegment(@Nonnull Vector3dc var1, double var2, @Nonnull Vector3dc var4, int var5) {
      this.newSegment().initAsHitGroundSegment(var1, var2, var4, var5);
   }

   class="kw">public void addHitWallSegment(@Nonnull Vector3dc var1, boolean var2, double var3, @Nonnull Vector3dc var5, int var6) {
      this.newSegment().initAsHitWallSegment(var1, var2, var3, var5, var6);
   }

   class="kw">public void addMoveSegment(@Nonnull Vector3dc var1, boolean var2, double var3) {
      this.newSegment().initAsMoveSegment(var1, var2, var3);
   }

   class="kw">public void addClimbSegment(@Nonnull Vector3dc var1, double var2, int var4) {
      this.newSegment().initAsClimbSegment(var1, var2, var4);
   }

   class="kw">public void addHitEdgeSegment(@Nonnull Vector3dc var1, double var2) {
      this.newSegment().initAsHitEdgeSegment(var1, var2);
   }

   class="kw">public void addDropSegment(@Nonnull Vector3d var1, double var2) {
      this.newSegment().initAsDropSegment(var1, var2);
   }

   class="kw">public void addBlockedDropSegment(@Nonnull Vector3d var1, double var2) {
      this.edgeBlocked = true;
      this.newSegment().initAsBlockedDropSegment(var1, var2);
   }

   class="kw">public void changeSegmentToBlockedWall() {
      this.segments[this.segmentCount - 1].type = ProbeMoveData.Segment.Type.BLOCKED_WALL;
   }

   class="kw">public void changeSegmentToBlockedEdge() {
      this.edgeBlocked = true;
      this.segments[this.segmentCount - 1].type = ProbeMoveData.Segment.Type.BLOCKED_EDGE;
   }

   class="kw">public double getLastDistance() {
      class="kw">return this.segments[this.segmentCount - 1].distance;
   }

   @Nonnull
   class="kw">public String dump() {
      StringBuilder var1 = new StringBuilder();
      var1.append("ProbeMoveData")
         .append("\nprobePosition=")
         .append(Vector3dUtil.formatShortString(this.probePosition))
         .append(", probeDirection=")
         .append(Vector3dUtil.formatShortString(this.probeDirection))
         .append(", initialPosition=")
         .append(Vector3dUtil.formatShortString(this.initialPosition))
         .append(", targetPosition=")
         .append(Vector3dUtil.formatShortString(this.targetPosition))
         .append("\ndirectionComponentSelector=")
         .append(Vector3dUtil.formatShortString(this.directionComponentSelector))
         .append(", edgeBlocked=")
         .append(this.edgeBlocked)
         .append(", isSavingSegments=")
         .append(this.isSavingSegments)
         .append(", segmentCount=")
         .append(this.segmentCount)
         .append("\nrelaxedConstraints=")
         .append(this.relaxedConstraints)
         .append(", blockCollisionFilter=")
         .append(this.blockCollisionFilter != null ? "set" : "none");
      if (this.segments != null && this.segmentCount > 0) {
         int var2 = Math.min(this.segmentCount, this.segments.length);
         if (var2 <= 0) {
            var1.append("\nsegments=none");
            class="kw">return var1.toString();
         }

         var1.append("\nsegments:");

         for (int var3 = 0; var3 < var2; var3++) {
            ProbeMoveData.Segment var4 = this.segments[var3];
            if (var4 == null) {
               var1.append("\nsegment[").append(var3).append("]=null");
            } else {
               var1.append("\nsegment[")
                  .append(var3)
                  .append("]: type=")
                  .append(var4.type)
                  .append(", distance=")
                  .append(var4.distance)
                  .append(", onGround=")
                  .append(var4.onGround)
                  .append(", blockId=")
                  .append(var4.blockId)
                  .append(", position=")
                  .append(Vector3dUtil.formatShortString(var4.position))
                  .append(", normal=")
                  .append(Vector3dUtil.formatShortString(var4.normal));
               if (var4.type == ProbeMoveData.Segment.Type.CLIMB
                  || var4.type == ProbeMoveData.Segment.Type.DROP
                  || var4.type == ProbeMoveData.Segment.Type.BLOCKED_DROP) {
                  ProbeMoveData.Segment var5 = var3 > 0 ? this.segments[var3 - 1] : null;
                  double var6 = var5 != null ? var5.position.y : this.initialPosition.y;
                  var1.append(", dy=").append(var4.position.y - var6);
               }
            }
         }

         class="kw">return var1.toString();
      } else {
         var1.append("\nsegments=none");
         class="kw">return var1.toString();
      }
   }

   class="kw">protected ProbeMoveData.Segment newSegment() {
      if (this.segmentCount == this.segments.length) {
         this.segments = Arrays.copyOf(this.segments, this.segmentCount + 4);

         for (int var1 = this.segmentCount; var1 < this.segments.length; var1++) {
            this.segments[var1] = new ProbeMoveData.Segment();
         }
      }

      class="kw">return this.segments[this.segmentCount++];
   }

   class="kw">public class="kw">static class Segment {
      class="kw">public ProbeMoveData.Segment.Type type;
      class="kw">public class="kw">final Vector3d position = new Vector3d();
      class="kw">public class="kw">final Vector3d normal = new Vector3d();
      class="kw">public double distance;
      class="kw">public boolean onGround;
      class="kw">public int blockId;

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

      class="kw">public void initAsStartSegment(@Nonnull Vector3dc var1, boolean var2) {
         this.type = ProbeMoveData.Segment.Type.START;
         this.position.set(var1);
         this.normal.zero();
         this.distance = 0.0;
         this.onGround = var2;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public void initAsEndSegment(@Nonnull Vector3dc var1, boolean var2, double var3) {
         this.type = ProbeMoveData.Segment.Type.END;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var3;
         this.onGround = var2;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public void initAsBlockedGroundSegment(@Nonnull Vector3dc var1, double var2, @Nonnull Vector3dc var4, int var5) {
         this.type = ProbeMoveData.Segment.Type.BLOCKED_GROUND;
         this.position.set(var1);
         this.normal.set(var4);
         this.distance = var2;
         this.onGround = true;
         this.blockId = var5;
      }

      class="kw">public void initAsHitGroundSegment(@Nonnull Vector3dc var1, double var2, @Nonnull Vector3dc var4, int var5) {
         this.type = ProbeMoveData.Segment.Type.HIT_GROUND;
         this.position.set(var1);
         this.normal.set(var4);
         this.distance = var2;
         this.onGround = true;
         this.blockId = var5;
      }

      class="kw">public void initAsHitWallSegment(@Nonnull Vector3dc var1, boolean var2, double var3, @Nonnull Vector3dc var5, int var6) {
         this.type = ProbeMoveData.Segment.Type.HIT_WALL;
         this.position.set(var1);
         this.normal.set(var5);
         this.distance = var3;
         this.onGround = var2;
         this.blockId = var6;
      }

      class="kw">public void initAsClimbSegment(@Nonnull Vector3dc var1, double var2, int var4) {
         this.type = ProbeMoveData.Segment.Type.CLIMB;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var2;
         this.onGround = true;
         this.blockId = var4;
      }

      class="kw">public void initAsMoveSegment(@Nonnull Vector3dc var1, boolean var2, double var3) {
         this.type = ProbeMoveData.Segment.Type.MOVE;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var3;
         this.onGround = var2;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public void initAsDropSegment(@Nonnull Vector3dc var1, double var2) {
         this.type = ProbeMoveData.Segment.Type.DROP;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var2;
         this.onGround = true;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public void initAsBlockedDropSegment(@Nonnull Vector3dc var1, double var2) {
         this.type = ProbeMoveData.Segment.Type.BLOCKED_DROP;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var2;
         this.onGround = false;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public void initAsHitEdgeSegment(@Nonnull Vector3dc var1, double var2) {
         this.type = ProbeMoveData.Segment.Type.HIT_EDGE;
         this.position.set(var1);
         this.normal.zero();
         this.distance = var2;
         this.onGround = true;
         this.blockId = Integer.MIN_VALUE;
      }

      class="kw">public enum Type {
         START(false, false),
         HIT_GROUND(false, true),
         MOVE(false, true),
         BLOCKED_GROUND(true, true),
         HIT_WALL(false, true),
         BLOCKED_WALL(true, true),
         CLIMB(false, false),
         HIT_EDGE(false, true),
         BLOCKED_EDGE(true, true),
         DROP(false, false),
         BLOCKED_DROP(true, false),
         END(false, true);

         class="kw">final boolean isBlocked;
         class="kw">final boolean canInterpolate;

         class="kw">public boolean isBlocked() {
            class="kw">return this.isBlocked;
         }

         class="kw">public boolean canInterpolate() {
            class="kw">return this.canInterpolate;
         }

         Type(boolean nullxx, boolean nullxxx) {
            this.isBlocked = nullxx;
            this.canInterpolate = nullxxx;
         }
      }
   }

   class="kw">public class="kw">static class SegmentLocation {
      class="kw">public int segmentIndex = -1;
      class="kw">public int previousSegmentIndex = -1;
      class="kw">public double lambda;
      @Nullable
      class="kw">public ProbeMoveData.Segment.Type segmentType;

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

      class="kw">public void reset() {
         this.segmentIndex = -1;
         this.previousSegmentIndex = -1;
         this.lambda = 0.0;
         this.segmentType = null;
      }
   }
}