All around minor cleanups to movement classes

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

@@ -33,6 +33,7 @@ import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Optional;
 
 import static baritone.utils.InputOverrideHandler.Input;
@@ -268,15 +269,15 @@ public abstract class Movement implements Helper, MovementHelper {
         return state;
     }
 
-    public ArrayList<BlockPos> toBreakCached = null;
+    public List<BlockPos> toBreakCached = null;
-    public ArrayList<BlockPos> toPlaceCached = null;
+    public List<BlockPos> toPlaceCached = null;
-    public ArrayList<BlockPos> toWalkIntoCached = null;
+    public List<BlockPos> toWalkIntoCached = null;
 
-    public ArrayList<BlockPos> toBreak() {
+    public List<BlockPos> toBreak() {
         if (toBreakCached != null) {
             return toBreakCached;
         }
-        ArrayList<BlockPos> result = new ArrayList<>();
+        List<BlockPos> result = new ArrayList<>();
         for (BlockPos positionToBreak : positionsToBreak) {
             if (!MovementHelper.canWalkThrough(positionToBreak)) {
                 result.add(positionToBreak);
@@ -286,11 +287,11 @@ public abstract class Movement implements Helper, MovementHelper {
         return result;
     }
 
-    public ArrayList<BlockPos> toPlace() {
+    public List<BlockPos> toPlace() {
         if (toPlaceCached != null) {
             return toPlaceCached;
         }
-        ArrayList<BlockPos> result = new ArrayList<>();
+        List<BlockPos> result = new ArrayList<>();
         for (BlockPos positionToBreak : positionsToPlace) {
             if (!MovementHelper.canWalkOn(positionToBreak)) {
                 result.add(positionToBreak);
@@ -300,7 +301,7 @@ public abstract class Movement implements Helper, MovementHelper {
         return result;
     }
 
-    public ArrayList<BlockPos> toWalkInto() { // overridden by movementdiagonal
+    public List<BlockPos> toWalkInto() { // overridden by movementdiagonal
         if (toWalkIntoCached == null) {
             toWalkIntoCached = new ArrayList<>();
         }

src/main/java/baritone/pathing/movement/movements/MovementAscend.java

@@ -130,9 +130,9 @@ public class MovementAscend extends Movement {
             default:
                 return state;
         }
+
         if (playerFeet().equals(dest)) {
-            state.setStatus(MovementStatus.SUCCESS);
+            return state.setStatus(MovementStatus.SUCCESS);
-            return state;
         }
 
         if (!MovementHelper.canWalkOn(positionsToPlace[0])) {
@@ -146,17 +146,21 @@ public class MovementAscend extends Movement {
                     double faceZ = (dest.getZ() + anAgainst.getZ() + 1.0D) * 0.5D;
                     state.setTarget(new MovementState.MovementTarget(Utils.calcRotationFromVec3d(playerHead(), new Vec3d(faceX, faceY, faceZ), playerRotations()), true));
                     EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit;
-                    if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), anAgainst) && LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionsToPlace[0])) {
+
+                    LookBehaviorUtils.getSelectedBlock().ifPresent(selectedBlock -> {
+                        if (Objects.equals(selectedBlock, anAgainst) && selectedBlock.offset(side).equals(positionsToPlace[0])) {
                             ticksWithoutPlacement++;
                             state.setInput(InputOverrideHandler.Input.SNEAK, true);
                             if (player().isSneaking()) {
                                 state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
                             }
                             if (ticksWithoutPlacement > 20) {
-                            state.setInput(InputOverrideHandler.Input.MOVE_BACK, true);//we might be standing in the way, move back
+                                // After 20 ticks without placement, we might be standing in the way, move back
+                                state.setInput(InputOverrideHandler.Input.MOVE_BACK, true);
                             }
                         }
-                    System.out.println("Trying to look at " + anAgainst + ", actually looking at" + LookBehaviorUtils.getSelectedBlock());
+                        System.out.println("Trying to look at " + anAgainst + ", actually looking at" + selectedBlock);
+                    });
                     return state;
                 }
             }
@@ -165,28 +169,22 @@ public class MovementAscend extends Movement {
         MovementHelper.moveTowards(state, dest);
 
         if (headBonkClear()) {
-            state.setInput(InputOverrideHandler.Input.JUMP, true);
+            return state.setInput(InputOverrideHandler.Input.JUMP, true);
-            return state;
         }
 
         int xAxis = Math.abs(src.getX() - dest.getX()); // either 0 or 1
         int zAxis = Math.abs(src.getZ() - dest.getZ()); // either 0 or 1
         double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ);
-
         double sideDist = zAxis * Math.abs((dest.getX() + 0.5D) - player().posX) + xAxis * Math.abs((dest.getZ() + 0.5D) - player().posZ);
         // System.out.println(flatDistToNext + " " + sideDist);
-        if (flatDistToNext > 1.2) {
+        if (flatDistToNext > 1.2 || sideDist > 0.2) {
             return state;
         }
 
-        if (sideDist > 0.2) {
+        // Once we are pointing the right way and moving, start jumping
-            return state;
+        // This is slightly more efficient because otherwise we might start jumping before moving, and fall down without moving onto the block we want to jump onto
-        }
+        // Also wait until we are close enough, because we might jump and hit our head on an adjacent block
-        //once we are pointing the right way and moving, start jumping
+        return state.setInput(InputOverrideHandler.Input.JUMP, true);
-        //this is slightly more efficient because otherwise we might start jumping before moving, and fall down without moving onto the block we want to jump onto
-        //also wait until we are close enough, because we might jump and hit our head on an adjacent block
-        state.setInput(InputOverrideHandler.Input.JUMP, true);
-        return state;
     }
 
     private boolean headBonkClear() {
@@ -194,7 +192,7 @@ public class MovementAscend extends Movement {
         for (int i = 0; i < 4; i++) {
             BlockPos check = startUp.offset(EnumFacing.byHorizontalIndex(i));
             if (!MovementHelper.canWalkThrough(check)) {
-                // we might bonk our head
+                // We might bonk our head
                 return false;
             }
         }

src/main/java/baritone/pathing/movement/movements/MovementDescend.java

@@ -73,6 +73,7 @@ public class MovementDescend extends Movement {
             default:
                 return state;
         }
+
         BlockPos playerFeet = playerFeet();
         if (playerFeet.equals(dest)) {
             if (BlockStateInterface.isLiquid(dest) || player().posY - playerFeet.getY() < 0.094) { // lilypads
@@ -91,9 +92,6 @@ public class MovementDescend extends Movement {
         double fromStart = Math.sqrt(x * x + z * z);
         if (!playerFeet.equals(dest) || ab > 0.25) {
             BlockPos fakeDest = new BlockPos(dest.getX() * 2 - src.getX(), dest.getY(), dest.getZ() * 2 - src.getZ());
-            double diffX2 = player().posX - (fakeDest.getX() + 0.5);
-            double diffZ2 = player().posZ - (fakeDest.getZ() + 0.5);
-            double d = Math.sqrt(diffX2 * diffX2 + diffZ2 * diffZ2);
             if (numTicks++ < 20) {
                 MovementHelper.moveTowards(state, fakeDest);
                 if (fromStart > 1.25) {

src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java

@@ -30,6 +30,7 @@ import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.ArrayList;
+import java.util.List;
 
 public class MovementDiagonal extends Movement {
 
@@ -59,6 +60,7 @@ public class MovementDiagonal extends Movement {
             default:
                 return state;
         }
+
         if (playerFeet().equals(dest)) {
             state.setStatus(MovementState.MovementStatus.SUCCESS);
             return state;
@@ -81,7 +83,7 @@ public class MovementDiagonal extends Movement {
         }
         double multiplier = WALK_ONE_BLOCK_COST;
 
-        // for either possible soul sand, that affects half of our walking
+        // For either possible soul sand, that affects half of our walking
         if (destWalkOn.getBlock().equals(Blocks.SOUL_SAND)) {
             multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
         }
@@ -117,17 +119,17 @@ public class MovementDiagonal extends Movement {
             }
         }
         if (BlockStateInterface.isWater(src) || BlockStateInterface.isWater(dest)) {
-            // ignore previous multiplier
+            // Ignore previous multiplier
-            // whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water
+            // Whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water
-            // not even touching the blocks below
+            // Not even touching the blocks below
             multiplier = WALK_ONE_IN_WATER_COST;
         }
         if (optionA != 0 || optionB != 0) {
             multiplier *= SQRT_2 - 0.001; // TODO tune
         }
         if (multiplier == WALK_ONE_BLOCK_COST && context.canSprint()) {
-            // if we aren't edging around anything, and we aren't in water or soul sand
+            // If we aren't edging around anything, and we aren't in water or soul sand
-            // we can sprint =D
+            // We can sprint =D
             multiplier = SPRINT_ONE_BLOCK_COST;
         }
         return multiplier * SQRT_2;
@@ -139,7 +141,7 @@ public class MovementDiagonal extends Movement {
     }
 
     @Override
-    public ArrayList<BlockPos> toBreak() {
+    public List<BlockPos> toBreak() {
         if (toBreakCached != null) {
             return toBreakCached;
         }
@@ -154,11 +156,11 @@ public class MovementDiagonal extends Movement {
     }
 
     @Override
-    public ArrayList<BlockPos> toWalkInto() {
+    public List<BlockPos> toWalkInto() {
         if (toWalkIntoCached == null) {
             toWalkIntoCached = new ArrayList<>();
         }
-        ArrayList<BlockPos> result = new ArrayList<>();
+        List<BlockPos> result = new ArrayList<>();
         for (int i = 0; i < 4; i++) {
             if (!MovementHelper.canWalkThrough(positionsToBreak[i])) {
                 result.add(positionsToBreak[i]);

src/main/java/baritone/pathing/movement/movements/MovementDownward.java

@@ -68,6 +68,7 @@ public class MovementDownward extends Movement {
             default:
                 return state;
         }
+
         if (playerFeet().equals(dest)) {
             state.setStatus(MovementState.MovementStatus.SUCCESS);
             return state;

src/main/java/baritone/pathing/movement/movements/MovementFall.java

@@ -67,10 +67,10 @@ public class MovementFall extends Movement {
         }
         for (int i = 2; i < positionsToBreak.length; i++) {
             // TODO is this the right check here?
-            // miningDurationTicks is all right, but shouldn't it be canWalkThrough instead?
+            // MiningDurationTicks is all right, but shouldn't it be canWalkThrough instead?
-            // lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage
+            // Lilypads (i think?) are 0 ticks to mine, but they definitely cause fall damage
-            // same thing for falling through water... we can't actually do that
+            // Same thing for falling through water... we can't actually do that
-            // and falling through signs is possible, but they do have a mining duration, right?
+            // And falling through signs is possible, but they do have a mining duration, right?
             if (MovementHelper.getMiningDurationTicks(context, positionsToBreak[i]) > 0) {
                 //can't break while falling
                 return COST_INF;
@@ -90,6 +90,7 @@ public class MovementFall extends Movement {
             default:
                 return state;
         }
+
         BlockPos playerFeet = playerFeet();
         Optional<Rotation> targetRotation = Optional.empty();
         if (!BlockStateInterface.isWater(dest) && src.getY() - dest.getY() > Baritone.settings().maxFallHeightNoWater.get() && !playerFeet.equals(dest)) {

src/main/java/baritone/pathing/movement/movements/MovementPillar.java

@@ -115,6 +115,7 @@ public class MovementPillar extends Movement {
             default:
                 return state;
         }
+
         IBlockState fromDown = BlockStateInterface.get(src);
         boolean ladder = fromDown.getBlock() instanceof BlockLadder || fromDown.getBlock() instanceof BlockVine;
         boolean vine = fromDown.getBlock() instanceof BlockVine;
@@ -123,57 +124,68 @@ public class MovementPillar extends Movement {
                     Utils.getBlockPosCenter(positionsToPlace[0]),
                     new Rotation(mc.player.rotationYaw, mc.player.rotationPitch)), true));
         }
-        EntityPlayerSP thePlayer = Minecraft.getMinecraft().player;
+
         boolean blockIsThere = MovementHelper.canWalkOn(src) || ladder;
         if (ladder) {
             BlockPos against = vine ? getAgainst(src) : src.offset(fromDown.getValue(BlockLadder.FACING).getOpposite());
             if (against == null) {
                 displayChatMessageRaw("Unable to climb vines");
-                state.setStatus(MovementState.MovementStatus.UNREACHABLE);
+                return state.setStatus(MovementState.MovementStatus.UNREACHABLE);
-                return state;
             }
-            if (playerFeet().equals(against.up()) || playerFeet().equals(dest)) {
+
-                state.setStatus(MovementState.MovementStatus.SUCCESS);
+            if (playerFeet().equals(against.up()) || playerFeet().equals(dest))
-                return state;
+                return state.setStatus(MovementState.MovementStatus.SUCCESS);
-            }
+
-            /*if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) {
+            /*
+            if (thePlayer.getPosition0().getX() != from.getX() || thePlayer.getPosition0().getZ() != from.getZ()) {
                 Baritone.moveTowardsBlock(from);
-             }*/
+            }
+             */
+
             MovementHelper.moveTowards(state, against);
             return state;
         } else {
-            if (!MovementHelper.throwaway(true)) {//get ready to place a throwaway block
+            // Get ready to place a throwaway block
+            if (!MovementHelper.throwaway(true)) {
                 state.setStatus(MovementState.MovementStatus.UNREACHABLE);
                 return state;
             }
+
             numTicks++;
-            state.setInput(InputOverrideHandler.Input.JUMP, thePlayer.posY < dest.getY()); //if our Y coordinate is above our goal, stop jumping
+            // If our Y coordinate is above our goal, stop jumping
+            state.setInput(InputOverrideHandler.Input.JUMP, player().posY < dest.getY());
             state.setInput(InputOverrideHandler.Input.SNEAK, true);
-            //otherwise jump
+
+            // Otherwise jump
             if (numTicks > 40) {
-                double diffX = thePlayer.posX - (dest.getX() + 0.5);
+                double diffX = player().posX - (dest.getX() + 0.5);
-                double diffZ = thePlayer.posZ - (dest.getZ() + 0.5);
+                double diffZ = player().posZ - (dest.getZ() + 0.5);
                 double dist = Math.sqrt(diffX * diffX + diffZ * diffZ);
                 if (dist > 0.17) {//why 0.17? because it seemed like a good number, that's why
                     //[explanation added after baritone port lol] also because it needs to be less than 0.2 because of the 0.3 sneak limit
                     //and 0.17 is reasonably less than 0.2
-                    state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, true);//if it's been more than forty ticks of trying to jump and we aren't done yet, go forward, maybe we are stuck
+
+                    // If it's been more than forty ticks of trying to jump and we aren't done yet, go forward, maybe we are stuck
+                    state.setInput(InputOverrideHandler.Input.MOVE_FORWARD, true);
                 }
             }
+
             if (!blockIsThere) {
                 Block fr = BlockStateInterface.get(src).getBlock();
                 if (!(fr instanceof BlockAir || fr.isReplaceable(Minecraft.getMinecraft().world, src))) {
                     state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true);
                     blockIsThere = false;
                 } else if (Minecraft.getMinecraft().player.isSneaking()) {
-                    state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);//constantly right click
+                    state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
                 }
             }
         }
-        if (playerFeet().equals(dest) && blockIsThere) {//if we are at our goal and the block below us is placed
+
-            state.setStatus(MovementState.MovementStatus.SUCCESS);
+        // If we are at our goal and the block below us is placed
-            return state;//we are done
+        if (playerFeet().equals(dest) && blockIsThere) {
+            return state.setStatus(MovementState.MovementStatus.SUCCESS);
         }
+
         return state;
     }
 }

src/main/java/baritone/pathing/movement/movements/MovementTraverse.java

@@ -92,8 +92,8 @@ public class MovementTraverse extends Movement {
             }
             if (MovementHelper.canWalkThrough(positionsToBreak[0], pb0) && MovementHelper.canWalkThrough(positionsToBreak[1], pb1)) {
                 if (WC == WALK_ONE_BLOCK_COST && context.canSprint()) {
-                    // if there's nothing in the way, and this isn't water or soul sand, and we aren't sneak placing
+                    // If there's nothing in the way, and this isn't water or soul sand, and we aren't sneak placing
-                    // we can sprint =D
+                    // We can sprint =D
                     WC = SPRINT_ONE_BLOCK_COST;
                 }
                 return WC;
@@ -140,6 +140,7 @@ public class MovementTraverse extends Movement {
             default:
                 return state;
         }
+
         Block fd = BlockStateInterface.get(src.down()).getBlock();
         boolean ladder = fd instanceof BlockLadder || fd instanceof BlockVine;
         IBlockState pb0 = BlockStateInterface.get(positionsToBreak[0]);
@@ -161,6 +162,7 @@ public class MovementTraverse extends Movement {
                 }
             }
         }
+
         boolean isTheBridgeBlockThere = MovementHelper.canWalkOn(positionsToPlace[0]) || ladder;
         BlockPos whereAmI = playerFeet();
         if (whereAmI.getY() != dest.getY() && !ladder) {
@@ -170,6 +172,7 @@ public class MovementTraverse extends Movement {
             }
             return state;
         }
+
         if (isTheBridgeBlockThere) {
             if (playerFeet().equals(dest)) {
                 state.setStatus(MovementState.MovementStatus.SUCCESS);
@@ -202,20 +205,18 @@ public class MovementTraverse extends Movement {
                     EnumFacing side = Minecraft.getMinecraft().objectMouseOver.sideHit;
                     if (Objects.equals(LookBehaviorUtils.getSelectedBlock().orElse(null), against1) && Minecraft.getMinecraft().player.isSneaking()) {
                         if (LookBehaviorUtils.getSelectedBlock().get().offset(side).equals(positionsToPlace[0])) {
-                            state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
+                            return state.setInput(InputOverrideHandler.Input.CLICK_RIGHT, true);
-                            return state;
                         } else {
                             // Out.gui("Wrong. " + side + " " + LookBehaviorUtils.getSelectedBlock().get().offset(side) + " " + positionsToPlace[0], Out.Mode.Debug);
                         }
                     }
-                    state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true);
                     System.out.println("Trying to look at " + against1 + ", actually looking at" + LookBehaviorUtils.getSelectedBlock());
-                    return state;
+                    return state.setInput(InputOverrideHandler.Input.CLICK_LEFT, true);
                 }
             }
             state.setInput(InputOverrideHandler.Input.SNEAK, true);
             if (whereAmI.equals(dest)) {
-                // if we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of
+                // If we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of
                 // Out.log(from + " " + to + " " + faceX + "," + faceY + "," + faceZ + " " + whereAmI);
                 if (!MovementHelper.throwaway(true)) {// get ready to place a throwaway block
                     displayChatMessageRaw("bb pls get me some blocks. dirt or cobble");