Add clutches.

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

@@ -147,12 +147,6 @@ public final class Settings {
      */
     public final Setting<Boolean> strictLiquidCheck = new Setting<>(false);
 
-    /**
-     * Allow Baritone to fall arbitrary distances and place a water bucket beneath it.
-     * Reliability: questionable.
-     */
-    public final Setting<Boolean> allowWaterBucketFall = new Setting<>(true);
-
     /**
      * Allow Baritone to assume it can walk on still water just like any other block.
      * This functionality is assumed to be provided by a separate library that might have imported Baritone.
@@ -550,17 +544,17 @@ public final class Settings {
     public final Setting<Float> pathingMapLoadFactor = new Setting<>(0.75f);
 
     /**
-     * How far are you allowed to fall onto solid ground (without a water bucket)?
+     * How far are you allowed to fall onto solid ground (without clutching)?
      * 3 won't deal any damage. But if you just want to get down the mountain quickly and you have
      * Feather Falling IV, you might set it a bit higher, like 4 or 5.
      */
-    public final Setting<Integer> maxFallHeightNoWater = new Setting<>(3);
+    public final Setting<Integer> maxFallHeightNoClutch = new Setting<>(3);
 
     /**
-     * How far are you allowed to fall onto solid ground (with a water bucket)?
+     * How far are you allowed to fall onto solid ground (while clutching)?
      * It's not that reliable, so I've set it below what would kill an unarmored player (23)
      */
-    public final Setting<Integer> maxFallHeightBucket = new Setting<>(20);
+    public final Setting<Integer> maxFallHeightClutch = new Setting<>(20);
 
     /**
      * Is it okay to sprint through a descend followed by a diagonal?

src/api/java/baritone/api/pathing/movement/ActionCosts.java

@@ -17,6 +17,8 @@
 
 package baritone.api.pathing.movement;
 
+import baritone.api.utils.Pair;
+
 public interface ActionCosts {
 
     /**
@@ -76,10 +78,15 @@ static double velocity(int ticks) {
         return (Math.pow(0.98, ticks) - 1) * -3.92;
     }
 
-    static double oldFormula(double ticks) {
-        return -3.92 * (99 - 49.5 * (Math.pow(0.98, ticks) + 1) - ticks);
+    static double velocity(int ticks, double distanceMultiplier, double startingVelocity) {
+        double velocity = startingVelocity;
+        for (int i = 0; i < ticks; i++) {
+            velocity = 0.98 * (velocity + distanceMultiplier);
+        }
+        return velocity;
     }
 
+
     static double distanceToTicks(double distance) {
         if (distance == 0) {
             return 0; // Avoid 0/0 NaN
@@ -95,4 +102,47 @@ static double distanceToTicks(double distance) {
             tickCount++;
         }
     }
+
+    static double distanceToTicks(double distance, double distanceMultiplier, double startingVelocity) {
+        if (distance == 0) {
+            return 0d; // Avoid 0/0 NaN
+        }
+        double tmpDistance = distance;
+        int tickCount = 0;
+        while (true) {
+            double velocity = velocity(tickCount, distanceMultiplier, startingVelocity);
+            if (tmpDistance <= velocity) {
+                return tickCount + tmpDistance / velocity;
+            }
+            tmpDistance -= velocity;
+            tickCount++;
+        }
+    }
+
+    static Pair<Double, Double> distanceToTicks(double distance, double endBlockHeight, double endBlockSpeedMultiplier, double startingVelocity) {
+        if (distance == 0) {
+            return new Pair<>(0d, startingVelocity);
+        }
+        double tmpDistance = distance;
+        int tickCount = 0;
+        boolean firstTick = true;
+        while (true) {
+            double velocity;
+            if (tmpDistance < endBlockHeight) {
+                if (firstTick) {
+                    firstTick = false;
+                    velocity = velocity(tickCount, 0.08d, startingVelocity) * endBlockSpeedMultiplier;
+                } else {
+                    velocity = 0.0784d * endBlockSpeedMultiplier;
+                }
+            } else {
+                velocity = velocity(tickCount, 0.08d, startingVelocity);
+            }
+            if (tmpDistance <= velocity) {
+                return new Pair<>(tickCount + tmpDistance / velocity, velocity);
+            }
+            tmpDistance -= velocity;
+            tickCount++;
+        }
+    }
 }

src/api/java/baritone/api/utils/RayTraceUtils.java

@@ -50,7 +50,7 @@ public static HitResult rayTraceTowards(Entity entity, Rotation rotation, double
         if (wouldSneak) {
             start = inferSneakingEyePosition(entity);
         } else {
-            start = entity.getEyePosition(1.0F); // do whatever is correct
+            start = entity.getEyePosition();
         }
 
         Vec3 direction = RotationUtils.calcLookDirectionFromRotation(rotation);

src/api/java/baritone/api/utils/RotationUtils.java

@@ -186,6 +186,7 @@ public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos, dou
              *
              * or if you're a normal person literally all this does it ensure that we don't nudge the pitch to a normal level
              */
+            // TODO This is a very hacky solution.
             Rotation hypothetical = ctx.playerRotations().add(new Rotation(0, 0.0001F));
             if (wouldSneak) {
                 // the concern here is: what if we're looking at it now, but as soon as we start sneaking we no longer are

src/main/java/baritone/behavior/InventoryBehavior.java

@@ -167,17 +167,21 @@ public boolean hasGenericThrowaway() {
         return false;
     }
 
-    public boolean selectThrowawayForLocation(boolean select, int x, int y, int z) {
+    public boolean selectThrowawayForLocation(boolean select, int x, int y, int z, Item customItem) {
         BlockState maybe = baritone.getBuilderProcess().placeAt(x, y, z, baritone.bsi.get0(x, y, z));
-        if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof BlockItem && maybe.equals(((BlockItem) stack.getItem()).getBlock().getStateForPlacement(new BlockPlaceContext(new UseOnContext(ctx.world(), ctx.player(), InteractionHand.MAIN_HAND, stack, new BlockHitResult(new Vec3(ctx.player().position().x, ctx.player().position().y, ctx.player().position().z), Direction.UP, ctx.playerFeet(), false)) {}))))) {
+        if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof BlockItem && maybe.equals(((BlockItem) stack.getItem()).getBlock().getStateForPlacement(new BlockPlaceContext(ctx.player(), InteractionHand.MAIN_HAND, stack, new BlockHitResult(new Vec3(ctx.player().position().x, ctx.player().position().y, ctx.player().position().z), Direction.UP, ctx.playerFeet(), false)))))) {
             return true; // gotem
         }
         if (maybe != null && throwaway(select, stack -> stack.getItem() instanceof BlockItem && ((BlockItem) stack.getItem()).getBlock().equals(maybe.getBlock()))) {
             return true;
         }
-        for (Item item : Baritone.settings().acceptableThrowawayItems.value) {
-            if (throwaway(select, stack -> item.equals(stack.getItem()))) {
-                return true;
+        if (customItem != null) {
+            return throwaway(select, stack -> stack.is(customItem));
+        } else {
+            for (Item item : Baritone.settings().acceptableThrowawayItems.value) {
+                if (throwaway(select, stack -> item.equals(stack.getItem()))) {
+                    return true;
+                }
             }
         }
         return false;
@@ -225,8 +229,7 @@ public boolean throwaway(boolean select, Predicate<? super ItemStack> desired, b
             for (int i = 9; i < 36; i++) {
                 if (desired.test(inv.get(i))) {
                     if (select) {
-                        requestSwapWithHotBar(i, 7);
-                        p.getInventory().selected = 7;
+                        requestSwapWithHotBar(i, p.getInventory().selected);
                     }
                     return true;
                 }

src/main/java/baritone/pathing/clutch/Clutch.java

@@ -0,0 +1,109 @@
+/*
+ * 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.clutch;
+
+import baritone.Baritone;
+import baritone.api.IBaritone;
+import baritone.api.pathing.movement.ActionCosts;
+import baritone.api.utils.BetterBlockPos;
+import baritone.api.utils.IPlayerContext;
+import baritone.api.utils.Pair;
+import baritone.pathing.movement.CalculationContext;
+import baritone.pathing.movement.MovementHelper;
+import baritone.pathing.movement.MovementState;
+import baritone.utils.pathing.MutableClutchResult;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public abstract class Clutch {
+    private final double costMultiplier;
+
+    protected Clutch(double costMultiplier) {
+        this.costMultiplier = costMultiplier;
+    }
+
+    protected Clutch() {
+        this(1d);
+    }
+
+    public final ItemStack getClutchingItem(CalculationContext context) { // We could return the slot instead of the item
+        for (int slot = 0; slot < (Baritone.settings().allowInventory.value ? 36 : 9); slot++) {
+            ItemStack item = context.getBaritone().getPlayerContext().player().getInventory().items.get(slot);
+            if (isAcceptedItem(item.getItem())) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public abstract boolean isAcceptedItem(Item item);
+
+    public abstract boolean compare(BlockState state);
+
+    public boolean isSolid(CalculationContext context) {
+        return false;
+    }
+
+    public boolean isPlaceable(CalculationContext context, int x, int y, int z, BlockState block) {
+        return MovementHelper.canPlaceAgainst(context.bsi, x, y, z, block);
+    }
+
+    public boolean clutch(IBaritone baritone, MovementState state, BlockPos dest, MutableClutchResult result) {
+        return ClutchUtils.blockClutch(baritone, state, dest, result, true);
+    }
+
+    public boolean hasClutched(IPlayerContext ctx, BetterBlockPos dest, BlockState destState) {
+        VoxelShape shape = destState.getCollisionShape(ctx.world(), dest);
+        if (shape.isEmpty()) {
+            return ctx.player().getBoundingBox().intersects(dest.x, dest.y, dest.z, dest.x + 1, dest.y + 1, dest.z + 1);
+        } else {
+            return ctx.player().getBoundingBox().intersects(
+                    dest.x + shape.bounds().minX, dest.x + shape.bounds().minY, dest.x + shape.bounds().minZ,
+                    dest.x + shape.bounds().maxX, dest.x + shape.bounds().maxY, dest.x + shape.bounds().maxZ);
+        }
+    }
+
+    public boolean isFinished(IPlayerContext ctx, MovementState state, MutableClutchResult result) {
+        return true;
+    }
+
+    public float getFallDamage(int fallDamage) {
+        return 0f;
+    }
+
+    public Pair<Double, Double> getCost(double distance, double endBlockHeight, double velocity) {
+        return ActionCosts.distanceToTicks(distance, endBlockHeight, costMultiplier, velocity);
+    }
+
+    public double getAdditionalCost() {
+        return 0d;
+    }
+
+    public boolean slowsOnTopBlock() {
+        return true;
+    }
+
+    public boolean topBlockPriority() {
+        return true;
+    }
+}

src/main/java/baritone/pathing/clutch/ClutchUtils.java

@@ -0,0 +1,66 @@
+/*
+ * 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.clutch;
+
+import baritone.api.IBaritone;
+import baritone.api.utils.input.Input;
+import baritone.pathing.clutch.clutches.*;
+import baritone.pathing.movement.MovementHelper;
+import baritone.pathing.movement.MovementState;
+import baritone.utils.pathing.MutableClutchResult;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+public interface ClutchUtils {
+    // This list holds the order to try the clutches in. More convenient clutches should go further up.
+    Clutch[] CLUTCHES = new Clutch[]{
+            WaterClutch.INSTANCE,
+            LavaClutch.INSTANCE,
+            PowderedSnowClutch.INSTANCE,
+            TwistingVineClutch.INSTANCE,
+            SweetBerryClutch.INSTANCE,
+            VineClutch.INSTANCE,
+            LadderClutch.INSTANCE,
+            ScaffoldingClutch.INSTANCE,
+            SlimeClutch.INSTANCE,
+            HayBaleClutch.INSTANCE,
+            CobwebClutch.INSTANCE,
+            BlockClutch.INSTANCE,
+    };
+    ItemStack STACK_EMPTY_BUCKET = new ItemStack(Items.BUCKET);
+
+    static boolean blockClutch(IBaritone baritone, MovementState state, BlockPos dest, MutableClutchResult result, boolean allowDown) {
+        if (MovementHelper.attemptToPlaceABlock(state, baritone, dest, allowDown, true, true, result.item.getItem()) == MovementHelper.PlaceResult.READY_TO_PLACE) {
+            state.setInput(Input.CLICK_RIGHT, true);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    static boolean bucketPickup(MovementState state, Inventory inventory) {
+        int slot = inventory.findSlotMatchingItem(STACK_EMPTY_BUCKET);
+        if (Inventory.isHotbarSlot(slot)) {
+            inventory.selected = slot;
+            state.setInput(Input.CLICK_RIGHT, true);
+        }
+        return slot == -1;
+    }
+}

src/main/java/baritone/pathing/clutch/clutches/BlockClutch.java

@@ -0,0 +1,51 @@
+/*
+ * 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.clutch.clutches;
+
+import baritone.pathing.clutch.Clutch;
+import baritone.pathing.movement.CalculationContext;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class BlockClutch extends Clutch {
+    public static final BlockClutch INSTANCE = new BlockClutch();
+
+    private BlockClutch() {}
+
+    @Override
+    public boolean isAcceptedItem(Item item) {
+        return item instanceof BlockItem blockItem &&
+                !blockItem.getBlock().defaultBlockState().getCollisionShape(null, null).isEmpty();
+    }
+
+    @Override
+    public boolean compare(BlockState state) {
+        return !state.getCollisionShape(null, null).isEmpty();
+    }
+
+    @Override
+    public boolean isSolid(CalculationContext context) {
+        return true;
+    }
+
+    @Override
+    public float getFallDamage(int fallDamage) {
+        return fallDamage;
+    }
+}