From 037809634013edba7d75ad5448d0f4faae472a89 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 11 May 2025 18:12:11 -0400
Subject: [PATCH 01/22] Make Baritone not look forward while bridging.

---
 .../java/baritone/pathing/movement/MovementHelper.java   | 9 +++++++++
 .../pathing/movement/movements/MovementTraverse.java     | 6 +++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 0fa326d51..11b6d2a55 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -658,6 +658,15 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
         )).setInput(Input.MOVE_FORWARD, true);
     }
 
+    static void alignBridge(IPlayerContext ctx, MovementState state, BlockPos dest) {
+        state.setTarget(new MovementTarget(
+                RotationUtils.calcRotationFromVec3d(VecUtils.getBlockPosCenter(dest),
+                        ctx.playerHead(),
+                        ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
+                false
+        )).setInput(Input.MOVE_BACK, true);
+    }
+
     /**
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index cec3ca39a..f9ae54770 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -283,6 +283,7 @@ public MovementState updateState(MovementState state) {
                 }
             }
             MovementHelper.moveTowards(ctx, state, against);
+//            MovementHelper.moveBackwards(ctx, state, against);
             return state;
         } else {
             wasTheBridgeBlockAlwaysThere = false;
@@ -315,6 +316,7 @@ public MovementState updateState(MovementState state) {
                             // but only if our attempted place is straight ahead
                             return state.setInput(Input.MOVE_FORWARD, true);
                         }
+//                        return state.setInput(Input.MOVE_BACK, true);
                     } else if (ctx.playerRotations().isReallyCloseTo(state.getTarget().rotation)) {
                         // well i guess theres something in the way
                         return state.setInput(Input.CLICK_LEFT, true);
@@ -352,7 +354,9 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-            MovementHelper.moveTowards(ctx, state, positionsToBreak[0]);
+//            MovementHelper.moveTowards(ctx, state, positionsToBreak[0]);
+//            MovementHelper.moveTowardsBlock(ctx, state, positionsToBreak[0]);
+            MovementHelper.alignBridge(ctx, state, dest);
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }

From 1078270eb37e302de8ca93b01ead8cbfcc20dbc7 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Tue, 13 May 2025 21:46:37 -0400
Subject: [PATCH 02/22] Clean up.

---
 .../baritone/pathing/movement/movements/MovementTraverse.java | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index f9ae54770..012b186d6 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -283,7 +283,6 @@ public MovementState updateState(MovementState state) {
                 }
             }
             MovementHelper.moveTowards(ctx, state, against);
-//            MovementHelper.moveBackwards(ctx, state, against);
             return state;
         } else {
             wasTheBridgeBlockAlwaysThere = false;
@@ -316,7 +315,6 @@ public MovementState updateState(MovementState state) {
                             // but only if our attempted place is straight ahead
                             return state.setInput(Input.MOVE_FORWARD, true);
                         }
-//                        return state.setInput(Input.MOVE_BACK, true);
                     } else if (ctx.playerRotations().isReallyCloseTo(state.getTarget().rotation)) {
                         // well i guess theres something in the way
                         return state.setInput(Input.CLICK_LEFT, true);
@@ -354,8 +352,6 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-//            MovementHelper.moveTowards(ctx, state, positionsToBreak[0]);
-//            MovementHelper.moveTowardsBlock(ctx, state, positionsToBreak[0]);
             MovementHelper.alignBridge(ctx, state, dest);
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block

From cbfb329b94422b7bb7ab22d7c4a13d6521b1d35c Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Fri, 23 May 2025 18:31:34 -0400
Subject: [PATCH 03/22] Add direction-independent movement.

---
 .../pathing/movement/MovementHelper.java      | 75 +++++++++++++++++--
 .../movement/movements/MovementTraverse.java  |  5 +-
 2 files changed, 72 insertions(+), 8 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 11b6d2a55..b495b0927 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -31,6 +31,7 @@
 import baritone.utils.ToolSet;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.util.Mth;
 import net.minecraft.world.item.enchantment.EnchantmentHelper;
 import net.minecraft.world.level.block.*;
 import net.minecraft.world.level.block.piston.MovingPistonBlock;
@@ -658,13 +659,73 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
         )).setInput(Input.MOVE_FORWARD, true);
     }
 
-    static void alignBridge(IPlayerContext ctx, MovementState state, BlockPos dest) {
-        state.setTarget(new MovementTarget(
-                RotationUtils.calcRotationFromVec3d(VecUtils.getBlockPosCenter(dest),
-                        ctx.playerHead(),
-                        ctx.playerRotations()).withPitch(ctx.playerRotations().getPitch()),
-                false
-        )).setInput(Input.MOVE_BACK, true);
+    static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, BlockPos dest, Rotation rotation) {
+        state.setTarget(new MovementTarget(rotation, false));
+        /*
+        Options:
+        W: ax, az
+        S: -ax,-az
+        A: -az,ax
+        D: az,-ax
+        W+A:ax-az,az+ax,
+        W+D:ax+az,az-ax,
+        S+A:-ax-az,-az+ax,
+        S+D:-ax+az,-az-ax
+        */
+        boolean canSprint = Baritone.settings().allowSprint.value;
+        float ax = Mth.sin((float)Math.toRadians(ctx.playerRotations().getYaw()));
+        float az = Mth.cos((float)Math.toRadians(ctx.playerRotations().getYaw()));
+        Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+                VecUtils.getBlockPosCenter(dest),
+                ctx.playerRotations());
+        float targetAx = Mth.sin((float)Math.toRadians(blockRotation.getYaw()));
+        float targetAz = Mth.cos((float)Math.toRadians(blockRotation.getYaw()));
+        float[][] options = {
+                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az},
+                {-ax, -az},
+                {-az, az},
+                {az, -ax},
+                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax},
+                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax},
+                {-ax - az, -az + ax},
+                {-ax + az, -az - ax}
+        };
+        int selection = -1;
+        float closestX = 100000;
+        float closestZ = 100000;
+        for (int i = 0; i < options.length; i++) {
+            if (Math.abs(targetAx - options[i][0]) + Math.abs(targetAz - options[i][1]) < closestX + closestZ) {
+                closestX = Math.abs(targetAx - options[i][0]);
+                closestZ = Math.abs(targetAz - options[i][1]);
+                selection = i;
+            }
+        }
+        switch (selection) {
+            case 0:
+                state.setInput(Input.MOVE_FORWARD, true);
+                break;
+            case 1:
+                state.setInput(Input.MOVE_BACK, true);
+                break;
+            case 2:
+                state.setInput(Input.MOVE_LEFT, true);
+                break;
+            case 3:
+                state.setInput(Input.MOVE_RIGHT, true);
+                break;
+            case 4:
+                state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_LEFT, true);
+                break;
+            case 5:
+                state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_RIGHT, true);
+                break;
+            case 6:
+                state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_LEFT, true);
+                break;
+            case 7:
+                state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
+                break;
+        }
     }
 
     /**
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 012b186d6..e32603afd 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -352,7 +352,10 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-            MovementHelper.alignBridge(ctx, state, dest);
+            MovementHelper.moveTowardsWithRotation(ctx, state, dest,
+                    RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+                            VecUtils.getBlockPosCenter(dest),
+                    ctx.playerRotations()).add(new Rotation(225, 0).withPitch(ctx.playerRotations().getPitch())));
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }

From 72fb0a0d28d84b6e649e7e6fa0ba1318d6af1ace Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Fri, 23 May 2025 22:04:13 -0400
Subject: [PATCH 04/22] Add default to switch case.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index b495b0927..8777bcc6f 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -725,6 +725,8 @@ static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, Blo
             case 7:
                 state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
                 break;
+            default:
+                break;
         }
     }
 

From 83afa1126edd4f81b3767966ebf8815824e83c00 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Wed, 2 Jul 2025 16:08:14 -0400
Subject: [PATCH 05/22] Fix.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java     | 2 +-
 .../baritone/pathing/movement/movements/MovementTraverse.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 8777bcc6f..935cb9eb9 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -660,7 +660,7 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
     }
 
     static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, BlockPos dest, Rotation rotation) {
-        state.setTarget(new MovementTarget(rotation, false));
+        state.setTarget(new MovementTarget(rotation, true));
         /*
         Options:
         W: ax, az
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index e32603afd..c973b8e97 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -355,7 +355,7 @@ public MovementState updateState(MovementState state) {
             MovementHelper.moveTowardsWithRotation(ctx, state, dest,
                     RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                             VecUtils.getBlockPosCenter(dest),
-                    ctx.playerRotations()).add(new Rotation(225, 0).withPitch(ctx.playerRotations().getPitch())));
+                    ctx.playerRotations()).add(new Rotation(45, 0).withPitch(ctx.playerRotations().getPitch())));
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }

From 191155315b2c8fe35a214406d6399c1677093c9e Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 6 Jul 2025 20:25:02 -0400
Subject: [PATCH 06/22] Keep original player movement.

---
 .../pathing/movement/MovementHelper.java      | 27 ++++++-------------
 .../movement/movements/MovementTraverse.java  |  5 +---
 2 files changed, 9 insertions(+), 23 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 935cb9eb9..ed197acd9 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -661,17 +661,6 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
 
     static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, BlockPos dest, Rotation rotation) {
         state.setTarget(new MovementTarget(rotation, true));
-        /*
-        Options:
-        W: ax, az
-        S: -ax,-az
-        A: -az,ax
-        D: az,-ax
-        W+A:ax-az,az+ax,
-        W+D:ax+az,az-ax,
-        S+A:-ax-az,-az+ax,
-        S+D:-ax+az,-az-ax
-        */
         boolean canSprint = Baritone.settings().allowSprint.value;
         float ax = Mth.sin((float)Math.toRadians(ctx.playerRotations().getYaw()));
         float az = Mth.cos((float)Math.toRadians(ctx.playerRotations().getYaw()));
