Clean up BaritoneResourcePack

README.md

@@ -25,6 +25,8 @@ Here are some links to help to get started:
 
 - [Installation](INSTALL.md)
 
+There's also some useful information down below
+
 # Setup
 
 ## Command Line

buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java

@@ -208,7 +208,7 @@ public class ProguardTask extends BaritoneGradleTask {
         Objects.requireNonNull(extension);
 
         // for some reason cant use Class.forName
-        Class<?> class_baseExtension = extension.getClass().getSuperclass().getSuperclass().getSuperclass(); // <-- cursed
+        Class<?> class_baseExtension = extension.getClass().getSuperclass().getSuperclass().getSuperclass();
         Field f_replacer = class_baseExtension.getDeclaredField("replacer");
         f_replacer.setAccessible(true);
         Object replacer = f_replacer.get(extension);

buildSrc/src/main/java/baritone/gradle/util/MappingType.java

@@ -26,4 +26,4 @@ public enum MappingType {
     SEARGE,
     NOTCH,
     CUSTOM // forgegradle
-}
+}

buildSrc/src/main/java/baritone/gradle/util/ReobfWrapper.java

@@ -60,4 +60,4 @@ public class ReobfWrapper {
             throw new IllegalStateException(ex);
         }
     }
-}
+}

src/api/java/baritone/api/IBaritone.java

@@ -21,7 +21,6 @@ import baritone.api.behavior.ILookBehavior;
 import baritone.api.behavior.IPathingBehavior;
 import baritone.api.cache.IWorldProvider;
 import baritone.api.event.listener.IEventBus;
-import baritone.api.pathing.calc.IPathingControlManager;
 import baritone.api.process.ICustomGoalProcess;
 import baritone.api.process.IFollowProcess;
 import baritone.api.process.IGetToBlockProcess;
