Add Diagonal Jumps

.gitignore

@@ -21,3 +21,4 @@ classes/
 # Copyright Files
 !/.idea/copyright/Baritone.xml
 !/.idea/copyright/profiles_settings.xml
+/bin/

src/api/java/baritone/api/Settings.java

@@ -257,6 +257,20 @@ public final class Settings {
      */
     public final Setting<Boolean> allowParkourPlace = new Setting<>(false);
 
+    /**
+     * Allows baritone to consider parkour jumps at more angles.
+     * <p>
+     * Only takes effect if allowParkour is also enabled.
+     */
+    public final Setting<Boolean> allowParkourAdv = new Setting<>(false);
+
+    /**
+     * Allows baritone to consider 4 block jumps and neo jumps. Unreliable.
+     * <p>
+     * Only takes effect if allowParkour and allowParkourAdv is also enabled.
+     */
+    public final Setting<Boolean> allowParkourMomentumOrNeo = new Setting<>(false);
+
     /**
      * For example, if you have Mining Fatigue or Haste, adjust the costs of breaking blocks accordingly.
      */

src/api/java/baritone/api/utils/VecUtils.java

@@ -23,6 +23,7 @@
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
 import net.minecraft.world.World;
 
 /**
@@ -113,4 +114,39 @@ public static double entityDistanceToCenter(Entity entity, BlockPos pos) {
     public static double entityFlatDistanceToCenter(Entity entity, BlockPos pos) {
         return distanceToCenter(pos, entity.posX, pos.getY() + 0.5, entity.posZ);
     }
+
+    /**
+     * Adds vec1 and vec2
+     *
+     * @param vec1  The initial vector
+     * @param vec2  The vector to add
+     * @return      A new resultant vector
+     */
+    public static Vec3i add(Vec3i vec1, Vec3i vec2) {
+        return new Vec3i(vec1.getX() + vec2.getX(), vec1.getY() + vec2.getY(), vec1.getZ() + vec2.getZ());
+    }
+
+    /**
+     * Adds vec1 and vec2
+     *
+     * @param vec1  The initial vector
+     * @param vec2X The x value to add to the vector
+     * @param vec2Y The y value to add to the vector
+     * @param vec2Z The z value to add to the vector
+     * @return      A new resultant vector
+     */
+    public static Vec3i add(Vec3i vec1, int vec2X, int vec2Y, int vec2Z) {
+        return new Vec3i(vec1.getX() + vec2X, vec1.getY() + vec2Y, vec1.getZ() + vec2Z);
+    }
+
+    /**
+     * Subtracts vec2 from vec1; vec1 - vec2
+     *
+     * @param vec1  The initial vector
+     * @param vec2  The vector to subtract
+     * @return      A new resultant vector
+     */
+    public static Vec3i subtract(Vec3i vec1, Vec3i vec2) {
+        return new Vec3i(vec1.getX() - vec2.getX(), vec1.getY() - vec2.getY(), vec1.getZ() - vec2.getZ());
+    }
 }

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

@@ -59,7 +59,7 @@ protected Optional<IPath> calculate0(long primaryTimeout, long failureTimeout) {
             bestHeuristicSoFar[i] = startNode.estimatedCostToGoal;
             bestSoFar[i] = startNode;
         }
-        MutableMoveResult res = new MutableMoveResult();
+        MutableMoveResult mutableMoveResult = new MutableMoveResult();
         BetterWorldBorder worldBorder = new BetterWorldBorder(calcContext.world.getWorldBorder());
         long startTime = System.currentTimeMillis();
         boolean slowPath = Baritone.settings().slowPath.value;