@@ -681,14 +670,14 @@ static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, Blo
         float targetAx = Mth.sin((float)Math.toRadians(blockRotation.getYaw()));
         float targetAz = Mth.cos((float)Math.toRadians(blockRotation.getYaw()));
         float[][] options = {
-                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az},
-                {-ax, -az},
-                {-az, az},
-                {az, -ax},
-                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax},
-                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax},
-                {-ax - az, -az + ax},
-                {-ax + az, -az - ax}
+                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
+                {-ax, -az}, // S
+                {-az, az}, // A
+                {az, -ax}, // D
+                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax}, // W+A
+                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax}, // W+D
+                {-ax - az, -az + ax}, // S+A
+                {-ax + az, -az - ax} // S+D
         };
         int selection = -1;
         float closestX = 100000;
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index c973b8e97..8b605810f 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -352,10 +352,7 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-            MovementHelper.moveTowardsWithRotation(ctx, state, dest,
-                    RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
-                            VecUtils.getBlockPosCenter(dest),
-                    ctx.playerRotations()).add(new Rotation(45, 0).withPitch(ctx.playerRotations().getPitch())));
+            MovementHelper.moveTowardsWithRotation(ctx, state, dest, ctx.playerRotations());
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }

From 5d8136b02ea118449d6bf09ee3bc8a845201760f Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 13 Jul 2025 10:09:16 -0400
Subject: [PATCH 07/22] Simplify.

---
 .../pathing/movement/MovementHelper.java      | 63 +++++++++++--------
 1 file changed, 37 insertions(+), 26 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index ed197acd9..d338e3a45 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -50,10 +50,12 @@
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 import java.util.Optional;
 
+import static baritone.api.utils.RotationUtils.DEG_TO_RAD_F;
 import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP;
 import static baritone.pathing.precompute.Ternary.*;
 