@@ -65,8 +64,6 @@ public interface IBaritone {
      */
     IWorldProvider getWorldProvider();
 
-    IPathingControlManager getPathingControlManager();
-
     IInputOverrideHandler getInputOverrideHandler();
 
     ICustomGoalProcess getCustomGoalProcess();

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

@@ -68,16 +68,6 @@ public class Settings {
      */
     public Setting<Double> blockBreakAdditionalPenalty = new Setting<>(2D);
 
-    /**
-     * Additional penalty for hitting the space bar (ascend, pillar, or parkour) beacuse it uses hunger
-     */
-    public Setting<Double> jumpPenalty = new Setting<>(2D);
-
-    /**
-     * Walking on water uses up hunger really quick, so penalize it
-     */
-    public Setting<Double> walkOnWaterOnePenalty = new Setting<>(5D);
-
     /**
      * Allow Baritone to fall arbitrary distances and place a water bucket beneath it.
      * Reliability: questionable.
@@ -111,15 +101,6 @@ public class Settings {
      */
     public Setting<Boolean> allowJumpAt256 = new Setting<>(false);
 
-    /**
-     * Allow descending diagonally
-     * <p>
-     * Safer than allowParkour yet still slightly unsafe, can make contact with unchecked adjacent blocks, so it's unsafe in the nether.
-     * <p>
-     * For a generic "take some risks" mode I'd turn on this one, parkour, and parkour place.
-     */
-    public Setting<Boolean> allowDiagonalDescend = new Setting<>(false);
-
     /**
      * Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)
      */
@@ -172,8 +153,10 @@ public class Settings {
      * metric gets better and better with each block, instead of slightly worse.
      * <p>
      * Finding the optimal path is worth it, so it's the default.
+     * <p>
+     * This value is an expression instead of a literal so that it's exactly equal to SPRINT_ONE_BLOCK_COST defined in ActionCosts.java
      */
-    public Setting<Double> costHeuristic = new Setting<>(3.563);
+    public Setting<Double> costHeuristic = new Setting<>(20 / 5.612);
 
     // a bunch of obscure internal A* settings that you probably don't want to change
     /**
@@ -452,6 +435,10 @@ public class Settings {
 
     /**
      * {@code true}: can mine blocks when in inventory, chat, or tabbed away in ESC menu
+     * <p>
+     * {@code false}: works on cosmic prisons
+     * <p>
+     * LOL
      */
     public Setting<Boolean> leftClickWorkaround = new Setting<>(true);
 

src/api/java/baritone/api/event/listener/AbstractGameEventListener.java

@@ -36,6 +36,9 @@ public interface AbstractGameEventListener extends IGameEventListener {
     @Override
     default void onPlayerUpdate(PlayerUpdateEvent event) {}
 
+    @Override
+    default void onProcessKeyBinds() {}
+
     @Override
     default void onSendChatMessage(ChatEvent event) {}
 

src/api/java/baritone/api/event/listener/IGameEventListener.java

@@ -49,6 +49,11 @@ public interface IGameEventListener {
      */
     void onPlayerUpdate(PlayerUpdateEvent event);
 
+    /**
+     * Run once per game tick from before keybinds are processed.
+     */
+    void onProcessKeyBinds();
+
     /**
      * Runs whenever the client player sends a message to the server.
      *

src/api/java/baritone/api/pathing/calc/IPathFinder.java

@@ -36,6 +36,7 @@ public interface IPathFinder {
      *
      * @param primaryTimeout If a path is found, the path finder will stop after this amount of time
      * @param failureTimeout If a path isn't found, the path finder will continue for this amount of time
+     *
      * @return The final path
      */
     PathCalculationResult calculate(long primaryTimeout, long failureTimeout);

src/api/java/baritone/api/pathing/goals/Goal.java

@@ -33,6 +33,7 @@ public interface Goal {
      * @param x The goal X position
      * @param y The goal Y position
      * @param z The goal Z position
+     *
      * @return Whether or not it satisfies this goal
      */
     boolean isInGoal(int x, int y, int z);
@@ -43,6 +44,7 @@ public interface Goal {
      * @param x The goal X position
      * @param y The goal Y position
      * @param z The goal Z position
+     *
      * @return The estimate number of ticks to satisfy the goal
      */
     double heuristic(int x, int y, int z);

src/api/java/baritone/api/utils/BetterBlockPos.java

@@ -35,15 +35,6 @@ public final class BetterBlockPos extends BlockPos {
     public final int x;
     public final int y;
     public final int z;
-    public static long numCreated;
-
-    static {
-        numCreated = 0;
-    }
-
-    {
-        numCreated++;
-    }
 
     public BetterBlockPos(int x, int y, int z) {
         super(x, y, z);

src/api/java/baritone/api/utils/IInputOverrideHandler.java

@@ -27,7 +27,9 @@ import net.minecraft.client.settings.KeyBinding;
  */
 public interface IInputOverrideHandler extends IBehavior {
 
-    Boolean isInputForcedDown(KeyBinding key);
+    default boolean isInputForcedDown(KeyBinding key) {
+        return isInputForcedDown(Input.getInputForBind(key));
+    }
 
     boolean isInputForcedDown(Input input);
 

src/api/java/baritone/api/utils/IPlayerContext.java

@@ -20,6 +20,7 @@ package baritone.api.utils;
 import baritone.api.cache.IWorldData;
 import net.minecraft.block.BlockSlab;
 import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
@@ -36,7 +37,7 @@ public interface IPlayerContext {
 
     EntityPlayerSP player();
 
-    IPlayerController playerController();
+    PlayerControllerMP playerController();
 
     World world();
 

src/api/java/baritone/api/utils/Logger.java

@@ -17,30 +17,11 @@
 
 package baritone.api.utils;
 
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.ClickType;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.GameType;
-
 /**
  * @author Brady
- * @since 12/14/2018
+ * @since 9/23/2018
  */
-public interface IPlayerController {
+public class Logger {
 
-    boolean onPlayerDamageBlock(BlockPos pos, EnumFacing side);
 
-    void resetBlockRemoving();
-
-    ItemStack windowClick(int windowId, int slotId, int mouseButton, ClickType type, EntityPlayer player);
-
-    void setGameType(GameType type);
-
-    GameType getGameType();
-
-    default double getBlockReachDistance() {
-        return this.getGameType().isCreative() ? 5.0F : 4.5F;
-    }
 }

src/api/java/baritone/api/utils/PathCalculationResult.java

@@ -19,7 +19,6 @@ package baritone.api.utils;
 
 import baritone.api.pathing.calc.IPath;
 
-import java.util.Objects;
 import java.util.Optional;
 
 public class PathCalculationResult {
@@ -32,9 +31,11 @@ public class PathCalculationResult {
     }
 
     public PathCalculationResult(Type type, IPath path) {
-        Objects.requireNonNull(type);
         this.path = path;
         this.type = type;
+        if (type == null) {
+            throw new IllegalArgumentException("come on");
+        }
     }
 
     public final Optional<IPath> getPath() {

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

@@ -127,16 +127,6 @@ public final class RotationUtils {
         return new Vec3d((double) (f1 * f2), (double) f3, (double) (f * f2));
     }
 
-    /**
-     * @param ctx Context for the viewing entity
-     * @param pos The target block position
-     * @return The optional rotation
-     * @see #reachable(EntityPlayerSP, BlockPos, double)
-     */
-    public static Optional<Rotation> reachable(IPlayerContext ctx, BlockPos pos) {
-        return reachable(ctx.player(), pos, ctx.playerController().getBlockReachDistance());
-    }
-
     /**
      * Determines if the specified entity is able to reach the center of any of the sides
      * of the specified block. It first checks if the block center is reachable, and if so,

src/api/java/baritone/api/utils/SettingsUtil.java

@@ -18,77 +18,56 @@
 package baritone.api.utils;
 
 import baritone.api.Settings;
+import net.minecraft.client.Minecraft;
 import net.minecraft.item.Item;
 import net.minecraft.util.ResourceLocation;
 
 import java.awt.*;
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Consumer;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.*;
 import java.util.function.Function;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static net.minecraft.client.Minecraft.getMinecraft;
-
 public class SettingsUtil {
 
-    private static final Path SETTINGS_PATH = getMinecraft().gameDir.toPath().resolve("baritone").resolve("settings.txt");
-    private static final Pattern SETTING_PATTERN = Pattern.compile("^(?<setting>[^ ]+) +(?<value>[^ ]+)"); // 2 words separated by spaces
+    private static final File settingsFile = new File(new File(Minecraft.getMinecraft().gameDir, "baritone"), "settings.txt");
 
     private static final Map<Class<?>, SettingsIO> map;
 
-    private static boolean isComment(String line) {
-        return line.startsWith("#") || line.startsWith("//");
-    }
-
-    private static void forEachLine(Path file, Consumer<String> consumer) throws IOException {
-        try (BufferedReader scan = Files.newBufferedReader(file)) {
-            String line;
-            while ((line = scan.readLine()) != null) {
-                if (line.isEmpty() || isComment(line)) {
+    public static void readAndApply(Settings settings) {
+        try (Scanner scan = new Scanner(settingsFile)) {
+            while (scan.hasNextLine()) {
+                String line = scan.nextLine();
+                if (line.isEmpty()) {
                     continue;
                 }
-                consumer.accept(line);
-            }
-        }
-    }
-
-    public static void readAndApply(Settings settings) {
-        try {
-            forEachLine(SETTINGS_PATH, line -> {
-                Matcher matcher = SETTING_PATTERN.matcher(line);
-                if (!matcher.matches()) {
-                    System.out.println("Invalid syntax in setting file: " + line);
-                    return;
+                if (line.startsWith("#") || line.startsWith("//")) {
+                    continue;
                 }
-
-                String settingName = matcher.group("setting").toLowerCase();
-                String settingValue = matcher.group("value");
+                int space = line.indexOf(" ");
+                if (space == -1) {
+                    System.out.println("Skipping invalid line with no space: " + line);
+                    continue;
+                }
+                String settingName = line.substring(0, space).trim().toLowerCase();
+                String settingValue = line.substring(space).trim();
                 try {
                     parseAndApply(settings, settingName, settingValue);
                 } catch (Exception ex) {
-                    System.out.println("Unable to parse line " + line);
                     ex.printStackTrace();
+                    System.out.println("Unable to parse line " + line);
                 }
-            });
+            }
         } catch (Exception ex) {
-            System.out.println("Exception while reading Baritone settings, some settings may be reset to default values!");
             ex.printStackTrace();
+            System.out.println("Exception while reading Baritone settings, some settings may be reset to default values!");
         }
     }
 
     public static synchronized void save(Settings settings) {
-        try (BufferedWriter out = Files.newBufferedWriter(SETTINGS_PATH)) {
+        try (FileOutputStream out = new FileOutputStream(settingsFile)) {
             for (Settings.Setting setting : settings.allSettings) {
                 if (setting.get() == null) {
                     System.out.println("NULL SETTING?" + setting.getName());
@@ -104,11 +83,11 @@ public class SettingsUtil {
                 if (io == null) {
                     throw new IllegalStateException("Missing " + setting.getValueClass() + " " + setting + " " + setting.getName());
                 }
-                out.write(setting.getName() + " " + io.toString.apply(setting.get()) + "\n");
+                out.write((setting.getName() + " " + io.toString.apply(setting.get()) + "\n").getBytes());
             }
         } catch (Exception ex) {
-            System.out.println("Exception thrown while saving Baritone settings!");
             ex.printStackTrace();
+            System.out.println("Exception while saving Baritone settings!");
         }
     }
 

src/launch/java/baritone/launch/mixins/MixinKeyBinding.java

@@ -18,10 +18,8 @@
 package baritone.launch.mixins;
 
 import baritone.api.BaritoneAPI;
-import baritone.utils.Helper;
 import net.minecraft.client.settings.KeyBinding;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@@ -33,9 +31,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 @Mixin(KeyBinding.class)
 public class MixinKeyBinding {
 
-    @Shadow
-    public int pressTime;
-
     @Inject(
             method = "isKeyDown",
             at = @At("HEAD"),
@@ -43,26 +38,8 @@ public class MixinKeyBinding {
     )
     private void isKeyDown(CallbackInfoReturnable<Boolean> cir) {
         // only the primary baritone forces keys
-        Boolean force = BaritoneAPI.getProvider().getPrimaryBaritone().getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this);
-        if (force != null) {
-            cir.setReturnValue(force); // :sunglasses:
-        }
-    }
-
-    @Inject(
-            method = "isPressed",
-            at = @At("HEAD"),
-            cancellable = true
-    )
-    private void isPressed(CallbackInfoReturnable<Boolean> cir) {
-        // only the primary baritone forces keys
-        Boolean force = BaritoneAPI.getProvider().getPrimaryBaritone().getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this);
-        if (force != null && force == false) { // <-- cursed
-            if (pressTime > 0) {
-                Helper.HELPER.logDirect("You're trying to press this mouse button but I won't let you");
-                pressTime--;
-            }
-            cir.setReturnValue(force); // :sunglasses:
+        if (BaritoneAPI.getProvider().getPrimaryBaritone().getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this)) {
+            cir.setReturnValue(true);
         }
     }
 }

src/launch/java/baritone/launch/mixins/MixinMinecraft.java

@@ -25,15 +25,18 @@ import baritone.api.event.events.TickEvent;
 import baritone.api.event.events.WorldEvent;
 import baritone.api.event.events.type.EventState;
 import baritone.utils.BaritoneAutoTest;
+import baritone.utils.resource.BaritoneResourcePack;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.resources.IResourcePack;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumActionResult;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import org.spongepowered.asm.lib.Opcodes;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -42,6 +45,8 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
+import java.util.List;
+
 /**
  * @author Brady
  * @since 7/31/2018
@@ -49,10 +54,9 @@ import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 @Mixin(Minecraft.class)
 public class MixinMinecraft {
 
-    @Shadow
-    public EntityPlayerSP player;
-    @Shadow
-    public WorldClient world;
+    @Shadow public EntityPlayerSP player;
+    @Shadow public WorldClient world;
+    @Shadow @Final private List<IResourcePack> defaultResourcePacks;
 
     @Inject(
             method = "init",
@@ -71,6 +75,7 @@ public class MixinMinecraft {
     )
     private void preInit(CallbackInfo ci) {
         BaritoneAutoTest.INSTANCE.onPreInit();
+        this.defaultResourcePacks.add(new BaritoneResourcePack());
     }
 
     @Inject(
@@ -96,6 +101,15 @@ public class MixinMinecraft {
 
     }
 
+    @Inject(
+            method = "processKeyBinds",
+            at = @At("HEAD")
+    )
+    private void runTickKeyboard(CallbackInfo ci) {
+        // keyboard input is only the primary baritone
+        BaritoneAPI.getProvider().getPrimaryBaritone().getGameEventHandler().onProcessKeyBinds();
+    }
+
     @Inject(
             method = "loadWorld(Lnet/minecraft/client/multiplayer/WorldClient;Ljava/lang/String;)V",
             at = @At("HEAD")

src/main/java/baritone/Baritone.java

@@ -35,6 +35,9 @@ import baritone.utils.InputOverrideHandler;
 import baritone.utils.PathingControlManager;
 import baritone.utils.player.PrimaryPlayerContext;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundEvent;
 
 import java.io.File;
 import java.io.IOException;
@@ -93,11 +96,18 @@ public class Baritone implements IBaritone {
         this.gameEventHandler = new GameEventHandler(this);
     }
 
+    public void fitmc() {
+        SoundEvent event = new SoundEvent(new ResourceLocation("baritone", "fitmc_intro"));
+        Minecraft.getMinecraft().getSoundHandler().playSound(PositionedSoundRecord.getMasterRecord(event, 0.8F + (float) Math.random() * 0.4F));
+    }
+
     public synchronized void init() {
         if (initialized) {
             return;
         }
 
+        fitmc();
+
         // Define this before behaviors try and get it, or else it will be null and the builds will fail!
         this.playerContext = PrimaryPlayerContext.INSTANCE;
 
@@ -129,7 +139,6 @@ public class Baritone implements IBaritone {
         this.initialized = true;
     }
 
-    @Override
     public PathingControlManager getPathingControlManager() {
         return this.pathingControlManager;
     }

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

@@ -55,7 +55,10 @@ public class InventoryBehavior extends Behavior {
     }
 
     private void swapWithHotBar(int inInventory, int inHotbar) {
-        ctx.playerController().windowClick(ctx.player().inventoryContainer.windowId, inInventory < 9 ? inInventory + 36 : inInventory, inHotbar, ClickType.SWAP, ctx.player());
+        if (inInventory < 9) {
+            inInventory += 36;
+        }
+        ctx.playerController().windowClick(ctx.player().inventoryContainer.windowId, inInventory, inHotbar, ClickType.SWAP, ctx.player());
     }
 
     private int firstValidThrowaway() { // TODO offhand idk
@@ -78,7 +81,7 @@ public class InventoryBehavior extends Behavior {
                 continue;
             }
             if (klass.isInstance(stack.getItem())) {
-                double speed = ToolSet.calculateSpeedVsBlock(stack, against.getDefaultState()); // takes into account enchants
+                double speed = ToolSet.calculateStrVsBlock(stack, against.getDefaultState()); // takes into account enchants
                 if (speed > bestSpeed) {
                     bestSpeed = speed;
                     bestInd = i;

src/main/java/baritone/behavior/MemoryBehavior.java

@@ -21,7 +21,6 @@ import baritone.Baritone;
 import baritone.api.event.events.BlockInteractEvent;
 import baritone.api.event.events.PacketEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
-import baritone.api.event.events.TickEvent;
 import baritone.api.event.events.type.EventState;
 import baritone.cache.ContainerMemory;
 import baritone.cache.Waypoint;
@@ -61,14 +60,6 @@ public final class MemoryBehavior extends Behavior {
         super(baritone);
     }
 
-    @Override
-    public synchronized void onTick(TickEvent event) {
-        if (event.getType() == TickEvent.Type.OUT) {
-            enderChestWindowId = null;
-            futureInventories.clear();
-        }
-    }
-
     @Override
     public synchronized void onPlayerUpdate(PlayerUpdateEvent event) {
         if (event.getState() == EventState.PRE) {
@@ -125,10 +116,12 @@ public final class MemoryBehavior extends Behavior {
 
                 System.out.println("Received packet " + packet.getGuiId() + " " + packet.getEntityId() + " " + packet.getSlotCount() + " " + packet.getWindowId());
                 System.out.println(packet.getWindowTitle());
-                if (packet.getWindowTitle() instanceof TextComponentTranslation && ((TextComponentTranslation) packet.getWindowTitle()).getKey().equals("container.enderchest")) {
+                if (packet.getWindowTitle() instanceof TextComponentTranslation) {
                     // title is not customized (i.e. this isn't just a renamed shulker)
-                    enderChestWindowId = packet.getWindowId();
-                    return;
+                    if (((TextComponentTranslation) packet.getWindowTitle()).getKey().equals("container.enderchest")) {
+                        enderChestWindowId = packet.getWindowId();
+                        return;
+                    }
                 }
                 futureInventories.stream()
                         .filter(i -> i.type.equals(packet.getGuiId()) && i.slots == packet.getSlotCount())
@@ -184,7 +177,7 @@ public final class MemoryBehavior extends Behavior {
     }
 
     private BlockPos neighboringConnectedBlock(BlockPos in) {
-        BlockStateInterface bsi = new CalculationContext(baritone).bsi;
+        BlockStateInterface bsi = new CalculationContext(baritone).bsi();
         Block block = bsi.get0(in).getBlock();
         if (block != Blocks.TRAPPED_CHEST && block != Blocks.CHEST) {
             return null; // other things that have contents, but can be placed adjacent without combining

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

@@ -433,7 +433,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
             Optional<IPath> path = calcResult.getPath();
             if (Baritone.settings().cutoffAtLoadBoundary.get()) {
                 path = path.map(p -> {
-                    IPath result = p.cutoffAtLoadedChunks(context.bsi);
+                    IPath result = p.cutoffAtLoadedChunks(context.bsi());
 
                     if (result instanceof CutoffPath) {
                         logDebug("Cutting off path at edge of loaded chunks");
@@ -499,7 +499,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
         Goal transformed = goal;
         if (Baritone.settings().simplifyUnloadedYCoord.get() && goal instanceof IGoalRenderPos) {
             BlockPos pos = ((IGoalRenderPos) goal).getGoalPos();
-            if (!context.bsi.worldContainsLoadedChunk(pos.getX(), pos.getZ())) {
+            if (context.world().getChunk(pos) instanceof EmptyChunk) {
                 transformed = new GoalXZ(pos.getX(), pos.getZ());
             }
         }

src/main/java/baritone/cache/CachedWorld.java

@@ -179,8 +179,8 @@ public final class CachedWorld implements ICachedWorld, Helper {
             if (region == null) {
                 continue;
             }
-            int distX = (region.getX() << 9 + 256) - pruneCenter.getX();
-            int distZ = (region.getZ() << 9 + 256) - pruneCenter.getZ();
+            int distX = (region.getX() * 512 + 256) - pruneCenter.getX();
+            int distZ = (region.getZ() * 512 + 256) - pruneCenter.getZ();
             double dist = Math.sqrt(distX * distX + distZ * distZ);
             if (dist > 1024) {
                 logDebug("Deleting cached region " + region.getX() + "," + region.getZ() + " from ram");
@@ -215,7 +215,7 @@ public final class CachedWorld implements ICachedWorld, Helper {
         if (mostRecentlyModified == null) {
             return new BlockPos(0, 0, 0);
         }
-        return new BlockPos(mostRecentlyModified.x << 4 + 8, 0, mostRecentlyModified.z << 4 + 8);
+        return new BlockPos(mostRecentlyModified.x * 16 + 8, 0, mostRecentlyModified.z * 16 + 8);
     }
 
     private synchronized List<CachedRegion> allRegions() {

src/main/java/baritone/cache/ContainerMemory.java

@@ -123,8 +123,7 @@ public class ContainerMemory implements IContainerMemory {
         return out.array();
     }
 
-    public static PacketBuffer writeItemStacks(List<ItemStack> write, PacketBuffer out2) {
-        PacketBuffer out = out2; // avoid reassigning an argument LOL
+    public static PacketBuffer writeItemStacks(List<ItemStack> write, PacketBuffer out) {
         out = new PacketBuffer(out.writeInt(write.size()));
         for (ItemStack stack : write) {
             out = out.writeItemStack(stack);

src/main/java/baritone/cache/WorldScanner.java

@@ -28,9 +28,8 @@ import net.minecraft.world.chunk.BlockStateContainer;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
+import java.util.LinkedList;
 import java.util.List;
 
 public enum WorldScanner implements IWorldScanner {
@@ -42,7 +41,7 @@ public enum WorldScanner implements IWorldScanner {
         if (blocks.contains(null)) {
             throw new IllegalStateException("Invalid block name should have been caught earlier: " + blocks.toString());
         }
-        ArrayList<BlockPos> res = new ArrayList<>();
+        LinkedList<BlockPos> res = new LinkedList<>();
         if (blocks.isEmpty()) {
             return res;
         }
@@ -72,7 +71,33 @@ public enum WorldScanner implements IWorldScanner {
                         continue;
                     }
                     allUnloaded = false;
-                    scanChunkInto(chunkX << 4, chunkZ << 4, chunk, blocks, res, max, yLevelThreshold, playerY);
+                    ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
+                    chunkX = chunkX << 4;
+                    chunkZ = chunkZ << 4;
+                    for (int y0 = 0; y0 < 16; y0++) {
+                        ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
+                        if (extendedblockstorage == null) {
+                            continue;
+                        }
+                        int yReal = y0 << 4;
+                        BlockStateContainer bsc = extendedblockstorage.getData();
+                        // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x;
+                        // for better cache locality, iterate in that order
+                        for (int y = 0; y < 16; y++) {
+                            for (int z = 0; z < 16; z++) {
+                                for (int x = 0; x < 16; x++) {
+                                    IBlockState state = bsc.get(x, y, z);
+                                    if (blocks.contains(state.getBlock())) {
+                                        int yy = yReal | y;
+                                        res.add(new BlockPos(chunkX | x, yy, chunkZ | z));
+                                        if (Math.abs(yy - playerY) < yLevelThreshold) {
+                                            foundWithinY = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
             if ((allUnloaded && foundChunks)
@@ -99,12 +124,7 @@ public enum WorldScanner implements IWorldScanner {
             return Collections.emptyList();
         }
 
-        ArrayList<BlockPos> res = new ArrayList<>();
-        scanChunkInto(pos.x << 4, pos.z << 4, chunk, blocks, res, max, yLevelThreshold, playerY);
-        return res;
-    }
-
-    public void scanChunkInto(int chunkX, int chunkZ, Chunk chunk, List<Block> search, Collection<BlockPos> result, int max, int yLevelThreshold, int playerY) {
+        LinkedList<BlockPos> res = new LinkedList<>();
         ExtendedBlockStorage[] chunkInternalStorageArray = chunk.getBlockStorageArray();
         for (int y0 = 0; y0 < 16; y0++) {
             ExtendedBlockStorage extendedblockstorage = chunkInternalStorageArray[y0];
@@ -113,22 +133,21 @@ public enum WorldScanner implements IWorldScanner {
             }
             int yReal = y0 << 4;
             BlockStateContainer bsc = extendedblockstorage.getData();
-            // the mapping of BlockStateContainer.getIndex from xyz to index is y << 8 | z << 4 | x;
-            // for better cache locality, iterate in that order
             for (int y = 0; y < 16; y++) {
                 for (int z = 0; z < 16; z++) {
                     for (int x = 0; x < 16; x++) {
                         IBlockState state = bsc.get(x, y, z);
-                        if (search.contains(state.getBlock())) {
+                        if (blocks.contains(state.getBlock())) {
                             int yy = yReal | y;
-                            result.add(new BlockPos(chunkX | x, yy, chunkZ | z));
-                            if (result.size() >= max && Math.abs(yy - playerY) < yLevelThreshold) {
-                                return;
+                            res.add(new BlockPos((pos.x << 4) | x, yy, (pos.z << 4) | z));
+                            if (res.size() >= max || Math.abs(yy - playerY) < yLevelThreshold) {
+                                return res;
                             }
                         }
                     }
                 }
             }
         }
+        return res;
     }
 }

src/main/java/baritone/event/GameEventHandler.java

@@ -54,6 +54,11 @@ public final class GameEventHandler implements IEventBus, Helper {
         listeners.forEach(l -> l.onPlayerUpdate(event));
     }
 
+    @Override
+    public final void onProcessKeyBinds() {
+        listeners.forEach(IGameEventListener::onProcessKeyBinds);
+    }
+
     @Override
     public final void onSendChatMessage(ChatEvent event) {
         listeners.forEach(l -> l.onSendChatMessage(event));

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

@@ -25,15 +25,11 @@ import baritone.api.utils.BetterBlockPos;
 import baritone.pathing.calc.openset.BinaryHeapOpenSet;
 import baritone.pathing.movement.CalculationContext;
 import baritone.pathing.movement.Moves;
-import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
 import baritone.utils.pathing.BetterWorldBorder;
 import baritone.utils.pathing.Favoring;
 import baritone.utils.pathing.MutableMoveResult;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
 import java.util.Optional;
 
 /**
@@ -59,6 +55,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
         startNode.combinedCost = startNode.estimatedCostToGoal;
         BinaryHeapOpenSet openSet = new BinaryHeapOpenSet();
         openSet.insert(startNode);
+        startNode.isOpen = true;
         bestSoFar = new PathNode[COEFFICIENTS.length];//keep track of the best node by the metric of (estimatedCostToGoal + cost / COEFFICIENTS[i])
         double[] bestHeuristicSoFar = new double[COEFFICIENTS.length];
         for (int i = 0; i < bestHeuristicSoFar.length; i++) {
@@ -67,8 +64,8 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
         }
         MutableMoveResult res = new MutableMoveResult();
         Favoring favored = favoring;
-        BetterWorldBorder worldBorder = new BetterWorldBorder(calcContext.world.getWorldBorder());
-        long startTime = System.currentTimeMillis();
+        BetterWorldBorder worldBorder = new BetterWorldBorder(calcContext.world().getWorldBorder());
+        long startTime = System.nanoTime() / 1000000L;
         boolean slowPath = Baritone.settings().slowPath.get();
         if (slowPath) {
             logDebug("slowPath is on, path timeout will be " + Baritone.settings().slowPathTimeoutMS.<Long>get() + "ms instead of " + primaryTimeout + "ms");
@@ -80,39 +77,12 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
         int numMovementsConsidered = 0;
         int numEmptyChunk = 0;
         boolean favoring = !favored.isEmpty();
-        int timeCheckInterval = 1 << 6;
         int pathingMaxChunkBorderFetch = Baritone.settings().pathingMaxChunkBorderFetch.get(); // grab all settings beforehand so that changing settings during pathing doesn't cause a crash or unpredictable behavior
         boolean minimumImprovementRepropagation = Baritone.settings().minimumImprovementRepropagation.get();
-
-        long[] timeConsumed = new long[Moves.values().length];
-        int[] count = new int[Moves.values().length];
-        int[] stateLookup = new int[Moves.values().length];
-        long[] posCreation = new long[Moves.values().length];
-        long heapRemove = 0;
-        int heapRemoveCount = 0;
-        long heapAdd = 0;
-        int heapAddCount = 0;
-        long heapUpdate = 0;
-        int heapUpdateCount = 0;
-
-        long chunk = 0;
-        int chunkCount = 0;
-
-        long goalCheck = 0;
-        int goalCheckCount = 0;
-
-        long getNode = 0;
-        int getNodeCount = 0;
-        int startVal = BlockStateInterface.numTimesChunkSucceeded;
-        int startVal2 = BlockStateInterface.numBlockStateLookups;
-        long startVal3 = BetterBlockPos.numCreated;
-
         while (!openSet.isEmpty() && numEmptyChunk < pathingMaxChunkBorderFetch && !cancelRequested) {
-            if ((numNodes & (timeCheckInterval - 1)) == 0) { // only call this once every 64 nodes (about half a millisecond)
-                long now = System.currentTimeMillis(); // since nanoTime is slow on windows (takes many microseconds)
-                if (now - failureTimeoutTime >= 0 || (!failing && now - primaryTimeoutTime >= 0)) {
-                    break;
-                }
+            long now = System.nanoTime() / 1000000L;
+            if (now - failureTimeoutTime >= 0 || (!failing && now - primaryTimeoutTime >= 0)) {
+                break;
             }
             if (slowPath) {
                 try {
@@ -120,21 +90,15 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 } catch (InterruptedException ex) {
                 }
             }
-            long before = System.nanoTime();
             PathNode currentNode = openSet.removeLowest();
-            long t = System.nanoTime();
-            heapRemove += t - before;
-            heapRemoveCount++;
+            currentNode.isOpen = false;
             mostRecentConsidered = currentNode;
             numNodes++;
             if (goal.isInGoal(currentNode.x, currentNode.y, currentNode.z)) {
-                logDebug("Took " + (System.currentTimeMillis() - startTime) + "ms, " + numMovementsConsidered + " movements considered");
+                logDebug("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, " + numMovementsConsidered + " movements considered");
                 return Optional.of(new Path(startNode, currentNode, numNodes, goal, calcContext));
             }
-            goalCheck += System.nanoTime() - t;
-            goalCheckCount++;
             for (Moves moves : Moves.values()) {
-                long s = System.nanoTime();
                 int newX = currentNode.x + moves.xOffset;
                 int newZ = currentNode.z + moves.zOffset;
                 if ((newX >> 4 != currentNode.x >> 4 || newZ >> 4 != currentNode.z >> 4) && !calcContext.isLoaded(newX, newZ)) {
@@ -142,9 +106,6 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                     if (!moves.dynamicXZ) { // only increment the counter if the movement would have gone out of bounds guaranteed
                         numEmptyChunk++;
                     }
-                    long costStart = System.nanoTime();
-                    chunk += costStart - s;
-                    chunkCount++;
                     continue;
                 }
                 if (!moves.dynamicXZ && !worldBorder.entirelyContains(newX, newZ)) {
@@ -153,19 +114,8 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 if (currentNode.y + moves.yOffset > 256 || currentNode.y + moves.yOffset < 0) {
                     continue;
                 }
-                long costStart = System.nanoTime();
-                chunk += costStart - s;
-                chunkCount++;
-                // TODO cache cost
-                int numLookupsBefore = BlockStateInterface.numBlockStateLookups;
-                long numCreatedBefore = BetterBlockPos.numCreated;
                 res.reset();
                 moves.apply(calcContext, currentNode.x, currentNode.y, currentNode.z, res);
-                long costEnd = System.nanoTime();
-                stateLookup[moves.ordinal()] += BlockStateInterface.numBlockStateLookups - numLookupsBefore;
-                posCreation[moves.ordinal()] += BetterBlockPos.numCreated - numCreatedBefore;
-                timeConsumed[moves.ordinal()] += costEnd - costStart;
-                count[moves.ordinal()]++;
                 numMovementsConsidered++;
                 double actionCost = res.cost;
                 if (actionCost >= ActionCosts.COST_INF) {
@@ -174,10 +124,10 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 if (actionCost <= 0 || Double.isNaN(actionCost)) {
                     throw new IllegalStateException(moves + " calculated implausible cost " + actionCost);
                 }
-                // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
                 if (moves.dynamicXZ && !worldBorder.entirelyContains(res.x, res.z)) { // see issue #218
                     continue;
                 }
+                // check destination after verifying it's not COST_INF -- some movements return a static IMPOSSIBLE object with COST_INF and destination being 0,0,0 to avoid allocating a new result for every failed calculation
                 if (!moves.dynamicXZ && (res.x != newX || res.z != newZ)) {
                     throw new IllegalStateException(moves + " " + res.x + " " + newX + " " + res.z + " " + newZ);
                 }
@@ -189,10 +139,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                     // see issue #18
                     actionCost *= favored.calculate(hashCode);
                 }
-                long st = System.nanoTime();
                 PathNode neighbor = getNodeAtPosition(res.x, res.y, res.z, hashCode);
-                getNode += System.nanoTime() - st;
-                getNodeCount++;
                 double tentativeCost = currentNode.cost + actionCost;
                 if (tentativeCost < neighbor.cost) {
                     double improvementBy = neighbor.cost - tentativeCost;
@@ -206,16 +153,11 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                     neighbor.previous = currentNode;
                     neighbor.cost = tentativeCost;
                     neighbor.combinedCost = tentativeCost + neighbor.estimatedCostToGoal;
-                    if (neighbor.isOpen()) {
-                        long bef = System.nanoTime();
+                    if (neighbor.isOpen) {
                         openSet.update(neighbor);
-                        heapUpdate += System.nanoTime() - bef;
-                        heapUpdateCount++;
                     } else {
-                        long bef = System.nanoTime();
+                        neighbor.isOpen = true;
                         openSet.insert(neighbor);//dont double count, dont insert into open set if it's already there
-                        heapAdd += System.nanoTime() - bef;
-                        heapAddCount++;
                     }
                     for (int i = 0; i < bestSoFar.length; i++) {
                         double heuristic = neighbor.estimatedCostToGoal + neighbor.cost / COEFFICIENTS[i];
@@ -233,43 +175,13 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 }
             }
         }
-        int numBlockState = BlockStateInterface.numBlockStateLookups - startVal2;
-        int numSucc = BlockStateInterface.numTimesChunkSucceeded - startVal;
-        long numSuccc = BetterBlockPos.numCreated - startVal3;
-
-        long totalAccountedTimeMS = 0;
-        totalAccountedTimeMS += heapRemove / 1000000;
-        totalAccountedTimeMS += heapAdd / 1000000;
-        totalAccountedTimeMS += heapUpdate / 1000000;
-        totalAccountedTimeMS += chunk / 1000000;
-        totalAccountedTimeMS += getNode / 1000000;
-        totalAccountedTimeMS += goalCheck / 1000000;
-        System.out.println("Out of " + numBlockState + " block state lookups, " + numSucc + " were in the same chunk as the previous and could be cached");
-        System.out.println("Instantiated " + numSuccc + " BetterBlockPos objects");
-        System.out.println("Remove " + (heapRemove / heapRemoveCount) + " " + heapRemove / 1000000 + "ms " + heapRemoveCount);
-        System.out.println("Add " + (heapAdd / heapAddCount) + " " + heapAdd / 1000000 + "ms " + heapAddCount);
-        System.out.println("Update " + (heapUpdate / heapUpdateCount) + " " + heapUpdate / 1000000 + "ms " + heapUpdateCount);
-        System.out.println("Chunk " + (chunk / chunkCount) + " " + chunk / 1000000 + "ms " + chunkCount);
-        System.out.println("GetNode " + (getNode / getNodeCount) + " " + getNode / 1000000 + "ms " + getNodeCount);
-        System.out.println("GoalCheck " + (goalCheck / goalCheckCount) + " " + goalCheck / 1000000 + "ms " + goalCheckCount);
-        ArrayList<Moves> moves = new ArrayList<>(Arrays.asList(Moves.values()));
-        moves.sort(Comparator.comparingLong(k -> timeConsumed[k.ordinal()] / count[k.ordinal()]));
-        for (Moves move : moves) {
-            int num = count[move.ordinal()];
-            long nanoTime = timeConsumed[move.ordinal()];
-            totalAccountedTimeMS += nanoTime / 1000000;
-            System.out.println(nanoTime / num + " " + move + " " + nanoTime / 1000000 + "ms " + num);
-            System.out.println(stateLookup[move.ordinal()] / num + " " + stateLookup[move.ordinal()]);
-            System.out.println(posCreation[move.ordinal()] / num + " " + posCreation[move.ordinal()]);
-        }
-        System.out.println("Total accounted time: " + totalAccountedTimeMS);
         if (cancelRequested) {
             return Optional.empty();
         }
         System.out.println(numMovementsConsidered + " movements considered");
         System.out.println("Open set size: " + openSet.size());
         System.out.println("PathNode map size: " + mapSize());
-        System.out.println((int) (numNodes * 1.0 / ((System.currentTimeMillis() - startTime) / 1000F)) + " nodes per second");
+        System.out.println((int) (numNodes * 1.0 / ((System.nanoTime() / 1000000L - startTime) / 1000F)) + " nodes per second");
         double bestDist = 0;
         for (int i = 0; i < bestSoFar.length; i++) {
             if (bestSoFar[i] == null) {
@@ -280,7 +192,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch implements Hel
                 bestDist = dist;
             }
             if (dist > MIN_DIST_PATH * MIN_DIST_PATH) { // square the comparison since distFromStartSq is squared
-                logDebug("Took " + (System.currentTimeMillis() - startTime) + "ms, A* cost coefficient " + COEFFICIENTS[i] + ", " + numMovementsConsidered + " movements considered");
+                logDebug("Took " + (System.nanoTime() / 1000000L - startTime) + "ms, A* cost coefficient " + COEFFICIENTS[i] + ", " + numMovementsConsidered + " movements considered");
                 if (COEFFICIENTS[i] >= 3) {
                     System.out.println("Warning: cost coefficient is greater than three! Probably means that");
                     System.out.println("the path I found is pretty terrible (like sneak-bridging for dozens of blocks)");

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

@@ -136,10 +136,11 @@ public abstract class AbstractNodeCostSearch implements IPathFinder {
      * for the node mapped to the specified pos. If no node is found,
      * a new node is created.
      *
-     * @param x        The x position of the node
-     * @param y        The y position of the node
-     * @param z        The z position of the node
+     * @param x The x position of the node
+     * @param y The y position of the node
+     * @param z The z position of the node
      * @param hashCode The hash code of the node, provided by {@link BetterBlockPos#longHash(int, int, int)}
+     *
      * @return The associated node
      * @see <a href="https://github.com/cabaletta/baritone/issues/107">Issue #107</a>
      */

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

@@ -132,9 +132,7 @@ class Path extends PathBase {
             Movement move = moves.apply0(context, src);
             if (move.getDest().equals(dest)) {
                 // have to calculate the cost at calculation time so we can accurately judge whether a cost increase happened between cached calculation and real execution
-                // however, taking into account possible favoring that could skew the node cost, we really want the stricter limit of the two
-                // so we take the minimum of the path node cost difference, and the calculated cost
-                move.override(Math.min(move.calculateCost(context), cost));
+                move.override(cost);
                 return move;
             }
         }

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

@@ -58,6 +58,12 @@ public final class PathNode {
      */
     public PathNode previous;
 
+    /**
+     * Is this a member of the open set in A*? (only used during pathfinding)
+     * Instead of doing a costly member check in the open set, cache membership in each node individually too.
+     */
+    public boolean isOpen;
+
     /**
      * Where is this node in the array flattenization of the binary heap? Needed for decrease-key operations.
      */
@@ -70,16 +76,12 @@ public final class PathNode {
         if (Double.isNaN(estimatedCostToGoal)) {
             throw new IllegalStateException(goal + " calculated implausible heuristic");
         }
-        this.heapPosition = -1;
+        this.isOpen = false;
         this.x = x;
         this.y = y;
         this.z = z;
     }
 
-    public boolean isOpen() {
-        return heapPosition != -1;
-    }
-
     /**
      * TODO: Possibly reimplement hashCode and equals. They are necessary for this class to function but they could be done better
      *

src/main/java/baritone/pathing/calc/openset/BinaryHeapOpenSet.java

@@ -59,7 +59,7 @@ public final class BinaryHeapOpenSet implements IOpenSet {
     @Override
     public final void insert(PathNode value) {
         if (size >= array.length - 1) {
-            array = Arrays.copyOf(array, array.length << 1);
+            array = Arrays.copyOf(array, array.length * 2);
         }
         size++;
         value.heapPosition = size;

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

@@ -42,28 +42,26 @@ public class CalculationContext {
 
     private static final ItemStack STACK_BUCKET_WATER = new ItemStack(Items.WATER_BUCKET);
 
-    public final IBaritone baritone;
-    public final World world;
-    public final WorldData worldData;
-    public final BlockStateInterface bsi;
-    public final ToolSet toolSet;
-    public final boolean hasWaterBucket;
-    public final boolean hasThrowaway;
-    public final boolean canSprint;
-    public final double placeBlockCost;
-    public final boolean allowBreak;
-    public final boolean allowParkour;
-    public final boolean allowParkourPlace;
-    public final boolean allowJumpAt256;
-    public final boolean assumeWalkOnWater;
-    public final boolean allowDiagonalDescend;
-    public final int maxFallHeightNoWater;
-    public final int maxFallHeightBucket;
-    public final double waterWalkSpeed;
-    public final double breakBlockAdditionalCost;
-    public final double jumpPenalty;
-    public final double walkOnWaterOnePenalty;
-    public final BetterWorldBorder worldBorder;
+    private final IBaritone baritone;
+    private final EntityPlayerSP player;
+    private final World world;
+    private final WorldData worldData;
+    private final BlockStateInterface bsi;
+    private final ToolSet toolSet;
+    private final boolean hasWaterBucket;
+    private final boolean hasThrowaway;
+    private final boolean canSprint;
+    private final double placeBlockCost;
+    private final boolean allowBreak;
+    private final boolean allowParkour;
+    private final boolean allowParkourPlace;
+    private final boolean allowJumpAt256;
+    private final boolean assumeWalkOnWater;
+    private final int maxFallHeightNoWater;
+    private final int maxFallHeightBucket;
+    private final double waterWalkSpeed;
+    private final double breakBlockAdditionalCost;
+    private final BetterWorldBorder worldBorder;
 
     public CalculationContext(IBaritone baritone) {
         this(baritone, false);
@@ -71,10 +69,11 @@ public class CalculationContext {
 
     public CalculationContext(IBaritone baritone, boolean forUseOnAnotherThread) {
         this.baritone = baritone;
-        EntityPlayerSP player = baritone.getPlayerContext().player();
+        this.player = baritone.getPlayerContext().player();
         this.world = baritone.getPlayerContext().world();
         this.worldData = (WorldData) baritone.getWorldProvider().getCurrentWorld();
         this.bsi = new BlockStateInterface(world, worldData, forUseOnAnotherThread); // TODO TODO TODO
+        // new CalculationContext() needs to happen, can't add an argument (i'll beat you), can we get the world provider from currentlyTicking?
         this.toolSet = new ToolSet(player);
         this.hasThrowaway = Baritone.settings().allowPlace.get() && MovementHelper.throwaway(baritone.getPlayerContext(), false);
         this.hasWaterBucket = Baritone.settings().allowWaterBucketFall.get() && InventoryPlayer.isHotbar(player.inventory.getSlotFor(STACK_BUCKET_WATER)) && !world.provider.isNether();
@@ -85,7 +84,6 @@ public class CalculationContext {
         this.allowParkourPlace = Baritone.settings().allowParkourPlace.get();
         this.allowJumpAt256 = Baritone.settings().allowJumpAt256.get();
         this.assumeWalkOnWater = Baritone.settings().assumeWalkOnWater.get();
-        this.allowDiagonalDescend = Baritone.settings().allowDiagonalDescend.get();
         this.maxFallHeightNoWater = Baritone.settings().maxFallHeightNoWater.get();
         this.maxFallHeightBucket = Baritone.settings().maxFallHeightBucket.get();
         int depth = EnchantmentHelper.getDepthStriderModifier(player);
@@ -95,8 +93,6 @@ public class CalculationContext {
         float mult = depth / 3.0F;
         this.waterWalkSpeed = ActionCosts.WALK_ONE_IN_WATER_COST * (1 - mult) + ActionCosts.WALK_ONE_BLOCK_COST * mult;
         this.breakBlockAdditionalCost = Baritone.settings().blockBreakAdditionalPenalty.get();
-        this.jumpPenalty = Baritone.settings().jumpPenalty.get();
-        this.walkOnWaterOnePenalty = Baritone.settings().walkOnWaterOnePenalty.get();
         // why cache these things here, why not let the movements just get directly from settings?
         // because if some movements are calculated one way and others are calculated another way,
         // then you get a wildly inconsistent path that isn't optimal for either scenario.
@@ -124,7 +120,7 @@ public class CalculationContext {
     }
 
     public boolean canPlaceThrowawayAt(int x, int y, int z) {
-        if (!hasThrowaway) { // only true if allowPlace is true, see constructor
+        if (!hasThrowaway()) { // only true if allowPlace is true, see constructor
             return false;
         }
         if (isPossiblyProtected(x, y, z)) {
@@ -134,7 +130,7 @@ public class CalculationContext {
     }
 
     public boolean canBreakAt(int x, int y, int z) {
-        if (!allowBreak) {
+        if (!allowBreak()) {
             return false;
         }
         return !isPossiblyProtected(x, y, z);
@@ -144,4 +140,76 @@ public class CalculationContext {
         // TODO more protection logic here; see #220
         return false;
     }
+
+    public World world() {
+        return world;
+    }
+
+    public EntityPlayerSP player() {
+        return player;
+    }
+
+    public BlockStateInterface bsi() {
+        return bsi;
+    }
+
+    public WorldData worldData() {
+        return worldData;
+    }
+
+    public ToolSet getToolSet() {
+        return toolSet;
+    }
+
+    public boolean hasWaterBucket() {
+        return hasWaterBucket;
+    }
+
+    public boolean hasThrowaway() {
+        return hasThrowaway;
+    }
+
+    public boolean canSprint() {
+        return canSprint;
+    }
+
+    public double placeBlockCost() {
+        return placeBlockCost;
+    }
+
+    public boolean allowBreak() {
+        return allowBreak;
+    }
+
+    public boolean allowParkour() {
+        return allowParkour;
+    }
+
+    public boolean allowParkourPlace() {
+        return allowParkourPlace;
+    }
+
+    public boolean allowJumpAt256() {
+        return allowJumpAt256;
+    }
+
+    public boolean assumeWalkOnWater() {
+        return assumeWalkOnWater;
+    }
+
+    public int maxFallHeightNoWater() {
+        return maxFallHeightNoWater;
+    }
+
+    public int maxFallHeightBucket() {
+        return maxFallHeightBucket;
+    }
+
+    public double waterWalkSpeed() {
+        return waterWalkSpeed;
+    }
+
+    public double breakBlockAdditionalCost() {
+        return breakBlockAdditionalCost;
+    }
 }

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

@@ -26,6 +26,7 @@ import baritone.utils.BlockStateInterface;
 import net.minecraft.block.BlockLiquid;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.chunk.EmptyChunk;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -34,6 +35,7 @@ import java.util.Optional;
 
 public abstract class Movement implements IMovement, MovementHelper {
 
+    protected static final EnumFacing[] HORIZONTALS = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST};
     protected static final EnumFacing[] HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP = {EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.EAST, EnumFacing.WEST, EnumFacing.DOWN};
 
     protected final IBaritone baritone;
@@ -84,7 +86,7 @@ public abstract class Movement implements IMovement, MovementHelper {
         return cost;
     }
 
-    public abstract double calculateCost(CalculationContext context);
+    protected abstract double calculateCost(CalculationContext context);
 
     @Override
     public double recalculateCost() {
@@ -124,10 +126,13 @@ public abstract class Movement implements IMovement, MovementHelper {
                         rotation,
                         currentState.getTarget().hasToForceRotations()));
 
+        // TODO: calculate movement inputs from latestState.getGoal().position
+        // latestState.getTarget().position.ifPresent(null);      NULL CONSUMER REALLY SHOULDN'T BE THE FINAL THING YOU SHOULD REALLY REPLACE THIS WITH ALMOST ACTUALLY ANYTHING ELSE JUST PLEASE DON'T LEAVE IT AS IT IS THANK YOU KANYE
+
         currentState.getInputStates().forEach((input, forced) -> {
             baritone.getInputOverrideHandler().setInputForceState(input, forced);
         });
-        currentState.getInputStates().clear();
+        currentState.getInputStates().replaceAll((input, forced) -> false);
 
         // If the current status indicates a completed movement
         if (currentState.getStatus().isComplete()) {
@@ -226,7 +231,7 @@ public abstract class Movement implements IMovement, MovementHelper {
     }
 
     public void checkLoadedChunk(CalculationContext context) {
-        calculatedWhileLoaded = context.bsi.worldContainsLoadedChunk(dest.x, dest.z);
+        calculatedWhileLoaded = !(context.world().getChunk(getDest()) instanceof EmptyChunk);
     }
 
     @Override

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

@@ -340,24 +340,24 @@ public interface MovementHelper extends ActionCosts, Helper {
 
     static double getMiningDurationTicks(CalculationContext context, int x, int y, int z, IBlockState state, boolean includeFalling) {
         Block block = state.getBlock();
-        if (!canWalkThrough(context.bsi, x, y, z, state)) {
+        if (!canWalkThrough(context.bsi(), x, y, z, state)) {
             if (!context.canBreakAt(x, y, z)) {
                 return COST_INF;
             }
-            if (avoidBreaking(context.bsi, x, y, z, state)) {
+            if (avoidBreaking(context.bsi(), x, y, z, state)) {
                 return COST_INF;
             }
             if (block instanceof BlockLiquid) {
                 return COST_INF;
             }
             double m = Blocks.CRAFTING_TABLE.equals(block) ? 10 : 1; // TODO see if this is still necessary. it's from MineBot when we wanted to penalize breaking its crafting table
-            double strVsBlock = context.toolSet.getStrVsBlock(state);
+            double strVsBlock = context.getToolSet().getStrVsBlock(state);
             if (strVsBlock <= 0) {
                 return COST_INF;
             }
 
             double result = m / strVsBlock;
-            result += context.breakBlockAdditionalCost;
+            result += context.breakBlockAdditionalCost();
             if (includeFalling) {
                 IBlockState above = context.get(x, y + 1, z);
                 if (above.getBlock() instanceof BlockFalling) {

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

@@ -20,6 +20,7 @@ package baritone.pathing.movement;
 import baritone.api.pathing.movement.MovementStatus;
 import baritone.api.utils.Rotation;
 import baritone.api.utils.input.Input;
+import net.minecraft.util.math.Vec3d;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -28,6 +29,7 @@ import java.util.Optional;
 public class MovementState {
 
     private MovementStatus status;
+    private MovementTarget goal = new MovementTarget();
     private MovementTarget target = new MovementTarget();
     private final Map<Input, Boolean> inputState = new HashMap<>();
 
@@ -40,6 +42,15 @@ public class MovementState {
         return status;
     }
 
+    public MovementTarget getGoal() {
+        return this.goal;
+    }
+
+    public MovementState setGoal(MovementTarget goal) {
+        this.goal = goal;
+        return this;
+    }
+
     public MovementTarget getTarget() {
         return this.target;
     }
@@ -54,12 +65,23 @@ public class MovementState {
         return this;
     }
 
+    public boolean getInput(Input input) {
+        return this.inputState.getOrDefault(input, false);
+    }
+
     public Map<Input, Boolean> getInputStates() {
         return this.inputState;
     }
 
     public static class MovementTarget {
 
+        /**
+         * Necessary movement to achieve
+         * <p>
+         * TODO: Decide desiredMovement type
+         */
+        public Vec3d position;
+
         /**
          * Yaw and pitch angles that must be matched
          */
@@ -73,14 +95,27 @@ public class MovementState {
         private boolean forceRotations;
 
         public MovementTarget() {
-            this(null, false);
+            this(null, null, false);
+        }
+
+        public MovementTarget(Vec3d position) {
+            this(position, null, false);
         }
 
         public MovementTarget(Rotation rotation, boolean forceRotations) {
+            this(null, rotation, forceRotations);
+        }
+
+        public MovementTarget(Vec3d position, Rotation rotation, boolean forceRotations) {
+            this.position = position;
             this.rotation = rotation;
             this.forceRotations = forceRotations;
         }
 
+        public final Optional<Vec3d> getPosition() {
+            return Optional.ofNullable(this.position);
+        }
+
         public final Optional<Rotation> getRotation() {
             return Optional.ofNullable(this.rotation);
         }

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

@@ -52,18 +52,18 @@ public class MovementAscend extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         return cost(context, src.x, src.y, src.z, dest.x, dest.z);
     }
 
     public static double cost(CalculationContext context, int x, int y, int z, int destX, int destZ) {
         IBlockState toPlace = context.get(destX, y, destZ);
         boolean hasToPlace = false;
-        if (!MovementHelper.canWalkOn(context.bsi, destX, y, destZ, toPlace)) {
+        if (!MovementHelper.canWalkOn(context.bsi(), destX, y, destZ, toPlace)) {
             if (!context.canPlaceThrowawayAt(destX, y, destZ)) {
                 return COST_INF;
             }
-            if (!MovementHelper.isReplacable(destX, y, destZ, toPlace, context.bsi)) {
+            if (!MovementHelper.isReplacable(destX, y, destZ, toPlace, context.bsi())) {
                 return COST_INF;
             }
             for (int i = 0; i < 5; i++) {
@@ -73,7 +73,7 @@ public class MovementAscend extends Movement {
                 if (againstX == x && againstZ == z) { // we might be able to backplace now, but it doesn't matter because it will have been broken by the time we'd need to use it
                     continue;
                 }
-                if (MovementHelper.canPlaceAgainst(context.bsi, againstX, againstY, againstZ)) {
+                if (MovementHelper.canPlaceAgainst(context.bsi(), againstX, againstY, againstZ)) {
                     hasToPlace = true;
                     break;
                 }
@@ -83,7 +83,7 @@ public class MovementAscend extends Movement {
             }
         }
         IBlockState srcUp2 = context.get(x, y + 2, z); // used lower down anyway
-        if (context.get(x, y + 3, z).getBlock() instanceof BlockFalling && (MovementHelper.canWalkThrough(context.bsi, x, y + 1, z) || !(srcUp2.getBlock() instanceof BlockFalling))) {//it would fall on us and possibly suffocate us
+        if (context.get(x, y + 3, z).getBlock() instanceof BlockFalling && (MovementHelper.canWalkThrough(context.bsi(), x, y + 1, z) || !(srcUp2.getBlock() instanceof BlockFalling))) {//it would fall on us and possibly suffocate us
             // HOWEVER, we assume that we're standing in the start position
             // that means that src and src.up(1) are both air
             // maybe they aren't now, but they will be by the time this starts
@@ -115,23 +115,23 @@ public class MovementAscend extends Movement {
         if (jumpingToBottomSlab) {
             if (jumpingFromBottomSlab) {
                 walk = Math.max(JUMP_ONE_BLOCK_COST, WALK_ONE_BLOCK_COST); // we hit space immediately on entering this action
-                walk += context.jumpPenalty;
             } else {
                 walk = WALK_ONE_BLOCK_COST; // we don't hit space we just walk into the slab
             }
         } else {
-            // jumpingFromBottomSlab must be false
             if (toPlace.getBlock() == Blocks.SOUL_SAND) {
                 walk = WALK_ONE_OVER_SOUL_SAND_COST;
             } else {
-                walk = Math.max(JUMP_ONE_BLOCK_COST, WALK_ONE_BLOCK_COST);
+                walk = WALK_ONE_BLOCK_COST;
             }
-            walk += context.jumpPenalty;
         }
 
-        double totalCost = walk;
+        // cracks knuckles
+
+        double totalCost = 0;
+        totalCost += walk;
         if (hasToPlace) {
-            totalCost += context.placeBlockCost;
+            totalCost += context.placeBlockCost();
         }
         // start with srcUp2 since we already have its state
         // includeFalling isn't needed because of the falling check above -- if srcUp3 is falling we will have already exited with COST_INF if we'd actually have to break it

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

@@ -52,7 +52,7 @@ public class MovementDescend extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         MutableMoveResult result = new MutableMoveResult();
         cost(context, src.x, src.y, src.z, dest.x, dest.z, result);
         if (result.y != dest.y) {
@@ -93,7 +93,7 @@ public class MovementDescend extends Movement {
         //C, D, etc determine the length of the fall
 
         IBlockState below = context.get(destX, y - 2, destZ);
-        if (!MovementHelper.canWalkOn(context.bsi, destX, y - 2, destZ, below)) {
+        if (!MovementHelper.canWalkOn(context.bsi(), destX, y - 2, destZ, below)) {
             dynamicFallCost(context, x, y, z, destX, destZ, totalCost, below, res);
             return;
         }
@@ -122,7 +122,7 @@ public class MovementDescend extends Movement {
             // and potentially replace the water we're going to fall into
             return false;
         }
-        if (!MovementHelper.canWalkThrough(context.bsi, destX, y - 2, destZ, below) && below.getBlock() != Blocks.WATER) {
+        if (!MovementHelper.canWalkThrough(context.bsi(), destX, y - 2, destZ, below) && below.getBlock() != Blocks.WATER) {
             return false;
         }
         double costSoFar = 0;
@@ -140,13 +140,13 @@ public class MovementDescend extends Movement {
             if (ontoBlock.getBlock() == Blocks.WATER && context.getBlock(destX, newY + 1, destZ) != Blocks.WATERLILY) {
                 // lilypads are canWalkThrough, but we can't end a fall that should be broken by water if it's covered by a lilypad
                 // however, don't return impossible in the lilypad scenario, because we could still jump right on it (water that's below a lilypad is canWalkOn so it works)
-                if (context.assumeWalkOnWater) {
+                if (context.assumeWalkOnWater()) {
                     return false; // TODO fix
                 }
                 if (MovementHelper.isFlowing(ontoBlock)) {
                     return false; // TODO flowing check required here?
                 }
-                if (!MovementHelper.canWalkOn(context.bsi, destX, newY - 1, destZ)) {
+                if (!MovementHelper.canWalkOn(context.bsi(), destX, newY - 1, destZ)) {
                     // we could punch right through the water into something else
                     return false;
                 }
@@ -168,23 +168,23 @@ public class MovementDescend extends Movement {
                 effectiveStartHeight = newY;
                 continue;
             }
-            if (MovementHelper.canWalkThrough(context.bsi, destX, newY, destZ, ontoBlock)) {
+            if (MovementHelper.canWalkThrough(context.bsi(), destX, newY, destZ, ontoBlock)) {
                 continue;
             }
-            if (!MovementHelper.canWalkOn(context.bsi, destX, newY, destZ, ontoBlock)) {
+            if (!MovementHelper.canWalkOn(context.bsi(), destX, newY, destZ, ontoBlock)) {
                 return false;
             }
             if (MovementHelper.isBottomSlab(ontoBlock)) {
                 return false; // falling onto a half slab is really glitchy, and can cause more fall damage than we'd expect
             }
-            if (context.hasWaterBucket && unprotectedFallHeight <= context.maxFallHeightBucket + 1) {
+            if (context.hasWaterBucket() && unprotectedFallHeight <= context.maxFallHeightBucket() + 1) {
                 res.x = destX;
                 res.y = newY + 1;// this is the block we're falling onto, so dest is +1
                 res.z = destZ;
-                res.cost = tentativeCost + context.placeBlockCost;
+                res.cost = tentativeCost + context.placeBlockCost();
                 return true;
             }
-            if (unprotectedFallHeight <= context.maxFallHeightNoWater + 1) {
+            if (unprotectedFallHeight <= context.maxFallHeightNoWater() + 1) {
                 // fallHeight = 4 means onto.up() is 3 blocks down, which is the max
                 res.x = destX;
                 res.y = newY + 1;

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

@@ -54,7 +54,7 @@ public class MovementDiagonal extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         MutableMoveResult result = new MutableMoveResult();
         cost(context, src.x, src.y, src.z, dest.x, dest.z, result);
         if (result.y != dest.y) {
@@ -65,14 +65,14 @@ public class MovementDiagonal extends Movement {
 
     public static void cost(CalculationContext context, int x, int y, int z, int destX, int destZ, MutableMoveResult res) {
         IBlockState destInto = context.get(destX, y, destZ);
-        if (!MovementHelper.canWalkThrough(context.bsi, destX, y, destZ, destInto) || !MovementHelper.canWalkThrough(context.bsi, destX, y + 1, destZ)) {
+        if (!MovementHelper.canWalkThrough(context.bsi(), destX, y, destZ, destInto) || !MovementHelper.canWalkThrough(context.bsi(), destX, y + 1, destZ)) {
             return;
         }
         IBlockState destWalkOn = context.get(destX, y - 1, destZ);
         boolean descend = false;
-        if (!MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destWalkOn)) {
+        if (!MovementHelper.canWalkOn(context.bsi(), destX, y - 1, destZ, destWalkOn)) {
             descend = true;
-            if (!context.allowDiagonalDescend || !MovementHelper.canWalkOn(context.bsi, destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context.bsi, destX, y - 1, destZ, destWalkOn)) {
+            if (!MovementHelper.canWalkOn(context.bsi(), destX, y - 2, destZ) || !MovementHelper.canWalkThrough(context.bsi(), destX, y - 1, destZ, destWalkOn)) {
                 return;
             }
         }
@@ -80,8 +80,6 @@ public class MovementDiagonal extends Movement {
         // For either possible soul sand, that affects half of our walking
         if (destWalkOn.getBlock() == Blocks.SOUL_SAND) {
             multiplier += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
-        } else if (destWalkOn.getBlock() == Blocks.WATER) {
-            multiplier += context.walkOnWaterOnePenalty * SQRT_2;
         }
         Block fromDown = context.get(x, y - 1, z).getBlock();
         if (fromDown == Blocks.LADDER || fromDown == Blocks.VINE) {
@@ -133,7 +131,7 @@ public class MovementDiagonal extends Movement {
             // Ignore previous multiplier
             // Whatever we were walking on (possibly soul sand) doesn't matter as we're actually floating on water
             // Not even touching the blocks below
-            multiplier = context.waterWalkSpeed;
+            multiplier = context.waterWalkSpeed();
             water = true;
         }
         if (optionA != 0 || optionB != 0) {
@@ -144,7 +142,7 @@ public class MovementDiagonal extends Movement {
             }
         } else {
             // only can sprint if not edging around
-            if (context.canSprint && !water) {
+            if (context.canSprint() && !water) {
                 // If we aren't edging around anything, and we aren't in water
                 // We can sprint =D
                 // Don't check for soul sand, since we can sprint on that too

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

@@ -43,12 +43,12 @@ public class MovementDownward extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         return cost(context, src.x, src.y, src.z);
     }
 
     public static double cost(CalculationContext context, int x, int y, int z) {
-        if (!MovementHelper.canWalkOn(context.bsi, x, y - 2, z)) {
+        if (!MovementHelper.canWalkOn(context.bsi(), x, y - 2, z)) {
             return COST_INF;
         }
         IBlockState down = context.get(x, y - 1, z);

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

@@ -54,7 +54,7 @@ public class MovementFall extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         MutableMoveResult result = new MutableMoveResult();
         MovementDescend.cost(context, src.x, src.y, src.z, dest.x, dest.z, result);
         if (result.y != dest.y) {

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

@@ -60,10 +60,10 @@ public class MovementParkour extends Movement {
     }
 
     public static void cost(CalculationContext context, int x, int y, int z, EnumFacing dir, MutableMoveResult res) {
-        if (!context.allowParkour) {
+        if (!context.allowParkour()) {
             return;
         }
-        if (y == 256 && !context.allowJumpAt256) {
+        if (y == 256 && !context.allowJumpAt256()) {
             return;
         }
 
@@ -74,7 +74,7 @@ public class MovementParkour extends Movement {
             return;
         }
         IBlockState adj = context.get(x + xDiff, y - 1, z + zDiff);
-        if (MovementHelper.canWalkOn(context.bsi, x + xDiff, y - 1, z + zDiff, adj)) { // don't parkour if we could just traverse (for now)
+        if (MovementHelper.canWalkOn(context.bsi(), x + xDiff, y - 1, z + zDiff, adj)) { // don't parkour if we could just traverse (for now)
             // second most common case -- we could just traverse not parkour
             return;
         }
@@ -98,7 +98,7 @@ public class MovementParkour extends Movement {
         if (standingOn.getBlock() == Blocks.SOUL_SAND) {
             maxJump = 2; // 1 block gap
         } else {
-            if (context.canSprint) {
+            if (context.canSprint()) {
                 maxJump = 4;
             } else {
                 maxJump = 3;
@@ -111,18 +111,18 @@ public class MovementParkour extends Movement {
                     return;
                 }
             }
-            if (MovementHelper.canWalkOn(context.bsi, x + xDiff * i, y - 1, z + zDiff * i)) {
+            if (MovementHelper.canWalkOn(context.bsi(), x + xDiff * i, y - 1, z + zDiff * i)) {
                 res.x = x + xDiff * i;
                 res.y = y;
                 res.z = z + zDiff * i;
-                res.cost = costFromJumpDistance(i) + context.jumpPenalty;
+                res.cost = costFromJumpDistance(i);
                 return;
             }
         }
         if (maxJump != 4) {
             return;
         }
-        if (!context.allowParkourPlace) {
+        if (!context.allowParkourPlace()) {
             return;
         }
         int destX = x + 4 * xDiff;
@@ -131,7 +131,7 @@ public class MovementParkour extends Movement {
             return;
         }
         IBlockState toReplace = context.get(destX, y - 1, destZ);
-        if (!MovementHelper.isReplacable(destX, y - 1, destZ, toReplace, context.bsi)) {
+        if (!MovementHelper.isReplacable(destX, y - 1, destZ, toReplace, context.bsi())) {
             return;
         }
         for (int i = 0; i < 5; i++) {
@@ -141,11 +141,11 @@ public class MovementParkour extends Movement {
             if (againstX == x + xDiff * 3 && againstZ == z + zDiff * 3) { // we can't turn around that fast
                 continue;
             }
-            if (MovementHelper.canPlaceAgainst(context.bsi, againstX, againstY, againstZ)) {
+            if (MovementHelper.canPlaceAgainst(context.bsi(), againstX, againstY, againstZ)) {
                 res.x = destX;
                 res.y = y;
                 res.z = destZ;
-                res.cost = costFromJumpDistance(4) + context.placeBlockCost + context.jumpPenalty;
+                res.cost = costFromJumpDistance(4) + context.placeBlockCost();
                 return;
             }
         }
@@ -166,7 +166,7 @@ public class MovementParkour extends Movement {
 
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         MutableMoveResult res = new MutableMoveResult();
         cost(context, src.x, src.y, src.z, direction, res);
         if (res.x != dest.x || res.z != dest.z) {

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

@@ -42,7 +42,7 @@ public class MovementPillar extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         return cost(context, src.x, src.y, src.z);
     }
 
@@ -58,7 +58,7 @@ public class MovementPillar extends Movement {
                 return COST_INF; // can't pillar up from a bottom slab onto a non ladder
             }
         }
-        if (from == Blocks.VINE && !hasAgainst(context, x, y, z)) { // TODO this vine can't be climbed, but we could place a pillar still since vines are replacable, no? perhaps the pillar jump would be impossible because of the slowdown actually.
+        if (from instanceof BlockVine && !hasAgainst(context, x, y, z)) { // TODO this vine can't be climbed, but we could place a pillar still since vines are replacable, no? perhaps the pillar jump would be impossible because of the slowdown actually.
             return COST_INF;
         }
         IBlockState toBreak = context.get(x, y + 2, z);
@@ -76,7 +76,7 @@ public class MovementPillar extends Movement {
         if (!ladder && !context.canPlaceThrowawayAt(x, y, z)) { // we need to place a block where we started to jump on it
             return COST_INF;
         }
-        if (from instanceof BlockLiquid || (fromDown.getBlock() instanceof BlockLiquid && context.assumeWalkOnWater)) {
+        if (from instanceof BlockLiquid || (fromDown.getBlock() instanceof BlockLiquid && context.assumeWalkOnWater())) {
             // otherwise, if we're standing in water, we cannot pillar
             // if we're standing on water and assumeWalkOnWater is true, we cannot pillar
             // if we're standing on water and assumeWalkOnWater is false, we must have ascended to here, or sneak backplaced, so it is possible to pillar again
@@ -112,7 +112,7 @@ public class MovementPillar extends Movement {
         if (ladder) {
             return LADDER_UP_ONE_COST + hardness * 5;
         } else {
-            return JUMP_ONE_BLOCK_COST + context.placeBlockCost + context.jumpPenalty + hardness;
+            return JUMP_ONE_BLOCK_COST + context.placeBlockCost() + hardness;
         }
     }
 
@@ -159,8 +159,8 @@ public class MovementPillar extends Movement {
             }
             return state;
         }
-        boolean ladder = fromDown.getBlock() == Blocks.LADDER || fromDown.getBlock() == Blocks.VINE;
-        boolean vine = fromDown.getBlock() == Blocks.VINE;
+        boolean ladder = fromDown.getBlock() instanceof BlockLadder || fromDown.getBlock() instanceof BlockVine;
+        boolean vine = fromDown.getBlock() instanceof BlockVine;
         Rotation rotation = RotationUtils.calcRotationFromVec3d(ctx.player().getPositionEyes(1.0F),
                 VecUtils.getBlockPosCenter(positionToPlace),
                 new Rotation(ctx.player().rotationYaw, ctx.player().rotationPitch));

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

@@ -30,10 +30,7 @@ import baritone.pathing.movement.Movement;
 import baritone.pathing.movement.MovementHelper;
 import baritone.pathing.movement.MovementState;
 import baritone.utils.BlockStateInterface;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockDoor;
-import net.minecraft.block.BlockFenceGate;
-import net.minecraft.block.BlockSlab;
+import net.minecraft.block.*;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.EnumFacing;
@@ -60,7 +57,7 @@ public class MovementTraverse extends Movement {
     }
 
     @Override
-    public double calculateCost(CalculationContext context) {
+    protected double calculateCost(CalculationContext context) {
         return cost(context, src.x, src.y, src.z, dest.x, dest.z);
     }
 
@@ -69,17 +66,15 @@ public class MovementTraverse extends Movement {
         IBlockState pb1 = context.get(destX, y, destZ);
         IBlockState destOn = context.get(destX, y - 1, destZ);
         Block srcDown = context.getBlock(x, y - 1, z);
-        if (MovementHelper.canWalkOn(context.bsi, destX, y - 1, destZ, destOn)) {//this is a walk, not a bridge
+        if (MovementHelper.canWalkOn(context.bsi(), destX, y - 1, destZ, destOn)) {//this is a walk, not a bridge
             double WC = WALK_ONE_BLOCK_COST;
             boolean water = false;
             if (MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock())) {
-                WC = context.waterWalkSpeed;
+                WC = context.waterWalkSpeed();
                 water = true;
             } else {
                 if (destOn.getBlock() == Blocks.SOUL_SAND) {
                     WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
-                } else if (destOn.getBlock() == Blocks.WATER) {
-                    WC += context.walkOnWaterOnePenalty;
                 }
                 if (srcDown == Blocks.SOUL_SAND) {
                     WC += (WALK_ONE_OVER_SOUL_SAND_COST - WALK_ONE_BLOCK_COST) / 2;
@@ -91,7 +86,7 @@ public class MovementTraverse extends Movement {
             }
             double hardness2 = MovementHelper.getMiningDurationTicks(context, destX, y + 1, destZ, pb0, true); // only include falling on the upper block to break
             if (hardness1 == 0 && hardness2 == 0) {
-                if (!water && context.canSprint) {
+                if (!water && context.canSprint()) {
                     // If there's nothing in the way, and this isn't water, and we aren't sneak placing
                     // We can sprint =D
                     // Don't check for soul sand, since we can sprint on that too
@@ -108,7 +103,7 @@ public class MovementTraverse extends Movement {
             if (srcDown == Blocks.LADDER || srcDown == Blocks.VINE) {
                 return COST_INF;
             }
-            if (MovementHelper.isReplacable(destX, y - 1, destZ, destOn, context.bsi)) {
+            if (MovementHelper.isReplacable(destX, y - 1, destZ, destOn, context.bsi())) {
                 boolean throughWater = MovementHelper.isWater(pb0.getBlock()) || MovementHelper.isWater(pb1.getBlock());
                 if (MovementHelper.isWater(destOn.getBlock()) && throughWater) {
                     // this happens when assume walk on water is true and this is a traverse in water, which isn't allowed
@@ -122,7 +117,7 @@ public class MovementTraverse extends Movement {
                     return COST_INF;
                 }
                 double hardness2 = MovementHelper.getMiningDurationTicks(context, destX, y + 1, destZ, pb0, true); // only include falling on the upper block to break
-                double WC = throughWater ? context.waterWalkSpeed : WALK_ONE_BLOCK_COST;
+                double WC = throughWater ? context.waterWalkSpeed() : WALK_ONE_BLOCK_COST;
                 for (int i = 0; i < 5; i++) {
                     int againstX = destX + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getXOffset();
                     int againstY = y - 1 + HORIZONTALS_BUT_ALSO_DOWN____SO_EVERY_DIRECTION_EXCEPT_UP[i].getYOffset();
@@ -130,8 +125,8 @@ public class MovementTraverse extends Movement {
                     if (againstX == x && againstZ == z) { // this would be a backplace
                         continue;
                     }
-                    if (MovementHelper.canPlaceAgainst(context.bsi, againstX, againstY, againstZ)) { // found a side place option
-                        return WC + context.placeBlockCost + hardness1 + hardness2;
+                    if (MovementHelper.canPlaceAgainst(context.bsi(), againstX, againstY, againstZ)) { // found a side place option
+                        return WC + context.placeBlockCost() + hardness1 + hardness2;
                     }
                 }
                 // now that we've checked all possible directions to side place, we actually need to backplace
@@ -141,8 +136,8 @@ public class MovementTraverse extends Movement {
                 if (srcDown == Blocks.FLOWING_WATER || srcDown == Blocks.WATER) {
                     return COST_INF; // this is obviously impossible
                 }
-                WC = WC * (SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST);//since we are sneak backplacing, we are sneaking lol
-                return WC + context.placeBlockCost + hardness1 + hardness2;
+                WC = WC * SNEAK_ONE_BLOCK_COST / WALK_ONE_BLOCK_COST;//since we are sneak backplacing, we are sneaking lol
+                return WC + context.placeBlockCost() + hardness1 + hardness2;
             }
             return COST_INF;
         }
@@ -186,7 +181,7 @@ public class MovementTraverse extends Movement {
         state.setInput(Input.SNEAK, false);
 
         Block fd = BlockStateInterface.get(ctx, src.down()).getBlock();
-        boolean ladder = fd == Blocks.LADDER || fd == Blocks.VINE;
+        boolean ladder = fd instanceof BlockLadder || fd instanceof BlockVine;
         IBlockState pb0 = BlockStateInterface.get(ctx, positionsToBreak[0]);
         IBlockState pb1 = BlockStateInterface.get(ctx, positionsToBreak[1]);
 
@@ -239,7 +234,7 @@ public class MovementTraverse extends Movement {
                 state.setInput(Input.SPRINT, true);
             }
             Block destDown = BlockStateInterface.get(ctx, dest.down()).getBlock();
-            if (whereAmI.getY() != dest.getY() && ladder && (destDown == Blocks.VINE || destDown == Blocks.LADDER)) {
+            if (whereAmI.getY() != dest.getY() && ladder && (destDown instanceof BlockVine || destDown instanceof BlockLadder)) {
                 new MovementPillar(baritone, dest.down(), dest).updateState(state); // i'm sorry
                 return state;
             }

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

@@ -110,6 +110,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                 return false;
             }
 
+            //System.out.println("Should be at " + whereShouldIBe + " actually am at " + whereAmI);
             if (!Blocks.AIR.equals(BlockStateInterface.getBlock(ctx, whereAmI.down()))) {//do not skip if standing on air, because our position isn't stable to skip
                 for (int i = 0; i < pathPosition - 1 && i < path.length(); i++) {//this happens for example when you lag out and get teleported back a couple blocks
                     if (whereAmI.equals(path.positions().get(i))) {
@@ -373,15 +374,14 @@ public class PathExecutor implements IPathExecutor, Helper {
 
     private void sprintIfRequested() {
         // first and foremost, if allowSprint is off, or if we don't have enough hunger, don't try and sprint
-        if (!new CalculationContext(behavior.baritone).canSprint) {
+        if (!new CalculationContext(behavior.baritone).canSprint()) {
             behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
             ctx.player().setSprinting(false);
             return;
         }
 
         // if the movement requested sprinting, then we're done
-        if (behavior.baritone.getInputOverrideHandler().isInputForcedDown(Input.SPRINT)) {
-            behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
+        if (behavior.baritone.getInputOverrideHandler().isInputForcedDown(mc.gameSettings.keyBindSprint)) {
             if (!ctx.player().isSprinting()) {
                 ctx.player().setSprinting(true);
             }

src/main/java/baritone/process/FollowProcess.java

@@ -57,6 +57,7 @@ public final class FollowProcess extends BaritoneProcessHelper implements IFollo
     }
 
     private Goal towards(Entity following) {
+        // lol this is trashy but it works
         BlockPos pos;
         if (Baritone.settings().followOffsetDistance.get() == 0) {
             pos = new BlockPos(following);
@@ -78,7 +79,7 @@ public final class FollowProcess extends BaritoneProcessHelper implements IFollo
         if (entity.equals(ctx.player())) {
             return false;
         }
-        return ctx.world().loadedEntityList.contains(entity);
+        return ctx.world().loadedEntityList.contains(entity) || ctx.world().playerEntities.contains(entity);
     }
 
     private void scanWorld() {

src/main/java/baritone/process/GetToBlockProcess.java

@@ -154,4 +154,4 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
         }
         return block == Blocks.CRAFTING_TABLE || block == Blocks.FURNACE || block == Blocks.ENDER_CHEST || block == Blocks.CHEST || block == Blocks.TRAPPED_CHEST;
     }
-}
+}

src/main/java/baritone/process/MineProcess.java

@@ -39,6 +39,7 @@ import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraft.world.chunk.EmptyChunk;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -209,7 +210,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
         //long b = System.currentTimeMillis();
         for (Block m : mining) {
             if (CachedChunk.BLOCKS_TO_KEEP_TRACK_OF.contains(m)) {
-                locs.addAll(ctx.worldData.getCachedWorld().getLocationsOf(ChunkPacker.blockToString(m), 1, ctx.getBaritone().getPlayerContext().playerFeet().getX(), ctx.getBaritone().getPlayerContext().playerFeet().getZ(), 2));
+                locs.addAll(ctx.worldData().getCachedWorld().getLocationsOf(ChunkPacker.blockToString(m), 1, ctx.getBaritone().getPlayerContext().playerFeet().getX(), ctx.getBaritone().getPlayerContext().playerFeet().getZ(), 2));
             } else {
                 uninteresting.add(m);
             }
@@ -248,17 +249,16 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
     }
 
     public static List<BlockPos> prune(CalculationContext ctx, List<BlockPos> locs2, List<Block> mining, int max) {
-        List<BlockPos> dropped = droppedItemsScan(mining, ctx.world);
+        List<BlockPos> dropped = droppedItemsScan(mining, ctx.world());
         List<BlockPos> locs = locs2
                 .stream()
                 .distinct()
 
                 // remove any that are within loaded chunks that aren't actually what we want
-
-                .filter(pos -> !ctx.bsi.worldContainsLoadedChunk(pos.getX(), pos.getZ()) || mining.contains(ctx.getBlock(pos.getX(), pos.getY(), pos.getZ())) || dropped.contains(pos))
+                .filter(pos -> ctx.world().getChunk(pos) instanceof EmptyChunk || mining.contains(ctx.getBlock(pos.getX(), pos.getY(), pos.getZ())) || dropped.contains(pos))
 
                 // remove any that are implausible to mine (encased in bedrock, or touching lava)
-                .filter(pos -> MineProcess.plausibleToBreak(ctx.bsi, pos))
+                .filter(pos -> MineProcess.plausibleToBreak(ctx.bsi(), pos))
 
                 .sorted(Comparator.comparingDouble(ctx.getBaritone().getPlayerContext().playerFeet()::distanceSq))
                 .collect(Collectors.toList());

src/main/java/baritone/utils/BaritoneAutoTest.java

@@ -32,15 +32,6 @@ import net.minecraft.world.GameType;
 import net.minecraft.world.WorldSettings;
 import net.minecraft.world.WorldType;
 
-/**
- * Responsible for automatically testing Baritone's pathing algorithm by automatically creating a world with a specific
- * seed, setting a specified goal, and only allowing a certain amount of ticks to pass before the pathing test is
- * considered a failure. In order to test locally, docker may be used, or through an IDE: Create a run config which runs
- * in a separate directory from the primary one (./run), and set the enrivonmental variable {@code BARITONE_AUTO_TEST}
- * to {@code true}.
- *
- * @author leijurv, Brady
- */
 public class BaritoneAutoTest implements AbstractGameEventListener, Helper {
 
     public static final BaritoneAutoTest INSTANCE = new BaritoneAutoTest();

src/main/java/baritone/utils/BaritoneProcessHelper.java

@@ -23,10 +23,16 @@ import baritone.api.utils.IPlayerContext;
 
 public abstract class BaritoneProcessHelper implements IBaritoneProcess, Helper {
 
+    public static final double DEFAULT_PRIORITY = 0;
+
     protected final Baritone baritone;
     protected final IPlayerContext ctx;
     private final double priority;
 
+    public BaritoneProcessHelper(Baritone baritone) {
+        this(baritone, DEFAULT_PRIORITY);
+    }
+
     public BaritoneProcessHelper(Baritone baritone, double priority) {
         this.baritone = baritone;
         this.ctx = baritone.getPlayerContext();

src/main/java/baritone/utils/BlockBreakHelper.java

@@ -17,6 +17,8 @@
 
 package baritone.utils;
 
+import baritone.Baritone;
+import baritone.api.BaritoneAPI;
 import baritone.api.utils.IPlayerContext;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
@@ -29,6 +31,11 @@ import net.minecraft.util.math.RayTraceResult;
  */
 public final class BlockBreakHelper implements Helper {
 
+    /**
+     * The last block that we tried to break, if this value changes
+     * between attempts, then we re-initialize the breaking process.
+     */
+    private BlockPos lastBlock;
     private boolean didBreakLastTick;
 
     private IPlayerContext playerContext;
@@ -38,20 +45,42 @@ public final class BlockBreakHelper implements Helper {
     }
 
     public void tryBreakBlock(BlockPos pos, EnumFacing side) {
+        if (!pos.equals(lastBlock)) {
+            playerContext.playerController().clickBlock(pos, side);
+        }
         if (playerContext.playerController().onPlayerDamageBlock(pos, side)) {
             playerContext.player().swingArm(EnumHand.MAIN_HAND);
         }
+        lastBlock = pos;
     }
 
     public void stopBreakingBlock() {
-        // The player controller will never be null, but the player can be
-        if (playerContext.player() != null) {
+        if (playerContext.playerController() != null) {
             playerContext.playerController().resetBlockRemoving();
         }
+        lastBlock = null;
     }
 
+    private boolean fakeBreak() {
+        if (playerContext != BaritoneAPI.getProvider().getPrimaryBaritone().getPlayerContext()) {
+            // for a non primary player, we need to fake break always, CLICK_LEFT has no effect
+            return true;
+        }
+        if (!Baritone.settings().leftClickWorkaround.get()) {
+            // if this setting is false, we CLICK_LEFT regardless of gui status
+            return false;
+        }
+        return mc.currentScreen != null;
+    }
+
+    public boolean tick(boolean isLeftClick) {
+        if (!fakeBreak()) {
+            if (didBreakLastTick) {
+                stopBreakingBlock();
+            }
+            return isLeftClick;
+        }
 
-    public void tick(boolean isLeftClick) {
         RayTraceResult trace = playerContext.objectMouseOver();
         boolean isBlockTrace = trace != null && trace.typeOfHit == RayTraceResult.Type.BLOCK;
 
@@ -62,5 +91,6 @@ public final class BlockBreakHelper implements Helper {
             stopBreakingBlock();
             didBreakLastTick = false;
         }
+        return false; // fakeBreak is true so no matter what we aren't forcing CLICK_LEFT
     }
 }

src/main/java/baritone/utils/BlockStateInterface.java

@@ -40,15 +40,12 @@ import net.minecraft.world.chunk.Chunk;
  */
 public class BlockStateInterface {
 
-    public static int numBlockStateLookups = 0;
-    public static int numTimesChunkSucceeded = 0;
     private final Long2ObjectMap<Chunk> loadedChunks;
     private final WorldData worldData;
+
     private Chunk prev = null;
     private CachedRegion prevCached = null;
 
-    private final boolean useTheRealWorld;
-
     private static final IBlockState AIR = Blocks.AIR.getDefaultState();
 
     public BlockStateInterface(IPlayerContext ctx) {
@@ -67,7 +64,6 @@ public class BlockStateInterface {
         } else {
             this.loadedChunks = worldLoaded; // this will only be used on the main thread
         }
-        this.useTheRealWorld = !Baritone.settings().pathThroughCachedOnly.get();
         if (!Minecraft.getMinecraft().isCallingFromMinecraftThread()) {
             throw new IllegalStateException();
         }
@@ -92,13 +88,13 @@ public class BlockStateInterface {
     }
 
     public IBlockState get0(int x, int y, int z) { // Mickey resigned
-        numBlockStateLookups++;
+
         // Invalid vertical position
         if (y < 0 || y >= 256) {
             return AIR;
         }
 
-        if (useTheRealWorld) {
+        if (!Baritone.settings().pathThroughCachedOnly.get()) {
             Chunk cached = prev;
             // there's great cache locality in block state lookups
             // generally it's within each movement
@@ -107,7 +103,6 @@ public class BlockStateInterface {
             // which is a Long2ObjectOpenHashMap.get
             // see issue #113
             if (cached != null && cached.x == x >> 4 && cached.z == z >> 4) {
-                numTimesChunkSucceeded++;
                 return cached.getBlockState(x, y, z);
             }
             Chunk chunk = loadedChunks.get(ChunkPos.asLong(x >> 4, z >> 4));

src/main/java/baritone/utils/ExampleBaritoneControl.java

@@ -201,6 +201,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
             } else if (pathingBehavior.isPathing()) {
                 logDirect("Currently executing a path. Please cancel it first.");
             } else {
+                baritone.fitmc();
                 customGoalProcess.setGoalAndPath(pathingBehavior.getGoal());
             }
             return true;

src/main/java/baritone/utils/InputOverrideHandler.java

@@ -18,15 +18,12 @@
 package baritone.utils;
 
 import baritone.Baritone;
-import baritone.api.BaritoneAPI;
 import baritone.api.event.events.TickEvent;
 import baritone.api.utils.IInputOverrideHandler;
 import baritone.api.utils.input.Input;
 import baritone.behavior.Behavior;
-import net.minecraft.client.Minecraft;
 import net.minecraft.client.settings.KeyBinding;
-import net.minecraft.util.MovementInput;
-import net.minecraft.util.MovementInputFromOptions;
+import org.lwjgl.input.Keyboard;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -60,18 +57,8 @@ public final class InputOverrideHandler extends Behavior implements IInputOverri
      * @return Whether or not it is being forced down
      */
     @Override
-    public final Boolean isInputForcedDown(KeyBinding key) {
-        Input input = Input.getInputForBind(key);
-        if (input == null || !inControl()) {
-            return null;
-        }
-        if (input == Input.CLICK_LEFT) {
-            return false;
-        }
-        if (input == Input.CLICK_RIGHT) {
-            return isInputForcedDown(Input.CLICK_RIGHT);
-        }
-        return null;
+    public final boolean isInputForcedDown(KeyBinding key) {
+        return isInputForcedDown(Input.getInputForBind(key));
     }
 
     /**
@@ -104,25 +91,29 @@ public final class InputOverrideHandler extends Behavior implements IInputOverri
         this.inputForceStateMap.clear();
     }
 
+    @Override
+    public final void onProcessKeyBinds() {
+        // Simulate the key being held down this tick
+        for (Input input : Input.values()) {
+            KeyBinding keyBinding = input.getKeyBinding();
+
+            if (isInputForcedDown(keyBinding) && !keyBinding.isKeyDown()) {
+                int keyCode = keyBinding.getKeyCode();
+
+                if (keyCode < Keyboard.KEYBOARD_SIZE) {
+                    KeyBinding.onTick(keyCode < 0 ? keyCode + 100 : keyCode);
+                }
+            }
+        }
+    }
+
     @Override
     public final void onTick(TickEvent event) {
         if (event.getType() == TickEvent.Type.OUT) {
             return;
         }
-        blockBreakHelper.tick(isInputForcedDown(Input.CLICK_LEFT));
-
-        MovementInput desired = inControl()
-                ? new PlayerMovementInput(this)
-                : new MovementInputFromOptions(Minecraft.getMinecraft().gameSettings);
-
-        if (ctx.player().movementInput.getClass() != desired.getClass()) {
-            ctx.player().movementInput = desired; // only set it if it was previously incorrect
-            // gotta do it this way, or else it constantly thinks you're beginning a double tap W sprint lol
-        }
-    }
-
-    private boolean inControl() {
-        return baritone.getPathingBehavior().isPathing() || baritone != BaritoneAPI.getProvider().getPrimaryBaritone();
+        boolean stillClick = blockBreakHelper.tick(isInputForcedDown(Input.CLICK_LEFT));
+        setInputForceState(Input.CLICK_LEFT, stillClick);
     }
 
     public BlockBreakHelper getBlockBreakHelper() {

src/main/java/baritone/utils/PathingControlManager.java

@@ -29,7 +29,7 @@ import baritone.pathing.path.PathExecutor;
 import net.minecraft.util.math.BlockPos;
 
 import java.util.*;
-import java.util.stream.Stream;
+import java.util.stream.Collectors;
 
 public class PathingControlManager implements IPathingControlManager {
     private final Baritone baritone;
@@ -64,7 +64,8 @@ public class PathingControlManager implements IPathingControlManager {
         command = null;
         for (IBaritoneProcess proc : processes) {
             proc.onLostControl();
-            if (proc.isActive() && !proc.isTemporary()) { // it's okay only for a temporary thing (like combat pause) to maintain control even if you say to cancel
+            if (proc.isActive() && !proc.isTemporary()) { // it's okay for a temporary thing (like combat pause) to maintain control even if you say to cancel
+                // but not for a non temporary thing
                 throw new IllegalStateException(proc.displayName());
             }
         }
@@ -82,12 +83,11 @@ public class PathingControlManager implements IPathingControlManager {
 
     public void preTick() {
         inControlLastTick = inControlThisTick;
-        PathingBehavior p = baritone.getPathingBehavior();
-        command = executeProcesses();
+        command = doTheStuff();
         if (command == null) {
-            p.cancelSegmentIfSafe();
             return;
         }
+        PathingBehavior p = baritone.getPathingBehavior();
         switch (command.commandType) {
             case REQUEST_PAUSE:
                 p.requestPause();
@@ -170,30 +170,32 @@ public class PathingControlManager implements IPathingControlManager {
     }
 
 
-    public PathingCommand executeProcesses() {
-        Stream<IBaritoneProcess> inContention = processes.stream()
-                .filter(IBaritoneProcess::isActive)
-                .sorted(Comparator.comparingDouble(IBaritoneProcess::priority).reversed());
-
-
-        Iterator<IBaritoneProcess> iterator = inContention.iterator();
-        while (iterator.hasNext()) {
-            IBaritoneProcess proc = iterator.next();
-
-            PathingCommand exec = proc.onTick(Objects.equals(proc, inControlLastTick) && baritone.getPathingBehavior().calcFailedLastTick(), baritone.getPathingBehavior().isSafeToCancel());
-            if (exec == null) {
-                if (proc.isActive()) {
-                    throw new IllegalStateException(proc.displayName() + " returned null PathingCommand");
+    public PathingCommand doTheStuff() {
+        List<IBaritoneProcess> inContention = processes.stream().filter(IBaritoneProcess::isActive).sorted(Comparator.comparingDouble(IBaritoneProcess::priority)).collect(Collectors.toList());
+        boolean found = false;
+        boolean cancelOthers = false;
+        PathingCommand exec = null;
+        for (int i = inContention.size() - 1; i >= 0; i--) { // truly a gamer moment
+            IBaritoneProcess proc = inContention.get(i);
+            if (found) {
+                if (cancelOthers) {
+                    proc.onLostControl();
                 }
-                proc.onLostControl();
             } else {
-                inControlThisTick = proc;
-                if (!proc.isTemporary()) {
-                    iterator.forEachRemaining(IBaritoneProcess::onLostControl);
+                exec = proc.onTick(Objects.equals(proc, inControlLastTick) && baritone.getPathingBehavior().calcFailedLastTick(), baritone.getPathingBehavior().isSafeToCancel());
+                if (exec == null) {
+                    if (proc.isActive()) {
+                        throw new IllegalStateException(proc.displayName());
+                    }
+                    proc.onLostControl();
+                    continue;
                 }
-                return exec;
+                //System.out.println("Executing command " + exec.commandType + " " + exec.goal + " from " + proc.displayName());
+                inControlThisTick = proc;
+                found = true;
+                cancelOthers = !proc.isTemporary();
             }
         }
-        return null;
+        return exec;
     }
 }

src/main/java/baritone/utils/PlayerMovementInput.java

@@ -1,57 +0,0 @@
-/*
- * 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.utils;
-
-import baritone.api.utils.input.Input;
-import net.minecraft.util.MovementInput;
-
-public class PlayerMovementInput extends MovementInput {
-    private final InputOverrideHandler handler;
-
-    public PlayerMovementInput(InputOverrideHandler handler) {
-        this.handler = handler;
-    }
-
-    public void updatePlayerMoveState() {
-        this.moveStrafe = 0.0F;
-        this.moveForward = 0.0F;
-
-        jump = handler.isInputForcedDown(Input.JUMP); // oppa
-
-        if (this.forwardKeyDown = handler.isInputForcedDown(Input.MOVE_FORWARD)) {
-            this.moveForward++;
-        }
-
-        if (this.backKeyDown = handler.isInputForcedDown(Input.MOVE_BACK)) {
-            this.moveForward--;
-        }
-
-        if (this.leftKeyDown = handler.isInputForcedDown(Input.MOVE_LEFT)) {
-            this.moveStrafe++;
-        }
-
-        if (this.rightKeyDown = handler.isInputForcedDown(Input.MOVE_RIGHT)) {
-            this.moveStrafe--;
-        }
-
-        if (this.sneak = handler.isInputForcedDown(Input.SNEAK)) {
-            this.moveStrafe *= 0.3D;
-            this.moveForward *= 0.3D;
-        }
-    }
-}

src/main/java/baritone/utils/ToolSet.java

@@ -103,7 +103,7 @@ public class ToolSet {
         IBlockState blockState = b.getDefaultState();
         for (byte i = 0; i < 9; i++) {
             ItemStack itemStack = player.inventory.getStackInSlot(i);
-            double v = calculateSpeedVsBlock(itemStack, blockState);
+            double v = calculateStrVsBlock(itemStack, blockState);
             if (v > value) {
                 value = v;
                 best = i;
@@ -128,7 +128,7 @@ public class ToolSet {
      */
     private double getBestDestructionTime(Block b) {
         ItemStack stack = player.inventory.getStackInSlot(getBestSlot(b));
-        return calculateSpeedVsBlock(stack, b.getDefaultState());
+        return calculateStrVsBlock(stack, b.getDefaultState());
     }
 
     /**
@@ -138,7 +138,7 @@ public class ToolSet {
      * @param state the blockstate to be mined
      * @return how long it would take in ticks
      */
-    public static double calculateSpeedVsBlock(ItemStack item, IBlockState state) {
+    public static double calculateStrVsBlock(ItemStack item, IBlockState state) {
         float hardness = state.getBlockHardness(null, null);
         if (hardness < 0) {
             return -1;
@@ -154,10 +154,11 @@ public class ToolSet {
 
         speed /= hardness;
         if (state.getMaterial().isToolNotRequired() || (!item.isEmpty() && item.canHarvestBlock(state))) {
-            return speed / 30;
+            speed /= 30;
         } else {
-            return speed / 100;
+            speed /= 100;
         }
+        return speed;
     }
 
     /**
@@ -179,7 +180,7 @@ public class ToolSet {
                     speed *= 0.09;
                     break;
                 case 2:
-                    speed *= 0.0027; // you might think that 0.09*0.3 = 0.027 so that should be next, that would make too much sense. it's 0.0027.
+                    speed *= 0.0027;
                     break;
                 default:
                     speed *= 0.00081;

src/main/java/baritone/utils/pathing/Favoring.java

@@ -23,12 +23,16 @@ import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.IPlayerContext;
 import it.unimi.dsi.fastutil.longs.Long2DoubleOpenHashMap;
 
+import java.util.List;
+
 public final class Favoring {
+    private List<Avoidance> avoidances;
     private final Long2DoubleOpenHashMap favorings;
 
     public Favoring(IPlayerContext ctx, IPath previous) {
         this(previous);
-        for (Avoidance avoid : Avoidance.create(ctx)) {
+        avoidances = Avoidance.create(ctx);
+        for (Avoidance avoid : avoidances) {
             avoid.applySpherical(favorings);
         }
         System.out.println("Favoring size: " + favorings.size());

src/main/java/baritone/utils/pathing/PathBase.java

@@ -26,7 +26,7 @@ import net.minecraft.util.math.BlockPos;
 
 public abstract class PathBase implements IPath {
     @Override
-    public PathBase cutoffAtLoadedChunks(Object bsi0) { // <-- cursed cursed cursed
+    public PathBase cutoffAtLoadedChunks(Object bsi0) {
         BlockStateInterface bsi = (BlockStateInterface) bsi0;
         for (int i = 0; i < positions().size(); i++) {
             BlockPos pos = positions().get(i);

src/main/java/baritone/utils/player/PrimaryPlayerContext.java

@@ -20,9 +20,9 @@ package baritone.utils.player;
 import baritone.api.BaritoneAPI;
 import baritone.api.cache.IWorldData;
 import baritone.api.utils.IPlayerContext;
-import baritone.api.utils.IPlayerController;
 import baritone.utils.Helper;
 import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.world.World;
 
@@ -42,8 +42,8 @@ public enum PrimaryPlayerContext implements IPlayerContext, Helper {
     }
 
     @Override
-    public IPlayerController playerController() {
-        return PrimaryPlayerController.INSTANCE;
+    public PlayerControllerMP playerController() {
+        return mc.playerController;
     }
 
     @Override

src/main/java/baritone/utils/player/PrimaryPlayerController.java

@@ -1,61 +0,0 @@
-/*
- * 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.utils.player;
-
-import baritone.api.utils.IPlayerController;
-import baritone.utils.Helper;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.ClickType;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.GameType;
-
-/**
- * @author Brady
- * @since 12/14/2018
- */
-public enum PrimaryPlayerController implements IPlayerController, Helper {
-
-    INSTANCE;
-
-    @Override
-    public boolean onPlayerDamageBlock(BlockPos pos, EnumFacing side) {
-        return mc.playerController.onPlayerDamageBlock(pos, side);
-    }
-
-    @Override
-    public void resetBlockRemoving() {
-        mc.playerController.resetBlockRemoving();
-    }
-
-    @Override
-    public ItemStack windowClick(int windowId, int slotId, int mouseButton, ClickType type, EntityPlayer player) {
-        return mc.playerController.windowClick(windowId, slotId, mouseButton, type, player);
-    }
-
-    @Override
-    public void setGameType(GameType type) {
-        mc.playerController.setGameType(type);
-    }
-
-    @Override
-    public GameType getGameType() {
-        return mc.playerController.getCurrentGameType();
-    }
-}

src/main/java/baritone/utils/resource/BaritoneResourcePack.java

@@ -0,0 +1,70 @@
+/*
+ * 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.utils.resource;
+
+import net.minecraft.client.resources.IResourcePack;
+import net.minecraft.client.resources.data.IMetadataSection;
+import net.minecraft.client.resources.data.MetadataSerializer;
+import net.minecraft.util.ResourceLocation;
+
+import java.awt.image.BufferedImage;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * @author Brady
+ * @since 12/15/2018
+ */
+@SuppressWarnings("NullableProblems")
+public class BaritoneResourcePack implements IResourcePack {
+
+    @Override
+    public InputStream getInputStream(ResourceLocation location) {
+        return getResourceStream(location);
+    }
+
+    @Override
+    public boolean resourceExists(ResourceLocation location) {
+        return getResourceStream(location) != null;
+    }
+
+    @Override
+    public Set<String> getResourceDomains() {
+        return Collections.singleton("baritone");
+    }
+
+    @Override
+    public <T extends IMetadataSection> T getPackMetadata(MetadataSerializer metadataSerializer, String metadataSectionName) {
+        return null;
+    }
+
+    @Override
+    public BufferedImage getPackImage() {
+        return null;
+    }
+
+    @Override
+    public String getPackName() {
+        return "baritone";
+    }
+
+    private InputStream getResourceStream(ResourceLocation location) {
+        return BaritoneResourcePack.class.getResourceAsStream("/assets/" + location.getNamespace() + "/" + location.getPath());
+    }
+}

src/main/resources/assets/baritone/sounds.json

@@ -0,0 +1,10 @@
+{
+  "fitmc_intro": {
+    "category": "master",
+    "sounds": [
+      {
+        "name": "baritone:fitmc/intro"
+      }
+    ]
+  }
+}

src/test/java/baritone/cache/CachedRegionTest.java

@@ -44,4 +44,4 @@ public class CachedRegionTest {
             }
         }
     }
-}
+}

src/test/java/baritone/pathing/calc/openset/OpenSetsTest.java

@@ -167,4 +167,4 @@ public class OpenSetsTest {
             assertTrue(set.isEmpty());
         }
     }
-}
+}

src/test/java/baritone/pathing/goals/GoalGetToBlockTest.java

@@ -47,4 +47,4 @@ public class GoalGetToBlockTest {
         }
         assertTrue(acceptableOffsets.toString(), acceptableOffsets.isEmpty());
     }
-}
+}

src/test/java/baritone/pathing/movement/ActionCostsTest.java

@@ -48,4 +48,4 @@ public class ActionCostsTest {
         return fallDistance;
     }
 
-}
+}

src/test/java/baritone/utils/pathing/BetterBlockPosTest.java

@@ -136,4 +136,4 @@ public class BetterBlockPosTest {
         long after2 = System.nanoTime() / 1000000L;
         System.out.println((after1 - before1) + " " + (after2 - before2));
     }
-}
+}

src/test/java/baritone/utils/pathing/PathingBlockTypeTest.java

@@ -29,4 +29,4 @@ public class PathingBlockTypeTest {
             assertTrue(type == PathingBlockType.fromBits(bits[0], bits[1]));
         }
     }
-}
+}