@@ -112,52 +112,58 @@ protected Optional<IPath> calculate0(long primaryTimeout, long failureTimeout) {
                 if (currentNode.y + moves.yOffset > 256 || currentNode.y + moves.yOffset < 0) {
                     continue;
                 }
-                res.reset();
-                moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z, res);
-                numMovementsConsidered++;
-                double actionCost = res.cost;
-                if (actionCost >= ActionCosts.COST_INF) {
-                    continue;
-                }
-                if (actionCost <= 0 || Double.isNaN(actionCost)) {
-                    throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
-                }
-                // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
-                if (moves.dynamicXZ && !worldBorder.entirelyContains(res.x, res.z)) { // see issue #218
-                    continue;
-                }
-                if (!moves.dynamicXZ && (res.x != newX || res.z != newZ)) {
-                    throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
-                }
-                if (!moves.dynamicY && res.y != currentNode.y + moves.yOffset) {
-                    throw new IllegalStateException(moves + " " + res.y + " " + (currentNode.y + moves.yOffset));
-                }
-                long hashCode = BetterBlockPos.longHash(res.x, res.y, res.z);
-                if (isFavoring) {
-                    // see issue #18
-                    actionCost *= favoring.calculate(hashCode);
-                }
-                PathNode neighbor = getNodeAtPosition(res.x, res.y, res.z, hashCode);
-                double tentativeCost = currentNode.cost + actionCost;
-                if (neighbor.cost - tentativeCost > minimumImprovement) {
-                    neighbor.previous = currentNode;
-                    neighbor.cost = tentativeCost;
-                    neighbor.combinedCost = tentativeCost + neighbor.estimatedCostToGoal;
-                    if (neighbor.isOpen()) {
-                        openSet.update(neighbor);
-                    } else {
-                        openSet.insert(neighbor);//dont double count, dont insert into open set if it's already there
+                mutableMoveResult.reset();
+                moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z, mutableMoveResult);
+                MutableMoveResult res = mutableMoveResult;
+                while (res != null) {
+                    numMovementsConsidered++;
+                    double actionCost = res.cost;
+                    if (actionCost >= ActionCosts.COST_INF) {
+                        res = res.getNext();
+                        continue;
+                    }
+                    if (actionCost <= 0 || Double.isNaN(actionCost)) {
+                        throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
+                    }
+                    // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
+                    if (moves.dynamicXZ && !worldBorder.entirelyContains(res.x, res.z)) { // see issue #218
+                        res = res.getNext();
+                        continue;
+                    }
+                    if (!moves.dynamicXZ && (res.x != newX || res.z != newZ)) {
+                        throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
                     }
-                    for (int i = 0; i < COEFFICIENTS.length; i++) {
-                        double heuristic = neighbor.estimatedCostToGoal + neighbor.cost / COEFFICIENTS[i];
-                        if (bestHeuristicSoFar[i] - heuristic > minimumImprovement) {
-                            bestHeuristicSoFar[i] = heuristic;
-                            bestSoFar[i] = neighbor;
-                            if (failing && getDistFromStartSq(neighbor) > MIN_DIST_PATH * MIN_DIST_PATH) {
-                                failing = false;
+                    if (!moves.dynamicY && res.y != currentNode.y + moves.yOffset) {
+                        throw new IllegalStateException(moves + " " + res.y + " " + (currentNode.y + moves.yOffset));
+                    }
+                    long hashCode = BetterBlockPos.longHash(res.x, res.y, res.z);
+                    if (isFavoring) {
+                        // see issue #18
+                        actionCost *= favoring.calculate(hashCode);
+                    }
+                    PathNode neighbor = getNodeAtPosition(res.x, res.y, res.z, hashCode);
+                    double tentativeCost = currentNode.cost + actionCost;
+                    if (neighbor.cost - tentativeCost > minimumImprovement) {
+                        neighbor.previous = currentNode;
+                        neighbor.cost = tentativeCost;
+                        neighbor.combinedCost = tentativeCost + neighbor.estimatedCostToGoal;
+                        if (neighbor.isOpen()) {
+                            openSet.update(neighbor);
+                        } else {
+                            openSet.insert(neighbor);//dont double count, dont insert into open set if it's already there
+                        }
+                        for (int i = 0; i < COEFFICIENTS.length; i++) {
+                            double heuristic = neighbor.estimatedCostToGoal + neighbor.cost / COEFFICIENTS[i];
+                            if (bestHeuristicSoFar[i] - heuristic > minimumImprovement) {
+                                bestHeuristicSoFar[i] = heuristic;
+                                bestSoFar[i] = neighbor;
+                                if (failing && getDistFromStartSq(neighbor) > MIN_DIST_PATH * MIN_DIST_PATH) {
+                                    failing = false;
+                                }
                             }
                         }
                     }
+                    res = res.getNext();
                 }
             }
         }

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

@@ -115,13 +115,22 @@ private boolean assembleMovements() {
 
     private Movement runBackwards(BetterBlockPos src, BetterBlockPos dest, double cost) {
         for (Moves moves : Moves.values()) {
-            Movement move = moves.apply0(context, src);
-            if (move.getDest().equals(dest)) {
-                // have to calculate the cost at calculation time so we can accurately judge whether a cost increase happened between cached calculation and real execution
-                // however, taking into account possible favoring that could skew the node cost, we really want the stricter limit of the two
-                // so we take the minimum of the path node cost difference, and the calculated cost
-                move.override(Math.min(move.calculateCost(context), cost));
-                return move;
+            if (moves.canHaveMultipleDestinations()) {
+                for (Movement move : moves.getMultiDestination(context, src)) {
+                    if (move.getDest().equals(dest)) {
+                        move.override(Math.min(move.calculateCost(context), cost));
+                        return move;
+                    }
+                }
+            } else {
+                Movement move = moves.apply0(context, src);
+                if (move.getDest().equals(dest)) {
+                    // have to calculate the cost at calculation time so we can accurately judge whether a cost increase happened between cached calculation and real execution
+                    // however, taking into account possible favoring that could skew the node cost, we really want the stricter limit of the two
+                    // so we take the minimum of the path node cost difference, and the calculated cost
+                    move.override(Math.min(move.calculateCost(context), cost));
+                    return move;
+                }
             }
         }
         // this is no longer called from bestPathSoFar, now it's in postprocessing

src/main/java/baritone/pathing/movement/CalculationContext.java

@@ -57,6 +57,8 @@ public class CalculationContext {
     public final boolean allowBreak;
     public final boolean allowParkour;
     public final boolean allowParkourPlace;
+    public final boolean allowParkourAdv;
+    public final boolean allowParkourMomentumOrNeo;
     public final boolean allowJumpAt256;
     public final boolean allowParkourAscend;
     public final boolean assumeWalkOnWater;
@@ -91,6 +93,8 @@ public CalculationContext(IBaritone baritone, boolean forUseOnAnotherThread) {
         this.allowBreak = Baritone.settings().allowBreak.value;
         this.allowParkour = Baritone.settings().allowParkour.value;
         this.allowParkourPlace = Baritone.settings().allowParkourPlace.value;
+        this.allowParkourAdv = Baritone.settings().allowParkourAdv.value;
+        this.allowParkourMomentumOrNeo = Baritone.settings().allowParkourMomentumOrNeo.value;
         this.allowJumpAt256 = Baritone.settings().allowJumpAt256.value;
         this.allowParkourAscend = Baritone.settings().allowParkourAscend.value;
         this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.value;

src/main/java/baritone/pathing/movement/MovementHelper.java

@@ -35,6 +35,7 @@
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
 import net.minecraft.world.IBlockAccess;
 
 import java.util.Optional;
@@ -446,6 +447,22 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
         )).setInput(Input.MOVE_FORWARD, true);
     }
 
+    /**
+     * Moves towards a double vector's coordinates.
+     *
+     * @param ctx       Player context
+     * @param state     Movement State
+     * @param pos       Position to move to
+     */
+    static void moveTowards(IPlayerContext ctx, MovementState state, Vec3d pos) {
+        state.setTarget(new MovementTarget(
+                new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+                        pos,
+                        ctx.playerRotations()).getYaw(), ctx.player().rotationPitch),
+                false
+        )).setInput(Input.MOVE_FORWARD, true);
+    }
+
     /**
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.