@@ -661,34 +663,12 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
 
     static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, BlockPos dest, Rotation rotation) {
         state.setTarget(new MovementTarget(rotation, true));
-        boolean canSprint = Baritone.settings().allowSprint.value;
-        float ax = Mth.sin((float)Math.toRadians(ctx.playerRotations().getYaw()));
-        float az = Mth.cos((float)Math.toRadians(ctx.playerRotations().getYaw()));
+        float ax = Mth.sin(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
+        float az = Mth.cos(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
         Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                 VecUtils.getBlockPosCenter(dest),
                 ctx.playerRotations());
-        float targetAx = Mth.sin((float)Math.toRadians(blockRotation.getYaw()));
-        float targetAz = Mth.cos((float)Math.toRadians(blockRotation.getYaw()));
-        float[][] options = {
-                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
-                {-ax, -az}, // S
-                {-az, az}, // A
-                {az, -ax}, // D
-                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax}, // W+A
-                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax}, // W+D
-                {-ax - az, -az + ax}, // S+A
-                {-ax + az, -az - ax} // S+D
-        };
-        int selection = -1;
-        float closestX = 100000;
-        float closestZ = 100000;
-        for (int i = 0; i < options.length; i++) {
-            if (Math.abs(targetAx - options[i][0]) + Math.abs(targetAz - options[i][1]) < closestX + closestZ) {
-                closestX = Math.abs(targetAx - options[i][0]);
-                closestZ = Math.abs(targetAz - options[i][1]);
-                selection = i;
-            }
-        }
+        int selection = getSelection(blockRotation, ax, az);
         switch (selection) {
             case 0:
                 state.setInput(Input.MOVE_FORWARD, true);
@@ -719,6 +699,37 @@ static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, Blo
         }
     }
 
