Get Cutoff implementation out of API we DON'T need you

src/main/java/baritone/behavior/PathingBehavior.java

@@ -25,8 +25,8 @@ import baritone.api.event.events.RenderEvent;
 import baritone.api.event.events.TickEvent;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalXZ;
-import baritone.api.pathing.path.CutoffResult;
-import baritone.api.pathing.path.IPath;
+import baritone.pathing.calc.CutoffPath;
+import baritone.api.pathing.calc.IPath;
 import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import baritone.pathing.calc.AStarPathFinder;
@@ -285,27 +285,27 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
             Optional<IPath> path = findPath(start, previous);
             if (Baritone.settings().cutoffAtLoadBoundary.get()) {
                 path = path.map(p -> {
-                    CutoffResult result = p.cutoffAtLoadedChunks();
+                    IPath result = p.cutoffAtLoadedChunks();
 
-                    if (result.wasCut()) {
+                    if (result instanceof CutoffPath) {
                         logDebug("Cutting off path at edge of loaded chunks");
-                        logDebug("Length decreased by " + result.getRemoved());
+                        logDebug("Length decreased by " + (p.length() - result.length()));
                     } else {
                         logDebug("Path ends within loaded chunks");
                     }
 
-                    return result.getPath();
+                    return result;
                 });
             }
 
             Optional<PathExecutor> executor = path.map(p -> {
-                CutoffResult result = p.staticCutoff(goal);
+                IPath result = p.staticCutoff(goal);
 
-                if (result.wasCut()) {
-                    logDebug("Static cutoff " + p.length() + " to " + result.getPath().length());
+                if (result instanceof CutoffPath) {
+                    logDebug("Static cutoff " + p.length() + " to " + result.length());
                 }
 
-                return result.getPath();
+                return result;
             }).map(PathExecutor::new);
 
             synchronized (pathPlanLock) {

src/main/java/baritone/pathing/calc/AStarPathFinder.java

@@ -20,7 +20,7 @@ package baritone.pathing.calc;
 import baritone.Baritone;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.movement.ActionCosts;
-import baritone.api.pathing.path.IPath;
+import baritone.api.pathing.calc.IPath;
 import baritone.api.utils.BetterBlockPos;
 import baritone.pathing.calc.openset.BinaryHeapOpenSet;
 import baritone.pathing.movement.CalculationContext;

src/main/java/baritone/pathing/calc/AbstractNodeCostSearch.java

@@ -20,7 +20,7 @@ package baritone.pathing.calc;
 import baritone.Baritone;
 import baritone.api.pathing.calc.IPathFinder;
 import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.path.IPath;
+import baritone.api.pathing.calc.IPath;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 
 import java.util.Optional;

src/main/java/baritone/pathing/calc/CutoffPath.java

@@ -0,0 +1,64 @@
+/*
+ * This file is part of Baritone.
+ *
+ * Baritone is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Baritone is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Baritone.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package baritone.pathing.calc;
+
+import baritone.api.pathing.goals.Goal;
+import baritone.api.pathing.movement.IMovement;
+import baritone.api.pathing.calc.IPath;
+import baritone.api.utils.BetterBlockPos;
+
+import java.util.Collections;
+import java.util.List;
+
+public class CutoffPath implements IPath {
+
+    private final List<BetterBlockPos> path;
+
+    private final List<IMovement> movements;
+
+    private final int numNodes;
+
+    private final Goal goal;
+
+    CutoffPath(IPath prev, int lastPositionToInclude) {
+        path = prev.positions().subList(0, lastPositionToInclude + 1);
+        movements = prev.movements().subList(0, lastPositionToInclude + 1);
+        numNodes = prev.getNumNodesConsidered();
+        goal = prev.getGoal();
+    }
+
+    @Override
+    public Goal getGoal() {
+        return goal;
+    }
+
+    @Override
+    public List<IMovement> movements() {
+        return Collections.unmodifiableList(movements);
+    }
+
+    @Override
+    public List<BetterBlockPos> positions() {
+        return Collections.unmodifiableList(path);
+    }
+
+    @Override
+    public int getNumNodesConsidered() {
+        return numNodes;
+    }
+}

src/main/java/baritone/pathing/calc/Path.java

@@ -17,13 +17,16 @@
 
 package baritone.pathing.calc;
 
+import baritone.api.BaritoneAPI;
 import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.movement.IMovement;
-import baritone.api.pathing.path.IPath;
+import baritone.api.pathing.calc.IPath;
 import baritone.api.utils.BetterBlockPos;
 import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.Moves;
+import net.minecraft.client.Minecraft;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.chunk.EmptyChunk;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -188,4 +191,28 @@ class Path implements IPath {
     public BetterBlockPos getDest() {
         return end;
     }
+
+    @Override
+    public IPath cutoffAtLoadedChunks() {
+        for (int i = 0; i < positions().size(); i++) {
+            BlockPos pos = positions().get(i);
+            if (Minecraft.getMinecraft().world.getChunk(pos) instanceof EmptyChunk) {
+                return new CutoffPath(this, i);
+            }
+        }
+        return this;
+    }
+
+    @Override
+    public IPath staticCutoff(Goal destination) {
+        if (length() < BaritoneAPI.getSettings().pathCutoffMinimumLength.get()) {
+            return this;
+        }
+        if (destination == null || destination.isInGoal(getDest())) {
+            return this;
+        }
+        double factor = BaritoneAPI.getSettings().pathCutoffFactor.get();
+        int newLength = (int) (length() * factor);
+        return new CutoffPath(this, newLength);
+    }
 }

src/main/java/baritone/pathing/path/PathExecutor.java

@@ -22,7 +22,7 @@ import baritone.api.event.events.TickEvent;
 import baritone.api.pathing.movement.ActionCosts;
 import baritone.api.pathing.movement.IMovement;
 import baritone.api.pathing.movement.MovementStatus;
-import baritone.api.pathing.path.IPath;
+import baritone.api.pathing.calc.IPath;
 import baritone.api.pathing.path.IPathExecutor;
 import baritone.api.utils.BetterBlockPos;
 import baritone.pathing.calc.AbstractNodeCostSearch;

src/main/java/baritone/utils/PathRenderer.java

@@ -23,7 +23,7 @@ import baritone.api.pathing.goals.Goal;
 import baritone.api.pathing.goals.GoalComposite;
 import baritone.api.pathing.goals.GoalTwoBlocks;
 import baritone.api.pathing.goals.GoalXZ;
-import baritone.api.pathing.path.IPath;
+import baritone.api.pathing.calc.IPath;
 import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.interfaces.IGoalRenderPos;
 import baritone.behavior.PathingBehavior;