+    private static int getSelection(Rotation blockRotation, float ax, float az) {
+        float targetAx = Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F);
+        float targetAz = Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F);
+        float[][] options = getOptions(ax, az);
+        int selection = -1;
+        float closestX = 100000;
+        float closestZ = 100000;
+        for (int i = 0; i < options.length; i++) {
+            if (Math.abs(targetAx - options[i][0]) + Math.abs(targetAz - options[i][1]) < closestX + closestZ) {
+                closestX = Math.abs(targetAx - options[i][0]);
+                closestZ = Math.abs(targetAz - options[i][1]);
+                selection = i;
+            }
+        }
+        return selection;
+    }
+
+    private static float[] @NotNull [] getOptions(float ax, float az) {
+        boolean canSprint = Baritone.settings().allowSprint.value;
+        return new float[][]{
+                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
+                {-ax, -az}, // S
+                {-az, az}, // A
+                {az, -ax}, // D
+                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax}, // W+A
+                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax}, // W+D
+                {-ax - az, -az + ax}, // S+A
+                {-ax + az, -az - ax} // S+D
+        };
+    }
+
     /**
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.
@@ -838,7 +849,7 @@ static PlaceResult attemptToPlaceABlock(MovementState state, IBaritone baritone,
         if (ctx.getSelectedBlock().isPresent()) {
             BlockPos selectedBlock = ctx.getSelectedBlock().get();
             Direction side = ((BlockHitResult) ctx.objectMouseOver()).getDirection();
-            // only way for selectedBlock.equals(placeAt) to be true is if it's replacable
+            // only way for selectedBlock.equals(placeAt) to be true is if it's replaceable
             if (selectedBlock.equals(placeAt) || (MovementHelper.canPlaceAgainst(ctx, selectedBlock) && selectedBlock.relative(side).equals(placeAt))) {
                 if (wouldSneak) {
                     state.setInput(Input.SNEAK, true);

From 8ee7a1e39d2bade64366cbca03fc79db08d1b648 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Wed, 23 Jul 2025 00:29:03 -0400
Subject: [PATCH 08/22] Small change.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java    | 3 +--
 .../baritone/pathing/movement/movements/MovementTraverse.java  | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index d338e3a45..525c4ec95 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -661,8 +661,7 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
         )).setInput(Input.MOVE_FORWARD, true);
     }
 
-    static void moveTowardsWithRotation(IPlayerContext ctx, MovementState state, BlockPos dest, Rotation rotation) {
-        state.setTarget(new MovementTarget(rotation, true));
+    static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, BlockPos dest) {
         float ax = Mth.sin(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
         float az = Mth.cos(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
         Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 8b605810f..d133f75ad 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -352,7 +352,7 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-            MovementHelper.moveTowardsWithRotation(ctx, state, dest, ctx.playerRotations());
+            MovementHelper.moveTowardsWithoutRotation(ctx, state, dest);
             return state;
             // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }

From 1a3d302e464c189a60631b43233b65828f795da9 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Wed, 23 Jul 2025 00:49:45 -0400
Subject: [PATCH 09/22] Clean up.

---
 .../pathing/movement/MovementHelper.java      | 38 +++++--------------
 .../movement/movements/MovementTraverse.java  |  1 -
 2 files changed, 10 insertions(+), 29 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 525c4ec95..b45e41a23 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -669,32 +669,14 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
                 ctx.playerRotations());
         int selection = getSelection(blockRotation, ax, az);
         switch (selection) {
-            case 0:
-                state.setInput(Input.MOVE_FORWARD, true);
-                break;
-            case 1:
-                state.setInput(Input.MOVE_BACK, true);
-                break;
-            case 2:
-                state.setInput(Input.MOVE_LEFT, true);
-                break;
-            case 3:
-                state.setInput(Input.MOVE_RIGHT, true);
-                break;
-            case 4:
-                state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_LEFT, true);
-                break;
-            case 5:
-                state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_RIGHT, true);
-                break;
-            case 6:
-                state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_LEFT, true);
-                break;
-            case 7:
-                state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
-                break;
-            default:
-                break;
+            case 0 -> state.setInput(Input.MOVE_FORWARD, true);
+            case 1 -> state.setInput(Input.MOVE_BACK, true);
+            case 2 -> state.setInput(Input.MOVE_LEFT, true);
+            case 3 -> state.setInput(Input.MOVE_RIGHT, true);
+            case 4 -> state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_LEFT, true);
+            case 5 -> state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_RIGHT, true);
+            case 6 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_LEFT, true);
+            case 7 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
         }
     }
 
@@ -706,7 +688,7 @@ private static int getSelection(Rotation blockRotation, float ax, float az) {
         float closestX = 100000;
         float closestZ = 100000;
         for (int i = 0; i < options.length; i++) {
-            if (Math.abs(targetAx - options[i][0]) + Math.abs(targetAz - options[i][1]) < closestX + closestZ) {
+            if (Mth.abs(targetAx - options[i][0]) + Mth.abs(targetAz - options[i][1]) < closestX + closestZ) {
                 closestX = Math.abs(targetAx - options[i][0]);
                 closestZ = Math.abs(targetAz - options[i][1]);
                 selection = i;
@@ -715,7 +697,7 @@ private static int getSelection(Rotation blockRotation, float ax, float az) {
         return selection;
     }
 
-    private static float[] @NotNull [] getOptions(float ax, float az) {
+    private static float[][] getOptions(float ax, float az) {
         boolean canSprint = Baritone.settings().allowSprint.value;
         return new float[][]{
                 {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index d133f75ad..cff8ee636 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -354,7 +354,6 @@ public MovementState updateState(MovementState state) {
             }
             MovementHelper.moveTowardsWithoutRotation(ctx, state, dest);
             return state;
-            // TODO MovementManager.moveTowardsBlock(to); // move towards not look at because if we are bridging for a couple blocks in a row, it is faster if we dont spin around and walk forwards then spin around and place backwards for every block
         }
     }
 

From 9d338586871fd610fd64fa279b318522056748c0 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Fri, 25 Jul 2025 16:41:38 -0400
Subject: [PATCH 10/22] Small change.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 50734a367..821027070 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -50,7 +50,6 @@
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
 import net.minecraft.world.phys.Vec3;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 import java.util.List;

From 102960446df35bb5e2264e504fb8e7a0230ace76 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Thu, 31 Jul 2025 18:17:35 -0400
Subject: [PATCH 11/22] Fix bug.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 821027070..3df52b287 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -702,7 +702,7 @@ private static float[][] getOptions(float ax, float az) {
         return new float[][]{
                 {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
                 {-ax, -az}, // S
-                {-az, az}, // A
+                {-az, ax}, // A
                 {az, -ax}, // D
                 {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax}, // W+A
                 {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax}, // W+D

From 7b5ba80f678d793bd53da59677c0610d7ae7d55c Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Wed, 6 Aug 2025 15:38:53 -0400
Subject: [PATCH 12/22] Change to Vec2.

---
 .../pathing/movement/MovementHelper.java      | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 3df52b287..bad5d3e67 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -49,6 +49,7 @@
 import net.minecraft.world.level.pathfinder.PathComputationType;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec2;
 import net.minecraft.world.phys.Vec3;
 
 import java.util.ArrayList;
@@ -677,37 +678,38 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
             case 5 -> state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_RIGHT, true);
             case 6 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_LEFT, true);
             case 7 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
+            default -> {}
         }
     }
 
     private static int getSelection(Rotation blockRotation, float ax, float az) {
         float targetAx = Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F);
         float targetAz = Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F);
-        float[][] options = getOptions(ax, az);
+        Vec2[] options = getOptions(ax, az);
         int selection = -1;
         float closestX = 100000;
         float closestZ = 100000;
         for (int i = 0; i < options.length; i++) {
-            if (Mth.abs(targetAx - options[i][0]) + Mth.abs(targetAz - options[i][1]) < closestX + closestZ) {
-                closestX = Math.abs(targetAx - options[i][0]);
-                closestZ = Math.abs(targetAz - options[i][1]);
+            if (Mth.abs(targetAx - options[i].x) + Mth.abs(targetAz - options[i].y) < closestX + closestZ) {
+                closestX = Math.abs(targetAx - options[i].x);
+                closestZ = Math.abs(targetAz - options[i].y);
                 selection = i;
             }
         }
         return selection;
     }
 
-    private static float[][] getOptions(float ax, float az) {
+    private static Vec2[] getOptions(float ax, float az) {
         boolean canSprint = Baritone.settings().allowSprint.value;
-        return new float[][]{
-                {canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az}, // W
-                {-ax, -az}, // S
-                {-az, ax}, // A
-                {az, -ax}, // D
-                {(canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax}, // W+A
-                {(canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax}, // W+D
-                {-ax - az, -az + ax}, // S+A
-                {-ax + az, -az - ax} // S+D
+        return new Vec2[]{
+                new Vec2(canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az), // W
+                new Vec2(-ax, -az), // S
+                new Vec2(-az, ax), // A
+                new Vec2(az, -ax), // D
+                new Vec2((canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax), // W+A
+                new Vec2((canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax), // W+D
+                new Vec2(-ax - az, -az + ax), // S+A
+                new Vec2(-ax + az, -az - ax) // S+D
         };
     }
 

From f1e5c44b85509a0159199008124f55e6e344eede Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 17 Aug 2025 19:52:14 -0400
Subject: [PATCH 13/22] Replace messy Vec2 with a cleaner record class. Also,
 remove a messy switch case.

---
 .../pathing/movement/MovementHelper.java      | 51 ++++++++-----------
 .../pathing/movement/MovementOption.java      | 36 +++++++++++++
 2 files changed, 57 insertions(+), 30 deletions(-)
 create mode 100644 src/main/java/baritone/pathing/movement/MovementOption.java

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index bad5d3e67..80e8c3d13 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -668,48 +668,39 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
         Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                 VecUtils.getBlockPosCenter(dest),
                 ctx.playerRotations());
-        int selection = getSelection(blockRotation, ax, az);
-        switch (selection) {
-            case 0 -> state.setInput(Input.MOVE_FORWARD, true);
-            case 1 -> state.setInput(Input.MOVE_BACK, true);
-            case 2 -> state.setInput(Input.MOVE_LEFT, true);
-            case 3 -> state.setInput(Input.MOVE_RIGHT, true);
-            case 4 -> state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_LEFT, true);
-            case 5 -> state.setInput(Input.MOVE_FORWARD, true).setInput(Input.MOVE_RIGHT, true);
-            case 6 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_LEFT, true);
-            case 7 -> state.setInput(Input.MOVE_BACK, true).setInput(Input.MOVE_RIGHT, true);
-            default -> {}
-        }
+        MovementOption selection = getSelection(blockRotation, ax, az);
+        selection.setInputs(state);
     }
 
-    private static int getSelection(Rotation blockRotation, float ax, float az) {
+    private static MovementOption getSelection(Rotation blockRotation, float ax, float az) {
         float targetAx = Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F);
         float targetAz = Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F);
-        Vec2[] options = getOptions(ax, az);
-        int selection = -1;
+        MovementOption[] options = getOptions(ax, az);
+        MovementOption selection = null;
         float closestX = 100000;
         float closestZ = 100000;
-        for (int i = 0; i < options.length; i++) {
-            if (Mth.abs(targetAx - options[i].x) + Mth.abs(targetAz - options[i].y) < closestX + closestZ) {
-                closestX = Math.abs(targetAx - options[i].x);
-                closestZ = Math.abs(targetAz - options[i].y);
-                selection = i;
+        for (MovementOption option : options) {
+            if (Mth.abs(targetAx - option.motionX()) + Mth.abs(targetAz - option.motionZ()) < closestX + closestZ) {
+                closestX = Math.abs(targetAx - option.motionX());
+                closestZ = Math.abs(targetAz - option.motionZ());
+                selection = option;
             }
         }
         return selection;
     }
 
-    private static Vec2[] getOptions(float ax, float az) {
+    private static MovementOption[] getOptions(float ax, float az) {
         boolean canSprint = Baritone.settings().allowSprint.value;
-        return new Vec2[]{
-                new Vec2(canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az), // W
-                new Vec2(-ax, -az), // S
-                new Vec2(-az, ax), // A
-                new Vec2(az, -ax), // D
-                new Vec2((canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax), // W+A
-                new Vec2((canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax), // W+D
-                new Vec2(-ax - az, -az + ax), // S+A
-                new Vec2(-ax + az, -az - ax) // S+D
+
+        return new MovementOption[]{
+                new MovementOption(Input.MOVE_FORWARD, canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az),
+                new MovementOption(Input.MOVE_BACK, -ax, -az),
+                new MovementOption(Input.MOVE_LEFT, -az, ax),
+                new MovementOption(Input.MOVE_RIGHT, az, -ax),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_LEFT, (canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax),
+                new MovementOption(Input.MOVE_BACK, Input.MOVE_LEFT, -ax - az, -az + ax),
+                new MovementOption(Input.MOVE_BACK, Input.MOVE_RIGHT, -ax + az, -az - ax),
         };
     }
 
diff --git a/src/main/java/baritone/pathing/movement/MovementOption.java b/src/main/java/baritone/pathing/movement/MovementOption.java
new file mode 100644
index 000000000..41c678c3c
--- /dev/null
+++ b/src/main/java/baritone/pathing/movement/MovementOption.java
@@ -0,0 +1,36 @@
+/*
+ * 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.movement;
+
+import baritone.api.utils.input.Input;
+
+public record MovementOption(Input input1, Input input2, float motionX, float motionZ) {
+
+    public MovementOption(Input input1, float motionX, float motionZ) {
+        this(input1, null, motionX, motionZ);
+    }
+
+    public void setInputs(MovementState movementState) {
+        if (input1 != null) {
+            movementState.setInput(input1, true);
+        }
+        if (input2 != null) {
+            movementState.setInput(input2, true);
+        }
+    }
+}

From 9714fa4fd4aa1698d35da35913a9580ef33df79d Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 17 Aug 2025 20:04:55 -0400
Subject: [PATCH 14/22] Condense logic into huge lambda.

---
 .../pathing/movement/MovementHelper.java      | 27 ++++---------------
 .../pathing/movement/MovementOption.java      |  5 ++++
 2 files changed, 10 insertions(+), 22 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 80e8c3d13..6d6f780da 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -52,9 +52,7 @@
 import net.minecraft.world.phys.Vec2;
 import net.minecraft.world.phys.Vec3;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import static baritone.api.utils.RotationUtils.DEG_TO_RAD_F;
 import static baritone.pathing.movement.Movement.HORIZONTALS_BUT_ALSO_DOWN_____SO_EVERY_DIRECTION_EXCEPT_UP;
@@ -668,25 +666,10 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
         Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                 VecUtils.getBlockPosCenter(dest),
                 ctx.playerRotations());
-        MovementOption selection = getSelection(blockRotation, ax, az);
-        selection.setInputs(state);
-    }
-
-    private static MovementOption getSelection(Rotation blockRotation, float ax, float az) {
-        float targetAx = Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F);
-        float targetAz = Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F);
-        MovementOption[] options = getOptions(ax, az);
-        MovementOption selection = null;
-        float closestX = 100000;
-        float closestZ = 100000;
-        for (MovementOption option : options) {
-            if (Mth.abs(targetAx - option.motionX()) + Mth.abs(targetAz - option.motionZ()) < closestX + closestZ) {
-                closestX = Math.abs(targetAx - option.motionX());
-                closestZ = Math.abs(targetAz - option.motionZ());
-                selection = option;
-            }
-        }
-        return selection;
+        Arrays.stream(getOptions(ax, az)).min(Comparator.comparing(option -> option.distanceToSq(
+                Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F),
+                Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F)
+        ))).ifPresent(selection -> selection.setInputs(state));
     }
 
     private static MovementOption[] getOptions(float ax, float az) {
diff --git a/src/main/java/baritone/pathing/movement/MovementOption.java b/src/main/java/baritone/pathing/movement/MovementOption.java
index 41c678c3c..a63cb0d52 100644
--- a/src/main/java/baritone/pathing/movement/MovementOption.java
+++ b/src/main/java/baritone/pathing/movement/MovementOption.java
@@ -18,6 +18,7 @@
 package baritone.pathing.movement;
 
 import baritone.api.utils.input.Input;
+import net.minecraft.util.Mth;
 
 public record MovementOption(Input input1, Input input2, float motionX, float motionZ) {
 
@@ -33,4 +34,8 @@ public void setInputs(MovementState movementState) {
             movementState.setInput(input2, true);
         }
     }
+
+    public float distanceToSq(float otherX, float otherZ) {
+        return Mth.abs(motionX() - otherX) + Mth.abs(motionZ() - otherZ);
+    }
 }

From 0eb0e6709a63aee91799cb4c254bb1ffa5e9558d Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sun, 17 Aug 2025 20:12:22 -0400
Subject: [PATCH 15/22] Condense more.

---
 .../baritone/pathing/movement/MovementHelper.java | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 6d6f780da..89f61659c 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -666,16 +666,8 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
         Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                 VecUtils.getBlockPosCenter(dest),
                 ctx.playerRotations());
-        Arrays.stream(getOptions(ax, az)).min(Comparator.comparing(option -> option.distanceToSq(
-                Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F),
-                Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F)
-        ))).ifPresent(selection -> selection.setInputs(state));
-    }
-
-    private static MovementOption[] getOptions(float ax, float az) {
         boolean canSprint = Baritone.settings().allowSprint.value;
-
-        return new MovementOption[]{
+        Arrays.stream(new MovementOption[]{
                 new MovementOption(Input.MOVE_FORWARD, canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az),
                 new MovementOption(Input.MOVE_BACK, -ax, -az),
                 new MovementOption(Input.MOVE_LEFT, -az, ax),
@@ -684,7 +676,10 @@ private static MovementOption[] getOptions(float ax, float az) {
                 new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax),
                 new MovementOption(Input.MOVE_BACK, Input.MOVE_LEFT, -ax - az, -az + ax),
                 new MovementOption(Input.MOVE_BACK, Input.MOVE_RIGHT, -ax + az, -az - ax),
-        };
+        }).min(Comparator.comparing(option -> option.distanceToSq(
+                Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F),
+                Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F)
+        ))).ifPresent(selection -> selection.setInputs(state));
     }
 
     /**

From a2a6769742d87235466d2a9d3014fe531d4728cd Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sat, 23 Aug 2025 20:25:16 -0400
Subject: [PATCH 16/22] Round yaw to 45 degrees when bridging.

---
 .../pathing/movement/MovementHelper.java      | 35 ++++++++++---------
 .../pathing/movement/MovementOption.java      | 15 ++++++++
 .../movement/movements/MovementTraverse.java  |  1 +
 3 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 89f61659c..6e82172c5 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -661,27 +661,28 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
     }
 
     static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, BlockPos dest) {
-        float ax = Mth.sin(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
-        float az = Mth.cos(ctx.playerRotations().getYaw() * DEG_TO_RAD_F);
-        Rotation blockRotation = RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
+        float idealYaw = RotationUtils.calcRotationFromVec3d(
+                ctx.playerHead(),
                 VecUtils.getBlockPosCenter(dest),
-                ctx.playerRotations());
-        boolean canSprint = Baritone.settings().allowSprint.value;
-        Arrays.stream(new MovementOption[]{
-                new MovementOption(Input.MOVE_FORWARD, canSprint ? ax * 1.3f : ax, canSprint ? az * 1.3f : az),
-                new MovementOption(Input.MOVE_BACK, -ax, -az),
-                new MovementOption(Input.MOVE_LEFT, -az, ax),
-                new MovementOption(Input.MOVE_RIGHT, az, -ax),
-                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_LEFT, (canSprint ? ax * 1.3f : ax) - az, (canSprint ? az * 1.3f : az) + ax),
-                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? ax * 1.3f : ax) + az, (canSprint ? az * 1.3f : az) - ax),
-                new MovementOption(Input.MOVE_BACK, Input.MOVE_LEFT, -ax - az, -az + ax),
-                new MovementOption(Input.MOVE_BACK, Input.MOVE_RIGHT, -ax + az, -az - ax),
-        }).min(Comparator.comparing(option -> option.distanceToSq(
-                Mth.sin(blockRotation.getYaw() * DEG_TO_RAD_F),
-                Mth.cos(blockRotation.getYaw() * DEG_TO_RAD_F)
+                ctx.playerRotations()
+        ).getYaw();
+        MovementOption.getOptions(
+                Mth.sin(ctx.playerRotations().getYaw() * DEG_TO_RAD_F),
+                Mth.cos(ctx.playerRotations().getYaw() * DEG_TO_RAD_F),
+                Baritone.settings().allowSprint.value
+        ).min(Comparator.comparing(option -> option.distanceToSq(
+                Mth.sin(idealYaw * DEG_TO_RAD_F),
+                Mth.cos(idealYaw * DEG_TO_RAD_F)
         ))).ifPresent(selection -> selection.setInputs(state));
     }
 
+    static void roundYaw(IPlayerContext ctx, MovementState state) {
+        state.setTarget(new MovementTarget(new Rotation(
+                Math.round(ctx.playerRotations().getYaw() / 45f) * 45f,
+                ctx.playerRotations().getPitch()
+        ), true));
+    }
+
     /**
      * Returns whether or not the specified block is
      * water, regardless of whether or not it is flowing.
diff --git a/src/main/java/baritone/pathing/movement/MovementOption.java b/src/main/java/baritone/pathing/movement/MovementOption.java
index a63cb0d52..22b8a7e25 100644
--- a/src/main/java/baritone/pathing/movement/MovementOption.java
+++ b/src/main/java/baritone/pathing/movement/MovementOption.java
@@ -20,6 +20,8 @@
 import baritone.api.utils.input.Input;
 import net.minecraft.util.Mth;
 
+import java.util.stream.Stream;
+
 public record MovementOption(Input input1, Input input2, float motionX, float motionZ) {
 
     public MovementOption(Input input1, float motionX, float motionZ) {
@@ -38,4 +40,17 @@ public void setInputs(MovementState movementState) {
     public float distanceToSq(float otherX, float otherZ) {
         return Mth.abs(motionX() - otherX) + Mth.abs(motionZ() - otherZ);
     }
+    
+    public static Stream<MovementOption> getOptions(float motionX, float motionZ, boolean canSprint) {
+        return Stream.of(
+                new MovementOption(Input.MOVE_FORWARD, canSprint ? motionX * 1.3f : motionX, canSprint ? motionZ * 1.3f : motionZ),
+                new MovementOption(Input.MOVE_BACK, -motionX, -motionZ),
+                new MovementOption(Input.MOVE_LEFT, -motionZ, motionX),
+                new MovementOption(Input.MOVE_RIGHT, motionZ, -motionX),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_LEFT, (canSprint ? motionX * 1.3f : motionX) - motionZ, (canSprint ? motionZ * 1.3f : motionZ) + motionX),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? motionX * 1.3f : motionX) + motionZ, (canSprint ? motionZ * 1.3f : motionZ) - motionX),
+                new MovementOption(Input.MOVE_BACK, Input.MOVE_LEFT, -motionX - motionZ, -motionZ + motionX),
+                new MovementOption(Input.MOVE_BACK, Input.MOVE_RIGHT, -motionX + motionZ, -motionZ - motionX)
+        );
+    }
 }
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index 1e2dc8457..e1d7571d8 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -356,6 +356,7 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
+            MovementHelper.roundYaw(ctx, state);
             MovementHelper.moveTowardsWithoutRotation(ctx, state, dest);
             return state;
         }

From 61c0a097bb62ab246fc9b237f6de8a710cf89e39 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Thu, 28 Aug 2025 08:22:17 -0400
Subject: [PATCH 17/22] Add 45 degree intervals to yaw change.

---
 src/api/java/baritone/api/utils/Rotation.java | 20 +++++++++
 .../pathing/movement/MovementHelper.java      | 41 +++++++++++++++----
 .../movement/movements/MovementTraverse.java  |  3 +-
 3 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/src/api/java/baritone/api/utils/Rotation.java b/src/api/java/baritone/api/utils/Rotation.java
index c75a9a559..2ae67e7ae 100644
--- a/src/api/java/baritone/api/utils/Rotation.java
+++ b/src/api/java/baritone/api/utils/Rotation.java
@@ -159,6 +159,26 @@ public static float normalizeYaw(float yaw) {
         return newYaw;
     }
 
+    /**
+     * Gets the distance between a starting yaw and an offset yaw.
+     * Distance can be negative if the offset yaw is left of the starting yaw.
+     *
+     * @param yaw The initial yaw
+     * @param offsetYaw The offset yaw
+     * @return The distance between the yaws
+     */
+    public static float yawDistanceFromOffset(float yaw, float offsetYaw) {
+        if ((yaw > 0 ^ offsetYaw > 0) && ((yaw > 90 || yaw < -90) ^ (offsetYaw > 90 || offsetYaw < -90))) {
+            if (yaw < 0) {
+                return 360 + (yaw - offsetYaw);
+            } else {
+                return 360 - (yaw - offsetYaw);
+            }
+        } else {
+            return yaw - offsetYaw;
+        }
+    }
+
     @Override
     public String toString() {
         return "Yaw: " + yaw + ", Pitch: " + pitch;
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 6e82172c5..08fb2e3d8 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -660,12 +660,7 @@ static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
         )).setInput(Input.MOVE_FORWARD, true);
     }
 
-    static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, BlockPos dest) {
-        float idealYaw = RotationUtils.calcRotationFromVec3d(
-                ctx.playerHead(),
-                VecUtils.getBlockPosCenter(dest),
-                ctx.playerRotations()
-        ).getYaw();
+    static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, float idealYaw) {
         MovementOption.getOptions(
                 Mth.sin(ctx.playerRotations().getYaw() * DEG_TO_RAD_F),
                 Mth.cos(ctx.playerRotations().getYaw() * DEG_TO_RAD_F),
@@ -676,9 +671,39 @@ static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state,
         ))).ifPresent(selection -> selection.setInputs(state));
     }
 
-    static void roundYaw(IPlayerContext ctx, MovementState state) {
+    static void moveTowardsWithoutRotation(IPlayerContext ctx, MovementState state, BlockPos dest) {
+        float idealYaw = RotationUtils.calcRotationFromVec3d(
+                ctx.playerHead(),
+                VecUtils.getBlockPosCenter(dest),
+                ctx.playerRotations()
+        ).getYaw();
+        moveTowardsWithoutRotation(ctx, state, idealYaw);
+    }
+
+    static void moveTowardsWithSlightRotation(IPlayerContext ctx, MovementState state, BlockPos dest) {
+        float idealYaw = RotationUtils.calcRotationFromVec3d(
+                ctx.playerHead(),
+                VecUtils.getBlockPosCenter(dest),
+                ctx.playerRotations()
+        ).getYaw();
+        moveTowardsWithoutRotation(ctx, state, idealYaw);
+        float distance = Rotation.yawDistanceFromOffset(ctx.playerRotations().getYaw(), idealYaw) % 45f;
+        float newYaw;
+        if (distance > 0) {
+            if (distance > 22.5f) {
+                newYaw = -45f + distance;
+            } else {
+                newYaw = distance;
+            }
+        } else {
+            if (distance < -22.5f) {
+                newYaw = 45f + distance;
+            } else {
+                newYaw = distance;
+            }
+        }
         state.setTarget(new MovementTarget(new Rotation(
-                Math.round(ctx.playerRotations().getYaw() / 45f) * 45f,
+                ctx.playerRotations().getYaw() - newYaw,
                 ctx.playerRotations().getPitch()
         ), true));
     }
diff --git a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
index e1d7571d8..156da1adb 100644
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -356,8 +356,7 @@ public MovementState updateState(MovementState state) {
                 }
                 return state;
             }
-            MovementHelper.roundYaw(ctx, state);
-            MovementHelper.moveTowardsWithoutRotation(ctx, state, dest);
+            MovementHelper.moveTowardsWithSlightRotation(ctx, state, dest);
             return state;
         }
     }

From f9ae7029c3a2d8110fd2780d61d5263f88c3d245 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Thu, 28 Aug 2025 08:57:49 -0400
Subject: [PATCH 18/22] Formatting change.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 08fb2e3d8..2d80d1d9b 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -691,13 +691,13 @@ static void moveTowardsWithSlightRotation(IPlayerContext ctx, MovementState stat
         float newYaw;
         if (distance > 0) {
             if (distance > 22.5f) {
-                newYaw = -45f + distance;
+                newYaw = distance - 45f;
             } else {
                 newYaw = distance;
             }
         } else {
             if (distance < -22.5f) {
-                newYaw = 45f + distance;
+                newYaw = distance + 45f;
             } else {
                 newYaw = distance;
             }

From ce81d364797c90dcacf0726874fe053b1c0a7b2a Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Thu, 28 Aug 2025 21:44:05 -0400
Subject: [PATCH 19/22] Convert to ternary operators.

---
 .../pathing/movement/MovementHelper.java        | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index 2d80d1d9b..ad4f29cbf 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -688,20 +688,9 @@ static void moveTowardsWithSlightRotation(IPlayerContext ctx, MovementState stat
         ).getYaw();
         moveTowardsWithoutRotation(ctx, state, idealYaw);
         float distance = Rotation.yawDistanceFromOffset(ctx.playerRotations().getYaw(), idealYaw) % 45f;
-        float newYaw;
-        if (distance > 0) {
-            if (distance > 22.5f) {
-                newYaw = distance - 45f;
-            } else {
-                newYaw = distance;
-            }
-        } else {
-            if (distance < -22.5f) {
-                newYaw = distance + 45f;
-            } else {
-                newYaw = distance;
-            }
-        }
+        float newYaw = distance > 0f ?
+                distance > 22.5f ? distance - 45f : distance :
+                distance < -22.5f ? distance + 45f : distance;
         state.setTarget(new MovementTarget(new Rotation(
                 ctx.playerRotations().getYaw() - newYaw,
                 ctx.playerRotations().getPitch()

From 037912871c295801d3bb43d96b62ae1cda533bd1 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sat, 30 Aug 2025 08:21:58 -0400
Subject: [PATCH 20/22] Adjust order.

---
 src/main/java/baritone/pathing/movement/MovementHelper.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index ad4f29cbf..e9fce1ce2 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -686,7 +686,6 @@ static void moveTowardsWithSlightRotation(IPlayerContext ctx, MovementState stat
                 VecUtils.getBlockPosCenter(dest),
                 ctx.playerRotations()
         ).getYaw();
-        moveTowardsWithoutRotation(ctx, state, idealYaw);
         float distance = Rotation.yawDistanceFromOffset(ctx.playerRotations().getYaw(), idealYaw) % 45f;
         float newYaw = distance > 0f ?
                 distance > 22.5f ? distance - 45f : distance :
@@ -695,6 +694,7 @@ static void moveTowardsWithSlightRotation(IPlayerContext ctx, MovementState stat
                 ctx.playerRotations().getYaw() - newYaw,
                 ctx.playerRotations().getPitch()
         ), true));
+        moveTowardsWithoutRotation(ctx, state, idealYaw);
     }
 
     /**

From 714e7afce15870790705472f9fce165db99899b1 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Sat, 30 Aug 2025 17:48:19 -0400
Subject: [PATCH 21/22] More minor formatting changes.

---
 .../java/baritone/pathing/movement/MovementHelper.java     | 1 -
 .../java/baritone/pathing/movement/MovementOption.java     | 7 ++++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index e9fce1ce2..c01fd40e6 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -49,7 +49,6 @@
 import net.minecraft.world.level.pathfinder.PathComputationType;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.HitResult;
-import net.minecraft.world.phys.Vec2;
 import net.minecraft.world.phys.Vec3;
 
 import java.util.*;
diff --git a/src/main/java/baritone/pathing/movement/MovementOption.java b/src/main/java/baritone/pathing/movement/MovementOption.java
index 22b8a7e25..27dfcfd5a 100644
--- a/src/main/java/baritone/pathing/movement/MovementOption.java
+++ b/src/main/java/baritone/pathing/movement/MovementOption.java
@@ -23,6 +23,7 @@
 import java.util.stream.Stream;
 
 public record MovementOption(Input input1, Input input2, float motionX, float motionZ) {
+    private static final float SPRINT_MULTIPLIER = 1.3f;
 
     public MovementOption(Input input1, float motionX, float motionZ) {
         this(input1, null, motionX, motionZ);
@@ -43,12 +44,12 @@ public float distanceToSq(float otherX, float otherZ) {
     
     public static Stream<MovementOption> getOptions(float motionX, float motionZ, boolean canSprint) {
         return Stream.of(
-                new MovementOption(Input.MOVE_FORWARD, canSprint ? motionX * 1.3f : motionX, canSprint ? motionZ * 1.3f : motionZ),
+                new MovementOption(Input.MOVE_FORWARD, canSprint ? motionX * SPRINT_MULTIPLIER : motionX, canSprint ? motionZ * SPRINT_MULTIPLIER : motionZ),
                 new MovementOption(Input.MOVE_BACK, -motionX, -motionZ),
                 new MovementOption(Input.MOVE_LEFT, -motionZ, motionX),
                 new MovementOption(Input.MOVE_RIGHT, motionZ, -motionX),
-                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_LEFT, (canSprint ? motionX * 1.3f : motionX) - motionZ, (canSprint ? motionZ * 1.3f : motionZ) + motionX),
-                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? motionX * 1.3f : motionX) + motionZ, (canSprint ? motionZ * 1.3f : motionZ) - motionX),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_LEFT, (canSprint ? motionX * SPRINT_MULTIPLIER : motionX) - motionZ, (canSprint ? motionZ * SPRINT_MULTIPLIER : motionZ) + motionX),
+                new MovementOption(Input.MOVE_FORWARD, Input.MOVE_RIGHT, (canSprint ? motionX * SPRINT_MULTIPLIER : motionX) + motionZ, (canSprint ? motionZ * SPRINT_MULTIPLIER : motionZ) - motionX),
                 new MovementOption(Input.MOVE_BACK, Input.MOVE_LEFT, -motionX - motionZ, -motionZ + motionX),
                 new MovementOption(Input.MOVE_BACK, Input.MOVE_RIGHT, -motionX + motionZ, -motionZ - motionX)
         );

From a56f3cfd86f7fe858e83eeffd915ba2a6d92e095 Mon Sep 17 00:00:00 2001
From: Murat65536 <bob65536@proton.me>
Date: Wed, 10 Sep 2025 21:06:26 -0400
Subject: [PATCH 22/22] Clarify yaw distance comment

---
 src/api/java/baritone/api/utils/Rotation.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/api/java/baritone/api/utils/Rotation.java b/src/api/java/baritone/api/utils/Rotation.java
index 2ae67e7ae..a45cc32dc 100644
--- a/src/api/java/baritone/api/utils/Rotation.java
+++ b/src/api/java/baritone/api/utils/Rotation.java
@@ -161,7 +161,7 @@ public static float normalizeYaw(float yaw) {
 
     /**
      * Gets the distance between a starting yaw and an offset yaw.
-     * Distance can be negative if the offset yaw is left of the starting yaw.
+     * Distance can be negative if the offset yaw is behind of the starting yaw.
      *
      * @param yaw The initial yaw
      * @param offsetYaw The offset yaw