v1.1.6

public init
fix weird angle forcing behavior, fixes #341
2019-02-19 14:53:43 -08:00 · 2019-02-19 14:43:48 -08:00 · 2019-02-19 14:29:08 -08:00 · 2019-02-19 13:28:58 -08:00 · 2019-02-19 12:55:58 -08:00 · 2019-02-19 12:44:29 -08:00
51 changed files with 1131 additions and 323 deletions
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -22,9 +22,9 @@ Baritone uses A*, with some modifications:
 - **Backtrack cost favoring** While calculating the next segment, Baritone favors backtracking its current segment. The cost is decreased heavily, but is still positive (this won't cause it to backtrack if it doesn't need to). This allows it to splice and jump onto the next segment as early as possible, if the next segment begins with a backtrack of the current one. <a href="https://www.youtube.com/watch?v=CGiMcb8-99Y">Example</a>
 - **Backtrack detection and pausing** While path calculation happens on a separate thread, the main game thread has access to the latest node considered, and the best path so far (those are rendered light blue and dark blue respectively). When the current best path (rendered dark blue) passes through the player's current position on the current path segment, path execution is paused (if it's safe to do so), because there's no point continuing forward if we're about to turn around and go back that same way. Note that the current best path as reported by the path calculation thread takes into account the incremental cost backoff system, so it's accurate to what the path calculation thread will actually pick once it finishes.

-# Configuring Baritone
-All the settings and documentation are <a href="https://github.com/cabaletta/baritone/blob/master/src/api/java/baritone/api/Settings.java">here</a>.
-To change a boolean setting, just say its name in chat (for example saying `allowBreak` toggles whether Baritone will consider breaking blocks). For a numeric setting, say its name then the new value (like `pathTimeoutMS 250`). It's case insensitive.
+# Chat control
+
+- [Baritone chat control usage](USAGE.md)

 # Goals
 The pathing goal can be set to any of these options:
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,7 +1,9 @@
 # Integration between Baritone and Impact
 Impact 4.4 has Baritone included.

-These instructions apply to Impact 4.3 (and potentially other "hacked clients").
+These instructions apply to Impact 4.3.
+
+For Forge follow the instructions in [Setup](SETUP.md).

 To run Baritone on Vanilla, just follow the instructions in the README (it's `./gradlew runClient`).

@@ -18,11 +20,11 @@ There are two methods of acquiring a build of Baritone
 ### Official Release (Not always up to date)
 https://github.com/cabaletta/baritone/releases

-For Impact 4.3, there is no Baritone integration yet, so you will want `baritone-standalone-X.Y.Z.jar`.
+For Impact 4.3, there is no Baritone integration yet, so you will want `baritone-standalone-X.Y.Z.jar`. **For the rest of this guide, replace `X.Y.Z` with the actual numeric version you are using.**

 Any official release will be GPG signed by leijurv (44A3EA646EADAC6A) and ZeroMemes (73A788379A197567). Please verify that the hash of the file you download is in `checksums.txt` and that `checksums_signed.asc` is a valid signature by those two public keys of `checksums.txt`. 

-The build is fully deterministic and reproducible, and you can verify Travis did it properly by running `docker build --no-cache -t cabaletta/baritone . && docker run --rm cabaletta/baritone cat /code/dist/checksums.txt` yourself and comparing the shasum. This works identically on Travis, Mac, and Linux (if you have docker on Windows, I'd be grateful if you could let me know if it works there too).
+The build is fully deterministic and reproducible, and you can verify Travis did it properly by running `docker build --no-cache -t cabaletta/baritone .` yourself and comparing the shasum. This works identically on Travis, Mac, and Linux (if you have docker on Windows, I'd be grateful if you could let me know if it works there too).

 ### Building Baritone yourself
 You can either build Baritone through a command line or through IntelliJ's UI, information on that can be found [here](SETUP.md#building).
@@ -36,7 +38,7 @@ putting baritone.
  - ``cabaletta``
    - ``baritone``
      - ``X.Y.Z``
- - Copy the build of Baritone that was acquired earlier, and place it into the ``X.Y.Z`` folder
+ - Copy the build of Baritone that was acquired earlier, and place it into the ``X.Y.Z`` folder, renamed like so:
   - The full path should look like ``<Minecraft>/libraries/cabaletta/baritone/X.Y.Z/baritone-X.Y.Z.jar``

 ## Modifying the Impact Profile JSON to run baritone
@@ -79,10 +81,10 @@ The final step is "registering" the Baritone library with Impact, so that it loa
    ```
 - Now find the ``"minecraftArguments": "..."`` text near the top.
 - At the very end of the quotes where it says ``--tweakClass clientapi.load.ClientTweaker"``, add on the following so it looks like:
-  - ``--tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweakerOptifine"``
+  - ``--tweakClass clientapi.load.ClientTweaker --tweakClass baritone.launch.BaritoneTweaker"``
 - If you didn't close your launcher for this step, restart it now.
 - You can now launch Impact 4.3 as normal, and Baritone should start up
 
 ## How to use Baritone
- Instructions on how to use Baritone are limited, and you may have to read a little bit of code (Really nothing much
-  just plain English), you can view that <a href="https://github.com/cabaletta/baritone#chat-control">here</a>.
+
+- [Baritone chat control usage](USAGE.md)
--- a/README.md
+++ b/README.md
@@ -11,6 +11,8 @@
 [![Pull Requests](https://img.shields.io/github/issues-pr/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/pulls/)
 ![Code size](https://img.shields.io/github/languages/code-size/cabaletta/baritone.svg)
 ![GitHub repo size](https://img.shields.io/github/repo-size/cabaletta/baritone.svg)
+![](https://tokei.rs/b1/github/cabaletta/baritone?category=code)
+![](https://tokei.rs/b1/github/cabaletta/baritone?category=files)
 [![Minecraft](https://img.shields.io/badge/MC-1.12.2-green.svg)](https://minecraft.gamepedia.com/1.12.2)
 [![GitHub contributors](https://img.shields.io/github/contributors/cabaletta/baritone.svg)](https://github.com/cabaletta/baritone/graphs/contributors/)
 [![GitHub commits](https://img.shields.io/github/commits-since/cabaletta/baritone/v1.0.0.svg)](https://github.com/cabaletta/baritone/commit/)
@@ -28,6 +30,10 @@ Baritone is the pathfinding system used in [Impact](https://impactdevelopment.gi
 This project is an updated version of [MineBot](https://github.com/leijurv/MineBot/),
 the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. Baritone focuses on reliability and particularly performance (it's over [30x faster](https://github.com/cabaletta/baritone/pull/180#issuecomment-423822928) than MineBot at calculating paths).

+Have committed at least once a day for the last 6 months =D 🦀
+
+1Leijurv3DWTrGAfmmiTphjhXLvQiHg7K2
+
 Here are some links to help to get started:

 - [Features](FEATURES.md)
@@ -38,10 +44,11 @@ Here are some links to help to get started:

 - [Javadocs](https://baritone.leijurv.com/)

-# Chat control
-[Defined Here](src/main/java/baritone/utils/ExampleBaritoneControl.java)
+- [Settings](https://baritone.leijurv.com/baritone/api/Settings.html#allowBreak)

-Quick start example: `thisway 1000` or `goal 70` to set the goal, `path` to actually start pathing. Also try `mine diamond_ore`. `cancel` to cancel.
+# Chat control
+
+- [Baritone chat control usage](USAGE.md)

 # API example

@@ -56,7 +63,7 @@ BaritoneAPI.getProvider().getPrimaryBaritone().getCustomGoalProcess().setGoalAnd

 ## Can I use Baritone as a library in my custom utility client?

-Sure! (As long as usage is in compliance with the LGPL 3 License)
+That's what it's for, sure! (As long as usage is in compliance with the LGPL 3 License)

 ## How is it so fast?

--- a/SETUP.md
+++ b/SETUP.md
@@ -1,5 +1,32 @@
 # Setup

+## Prebuilt
+(not always completely up to date with latest features)
+
+Download from the [Releases](https://github.com/cabaletta/baritone/releases)
+
+The Forge releases can simply be added as a Forge mod.
+
+If another one of your Forge mods has a Baritone integration, you want `baritone-api-forge-VERSION.jar`. Otherwise, you want `baritone-standalone-forge-VERSION.jar`
+
+Previously (Baritone v1.1.2 and below), it was not fully compatible with the latest version of Forge. `freeLook` was broken in Forge 14.23.4.2744. Forge 14.23.4.2743 or **older** worked with Baritone v1.1.2 and lower. Newer versions of Forge "worked", sort of, but Baritone's movement became unreliable and `freeLook` must be off.
+
+## Artifacts
+
+Building Baritone will result in 5 artifacts created in the ``dist`` directory. These are the same as the artifacts created in the [releases](https://github.com/cabaletta/baritone/releases).
+
+- **API**: Only the non-api packages are obfuscated. This should be used in environments where other mods would like to use Baritone's features.
+- **Forge API**: Same as API, but packaged for Forge. This should be used where another mod has a Baritone integration.
+- **Standalone**: Everything is obfuscated. This should be used in environments where there are no other mods present that would like to use Baritone's features.
+- **Forge Standalone**: Same as Standalone, but packaged for Forge. This should be used when Baritone is your only Forge mod, or none of your other Forge mods integrate with Baritone.
+- **Unoptimized**: Nothing is obfuscated. This shouldn't be used ever in production.
+
+## More Info
+To replace out Impact 4.4's Baritone build with a customized one, switch to the `impact4.4-compat` branch, build Baritone as above then copy `dist/baritone-api-$VERSION$.jar` into `minecraft/libraries/cabaletta/baritone-api/1.0.0/baritone-api-1.0.0.jar`, replacing the jar that was previously there. You also need to edit `minecraft/versions/1.12.2-Impact_4.4/1.12.2-Impact_4.4.json`, find the line `"name": "cabaletta:baritone-api:1.0.0"`, remove the comma from the end, and entirely remove the line that's immediately after (starts with `"url"`). 
+
+Impact 4.4 **only** works with builds from the quite outdated `impact4.4-compat` branch. If you must have the latest Baritone features with Impact, and can't wait for 4.5, consider creating a standalone (non forge) build then adding it to Impact 4.**3** via the instructions in [Install](INSTALL.md).
+
+## Build it yourself
 - Clone or download Baritone

  ![Image](https://i.imgur.com/kbqBtoN.png)
@@ -65,15 +92,4 @@ $ gradlew build

  ![Image](https://i.imgur.com/PE6r9iN.png)

- Right click on **build** and press **Run**
-
-## Artifacts
-
-Building Baritone will result in 3 artifacts created in the ``dist`` directory.
-
- **API**: Only the non-api packages are obfuscated. This should be used in environments where other mods would like to use Baritone's features.
- **Standalone**: Everything is obfuscated. This should be used in environments where there are no other mods present that would like to use Baritone's features.
- **Unoptimized**: Nothing is obfuscated. This shouldn't be used ever in production.
-
-## More Info
-To replace out Impact 4.4's Baritone build with a customized one, switch to the `impact4.4-compat` branch, build Baritone as above then copy `dist/baritone-api-$VERSION$.jar` into `minecraft/libraries/cabaletta/baritone-api/1.0.0/baritone-api-1.0.0.jar`, replacing the jar that was previously there. You also need to edit `minecraft/versions/1.12.2-Impact_4.4/1.12.2-Impact_4.4.json`, find the line `"name": "cabaletta:baritone-api:1.0.0"`, remove the comma from the end, and entirely remove the line that's immediately after (starts with `"url"`). 
+- Double click on **build** to run it
--- a/USAGE.md
+++ b/USAGE.md
@@ -0,0 +1,79 @@
+(assuming you already have Baritone [set up](SETUP.md))
+
+# Prefix
+
+Baritone commands can by default be typed in the chatbox. However if you make a typo, like typing "gola 10000 10000" instead of goal it goes into public chat, which is bad.
+
+Therefore you can use a prefix before your messages.
+
+On Baritone v1.1.0 and newer: The prefix is `#` by default. Anything beginning with `#` isn't sent, and is only interpreted by Baritone.
+For older than v1.1.0, `#` must be enabled by toggling on the `prefix` setting.
+
+**Only** in Impact 4.4 is `.b` also a valid prefix. In 4.4, `#` does **not** work, neither does saying the commands directly in chat.
+
+Other clients like Kami and Asuna have their own custom things (like `-path`), and can disable direct chat control entirely.
+
+
+
+# Commands
+
+**All** of these commands may need a prefix before them, as above ^.
+
+`help` for (rudimentary) help. You can see what it says [here](https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java#L53).
+
+To toggle a boolean setting, just say its name in chat (for example saying `allowBreak` toggles whether Baritone will consider breaking blocks). For a numeric setting, say its name then the new value (like `primaryTimeoutMS 250`). It's case insensitive.
+
+
+
+
+Some common examples:
+- `thisway 1000` then `path` to go in the direction you're facing for a thousand blocks
+- `goal x y z` or `goal x z` or `goal y`, then `path` to go to a certain coordinate
+- `goal` to set the goal to your player's feet
+- `goal clear` to clear the goal
+- `cancel` or `stop` to stop everything
+- `goto portal` or `goto ender_chest` or `goto block_type` to go to a block. (in Impact, `.goto` is an alias for `.b goto` for the most part)
+- `mine diamond_ore` to mine diamond ore (turn on the setting `legitMine` to only mine ores that it can actually see. It will explore randomly around y=11 until it finds them.)
+- `follow playerName` to follow a player. `follow` to follow the entity you're looking at (only works if it hitting range). `followplayers` to follow any players in range (combine with Kill Aura for a fun time).
+- `save waypointName` to save a waypoint. `goto waypointName` to go to it.
+- `axis` to go to an axis or diagonal axis at y=120 (`axisHeight` is a configurable setting, defaults to 120).
+- `invert` to invert the current goal and path. This gets as far away from it as possible, instead of as close as possible. For example, do `goal` then `invert` to run as far as possible from where you're standing at the start.
+- `render` to rerender the world in case `renderCachedChunks` is being glitchy
+- `damn` daniel
+
+For the rest of the commands, you can take a look at the code [here](https://github.com/cabaletta/baritone/blob/master/src/main/java/baritone/utils/ExampleBaritoneControl.java).
+
+All the settings and documentation are <a href="https://github.com/cabaletta/baritone/blob/master/src/api/java/baritone/api/Settings.java">here</a>. If you find HTML easier to read than Javadoc, you can look <a href="https://baritone.leijurv.com/baritone/api/Settings.html#allowBreak">here</a>.
+
+There are about a hundred settings, but here are some fun / interesting / important ones that you might want to look at changing in normal usage of Baritone. The documentation for each can be found at the above links.
+- `allowBreak`
+- `allowSprint`
+- `allowPlace`
+- `allowParkour`
+- `allowParkourPlace`
+- `renderCachedChunks` (and `cachedChunksOpacity`) <-- very fun but you need a beefy computer
+- `avoidance`
+- `legitMine`
+- `followRadius`
+
+
+
+# Troubleshooting / common issues
+
+## Baritone highlights a block in green but gets completely stuck? Also I'm using Baritone with Future?
+Baritone is trying to right click to place a block there, but it can't since there's a conflicting mixin. Baritone can't force click right click when Future is also installed. Left click **does work** on recent Baritone even with Future, however. For now, turn off `allowPlace` and Baritone will only search for paths that don't require placing blocks to complete. `allowBreak` can remain on.
+
+## Why doesn't Baritone respond to any of my chat commands?
+This could be one of many things.
+
+First, make sure it's actually installed. An easy way to check is seeing if it created the folder `baritone` in your Minecraft folder.
+
+Second, make sure that you're using the prefix properly, and that chat control is enabled in the way you expect.
+
+For example, Impact disables direct chat control. (i.e. anything typed in chat without a prefix will be ignored and sent publicly). **This is a saved setting**, so if you run Impact once, `chatControl` will be off from then on, **even in other clients**.
+So you'll need to use the `#` prefix or edit `baritone/settings.txt` in your Minecraft folder to undo that (specifically, remove the line `chatControl false` then restart your client).
+
+
+## Why can I do `.goto x z` in Impact but nowhere else? Why can I do `-path to x z` in KAMI but nowhere else?
+These are custom commands that they added; those aren't from Baritone.
+The equivalent you're looking for is `goal x z` then `path`.
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@
 */

 group 'baritone'
-version '1.0.0-hotfix-2'
+version '1.1.6'

 buildscript {
    repositories {
@@ -95,7 +95,7 @@ dependencies {
 }

 mixin {
-    defaultObfuscationEnv notch
+    defaultObfuscationEnv searge
    add sourceSets.launch, 'mixins.baritone.refmap.json'
 }

@@ -113,6 +113,17 @@ jar {
    reproducibleFileOrder = true
 }

+jar {
+    manifest {
+        attributes(
+                'MixinConfigs': 'mixins.baritone.json',
+
+                'Implementation-Title': 'Baritone',
+                'Implementation-Version': version
+        )
+    }
+}
+
 task proguard(type: ProguardTask) {
    url 'https://downloads.sourceforge.net/project/proguard/proguard/6.0/proguard6.0.3.zip'
    extract 'proguard6.0.3/lib/proguard.jar'
--- a/buildSrc/src/main/java/baritone/gradle/task/BaritoneGradleTask.java
+++ b/buildSrc/src/main/java/baritone/gradle/task/BaritoneGradleTask.java
@@ -17,8 +17,6 @@

 package baritone.gradle.task;

-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
 import org.gradle.api.DefaultTask;

 import java.io.File;
@@ -26,7 +24,6 @@ import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.List;

 /**
 * @author Brady
@@ -34,8 +31,6 @@ import java.util.List;
 */
 class BaritoneGradleTask extends DefaultTask {

-    protected static final JsonParser PARSER = new JsonParser();
-
    protected static final String
            PROGUARD_ZIP                    = "proguard.zip",
            PROGUARD_JAR                    = "proguard.jar",
@@ -45,26 +40,28 @@ class BaritoneGradleTask extends DefaultTask {
            PROGUARD_STANDALONE_CONFIG      = "standalone.pro",
            PROGUARD_EXPORT_PATH            = "proguard_out.jar",

-            VERSION_MANIFEST = "version_manifest.json",
-
            TEMP_LIBRARY_DIR = "tempLibraries/",

-            ARTIFACT_STANDARD    = "%s-%s.jar",
-            ARTIFACT_UNOPTIMIZED = "%s-unoptimized-%s.jar",
-            ARTIFACT_API         = "%s-api-%s.jar",
-            ARTIFACT_STANDALONE  = "%s-standalone-%s.jar";
+            ARTIFACT_STANDARD         = "%s-%s.jar",
+            ARTIFACT_UNOPTIMIZED      = "%s-unoptimized-%s.jar",
+            ARTIFACT_API              = "%s-api-%s.jar",
+            ARTIFACT_STANDALONE       = "%s-standalone-%s.jar",
+            ARTIFACT_FORGE_API        = "%s-api-forge-%s.jar",
+            ARTIFACT_FORGE_STANDALONE = "%s-standalone-forge-%s.jar";

    protected String artifactName, artifactVersion;
-    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, proguardOut;
+    protected Path artifactPath, artifactUnoptimizedPath, artifactApiPath, artifactStandalonePath, artifactForgeApiPath, artifactForgeStandalonePath, proguardOut;

    protected void verifyArtifacts() throws IllegalStateException {
        this.artifactName = getProject().getName();
        this.artifactVersion = getProject().getVersion().toString();

-        this.artifactPath            = this.getBuildFile(formatVersion(ARTIFACT_STANDARD));
-        this.artifactUnoptimizedPath = this.getBuildFile(formatVersion(ARTIFACT_UNOPTIMIZED));
-        this.artifactApiPath         = this.getBuildFile(formatVersion(ARTIFACT_API));
-        this.artifactStandalonePath  = this.getBuildFile(formatVersion(ARTIFACT_STANDALONE));
+        this.artifactPath                = this.getBuildFile(formatVersion(ARTIFACT_STANDARD));
+        this.artifactUnoptimizedPath     = this.getBuildFile(formatVersion(ARTIFACT_UNOPTIMIZED));
+        this.artifactApiPath             = this.getBuildFile(formatVersion(ARTIFACT_API));
+        this.artifactStandalonePath      = this.getBuildFile(formatVersion(ARTIFACT_STANDALONE));
+        this.artifactForgeApiPath        = this.getBuildFile(formatVersion(ARTIFACT_FORGE_API));
+        this.artifactForgeStandalonePath = this.getBuildFile(formatVersion(ARTIFACT_FORGE_STANDALONE));

        this.proguardOut = this.getTemporaryFile(PROGUARD_EXPORT_PATH);

@@ -95,8 +92,4 @@ class BaritoneGradleTask extends DefaultTask {
    protected Path getBuildFile(String file) {
        return getRelativeFile("build/libs/" + file);
    }
-
-    protected JsonElement readJson(List<String> lines) {
-        return PARSER.parse(String.join("\n", lines));
-    }
 }
--- a/buildSrc/src/main/java/baritone/gradle/task/CreateDistTask.java
+++ b/buildSrc/src/main/java/baritone/gradle/task/CreateDistTask.java
@@ -42,9 +42,11 @@ public class CreateDistTask extends BaritoneGradleTask {
        super.verifyArtifacts();

        // Define the distribution file paths
-        Path api         = getRelativeFile("dist/" + formatVersion(ARTIFACT_API));
-        Path standalone  = getRelativeFile("dist/" + formatVersion(ARTIFACT_STANDALONE));
-        Path unoptimized = getRelativeFile("dist/" + formatVersion(ARTIFACT_UNOPTIMIZED));
+        Path api             = getRelativeFile("dist/" + formatVersion(ARTIFACT_API));
+        Path standalone      = getRelativeFile("dist/" + formatVersion(ARTIFACT_STANDALONE));
+        Path unoptimized     = getRelativeFile("dist/" + formatVersion(ARTIFACT_UNOPTIMIZED));
+        Path forgeApi        = getRelativeFile("dist/" + formatVersion(ARTIFACT_FORGE_API));
+        Path forgeStandalone = getRelativeFile("dist/" + formatVersion(ARTIFACT_FORGE_STANDALONE));

        // NIO will not automatically create directories
        Path dir = getRelativeFile("dist/");
@@ -53,12 +55,14 @@ public class CreateDistTask extends BaritoneGradleTask {
        }

        // Copy build jars to dist/
-        Files.copy(this.artifactApiPath,         api,         REPLACE_EXISTING);
-        Files.copy(this.artifactStandalonePath,  standalone,  REPLACE_EXISTING);
-        Files.copy(this.artifactUnoptimizedPath, unoptimized, REPLACE_EXISTING);
+        Files.copy(this.artifactApiPath,             api,             REPLACE_EXISTING);
+        Files.copy(this.artifactStandalonePath,      standalone,      REPLACE_EXISTING);
+        Files.copy(this.artifactUnoptimizedPath,     unoptimized,     REPLACE_EXISTING);
+        Files.copy(this.artifactForgeApiPath,        forgeApi,        REPLACE_EXISTING);
+        Files.copy(this.artifactForgeStandalonePath, forgeStandalone, REPLACE_EXISTING);

        // Calculate all checksums and format them like "shasum"
-        List<String> shasum = Stream.of(api, standalone, unoptimized)
+        List<String> shasum = Stream.of(api, forgeApi, standalone, forgeStandalone, unoptimized)
                .map(path -> sha1(path) + "  " + path.getFileName().toString())
                .collect(Collectors.toList());

--- a/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java
+++ b/buildSrc/src/main/java/baritone/gradle/task/ProguardTask.java
@@ -59,6 +59,8 @@ public class ProguardTask extends BaritoneGradleTask {

    private List<String> requiredLibraries;

+    private File mixin;
+
    @TaskAction
    protected void exec() throws Exception {
        super.verifyArtifacts();
@@ -79,7 +81,7 @@ public class ProguardTask extends BaritoneGradleTask {
            Files.delete(this.artifactUnoptimizedPath);
        }

-        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString());
+        Determinizer.determinize(this.artifactPath.toString(), this.artifactUnoptimizedPath.toString(), Optional.empty());
    }

    private void downloadProguard() throws Exception {
@@ -173,10 +175,16 @@ public class ProguardTask extends BaritoneGradleTask {
            // Find the library jar file, and copy it to tempLibraries
            for (File file : pair.getLeft().files(pair.getRight())) {
                if (file.getName().startsWith(lib)) {
+                    if (lib.contains("mixin")) {
+                        mixin = file;
+                    }
                    Files.copy(file.toPath(), getTemporaryFile("tempLibraries/" + lib + ".jar"), REPLACE_EXISTING);
                }
            }
        }
+        if (mixin == null) {
+            throw new IllegalStateException("Unable to find mixin jar");
+        }
    }

    // a bunch of epic stuff to get the path to the cached jar
@@ -264,12 +272,14 @@ public class ProguardTask extends BaritoneGradleTask {

    private void proguardApi() throws Exception {
        runProguard(getTemporaryFile(PROGUARD_API_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactApiPath.toString(), Optional.empty());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeApiPath.toString(), Optional.of(mixin));
    }

    private void proguardStandalone() throws Exception {
        runProguard(getTemporaryFile(PROGUARD_STANDALONE_CONFIG));
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactStandalonePath.toString(), Optional.empty());
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeStandalonePath.toString(), Optional.of(mixin));
    }

    private void cleanup() {
@@ -298,8 +308,8 @@ public class ProguardTask extends BaritoneGradleTask {
                .start();

        // We can't do output inherit process I/O with gradle for some reason and have it work, so we have to do this
-        this.printOutputLog(p.getInputStream());
-        this.printOutputLog(p.getErrorStream());
+        this.printOutputLog(p.getInputStream(), System.out);
+        this.printOutputLog(p.getErrorStream(), System.err);

        // Halt the current thread until the process is complete, if the exit code isn't 0, throw an exception
        int exitCode = p.waitFor();
@@ -308,12 +318,12 @@ public class ProguardTask extends BaritoneGradleTask {
        }
    }

-    private void printOutputLog(InputStream stream) {
+    private void printOutputLog(InputStream stream, PrintStream outerr) {
        new Thread(() -> {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream))) {
                String line;
                while ((line = reader.readLine()) != null) {
-                    System.out.println(line);
+                    outerr.println(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
--- a/buildSrc/src/main/java/baritone/gradle/util/Determinizer.java
+++ b/buildSrc/src/main/java/baritone/gradle/util/Determinizer.java
@@ -22,10 +22,7 @@ import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;

 import java.io.*;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
@@ -39,7 +36,7 @@ import java.util.stream.Collectors;
 */
 public class Determinizer {

-    public static void determinize(String inputPath, String outputPath) throws IOException {
+    public static void determinize(String inputPath, String outputPath, Optional<File> toInclude) throws IOException {
        System.out.println("Running Determinizer");
        System.out.println(" Input path: " + inputPath);
        System.out.println(" Output path: " + outputPath);
@@ -66,10 +63,30 @@ public class Determinizer {
                if (entry.getName().endsWith(".refmap.json")) {
                    JsonObject object = new JsonParser().parse(new InputStreamReader(jarFile.getInputStream(entry))).getAsJsonObject();
                    jos.write(writeSorted(object).getBytes());
+                } else if (entry.getName().equals("META-INF/MANIFEST.MF") && toInclude.isPresent()) { // only replace for forge jar
+                    ByteArrayOutputStream cancer = new ByteArrayOutputStream();
+                    copy(jarFile.getInputStream(entry), cancer);
+                    String manifest = new String(cancer.toByteArray());
+                    if (!manifest.contains("baritone.launch.BaritoneTweaker")) {
+                        throw new IllegalStateException("unable to replace");
+                    }
+                    manifest = manifest.replace("baritone.launch.BaritoneTweaker", "org.spongepowered.asm.launch.MixinTweaker");
+                    jos.write(manifest.getBytes());
                } else {
                    copy(jarFile.getInputStream(entry), jos);
                }
            }
+            if (toInclude.isPresent()) {
+                try (JarFile mixin = new JarFile(toInclude.get())) {
+                    for (JarEntry entry : mixin.stream().sorted(Comparator.comparing(JarEntry::getName)).collect(Collectors.toList())) {
+                        if (entry.getName().startsWith("META-INF") && !entry.getName().startsWith("META-INF/services")) {
+                            continue;
+                        }
+                        jos.putNextEntry(entry);
+                        copy(mixin.getInputStream(entry), jos);
+                    }
+                }
+            }
            jos.finish();
        }
    }
--- a/scripts/proguard.pro
+++ b/scripts/proguard.pro
@@ -12,6 +12,9 @@
 -flattenpackagehierarchy
 -repackageclasses 'baritone'

+# lwjgl is weird
+-dontwarn org.lwjgl.opengl.GL14
+
 -keep class baritone.api.** { *; } # this is the keep api

 # service provider needs these class names
--- a/src/api/java/baritone/api/IBaritone.java
+++ b/src/api/java/baritone/api/IBaritone.java
@@ -76,4 +76,11 @@ public interface IBaritone {
    IPlayerContext getPlayerContext();

    IEventBus getGameEventHandler();
+
+    /**
+     * Call as soon as Minecraft is ready.
+     * <p>
+     * Or whenever your overeager utility client wants.
+     */
+    void init();
 }
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -164,6 +164,11 @@ public final class Settings {
     */
    public final Setting<Boolean> considerPotionEffects = new Setting<>(true);

+    /**
+     * Sprint and jump a block early on ascends wherever possible
+     */
+    public final Setting<Boolean> sprintAscends = new Setting<>(true);
+
    /**
     * This is the big A* setting.
     * As long as your cost heuristic is an *underestimate*, it's guaranteed to find you the best path.
@@ -277,7 +282,7 @@ public final class Settings {
    /**
     * Start planning the next path once the remaining movements tick estimates sum up to less than this value
     */
-    public final Setting<Integer> planningTickLookAhead = new Setting<>(150);
+    public final Setting<Integer> planningTickLookahead = new Setting<>(150);

    /**
     * Default size of the Long2ObjectOpenHashMap used in pathing
@@ -308,6 +313,8 @@ public final class Settings {
     * Is it okay to sprint through a descend followed by a diagonal?
     * The player overshoots the landing, but not enough to fall off. And the diagonal ensures that there isn't
     * lava or anything that's !canWalkInto in that space, so it's technically safe, just a little sketchy.
+     * <p>
+     * Note: this is *not* related to the allowDiagonalDescend setting, that is a completely different thing.
     */
    public final Setting<Boolean> allowOvershootDiagonalDescend = new Setting<>(true);

@@ -378,10 +385,22 @@ public final class Settings {
     */
    public final Setting<Boolean> pruneRegionsFromRAM = new Setting<>(false);

+    /**
+     * Cancel baritone on left click, as a form of "panic button"
+     */
+    public final Setting<Boolean> clickCancel = new Setting<>(false);
+
+    /**
+     * Remember the contents of containers (chests, echests, furnaces)
+     * <p>
+     * Really buggy since the packet stuff is multithreaded badly thanks to brady
+     */
+    public final Setting<Boolean> containerMemory = new Setting<>(false);
+
    /**
     * Print all the debug messages to chat
     */
-    public final Setting<Boolean> chatDebug = new Setting<>(true);
+    public final Setting<Boolean> chatDebug = new Setting<>(false);

    /**
     * Allow chat based control of Baritone. Most likely should be disabled when Baritone is imported for use in
@@ -459,10 +478,45 @@ public final class Settings {
     */
    public final Setting<Boolean> pathThroughCachedOnly = new Setting<>(false);

+    /**
+     * Continue sprinting while in water
+     */
+    public final Setting<Boolean> sprintInWater = new Setting<>(true);
+
+    /**
+     * When GetToBlockProcess fails to calculate a path, instead of just giving up, mark the closest instances
+     * of that block as "unreachable" and go towards the next closest
+     */
+    public final Setting<Boolean> blacklistOnGetToBlockFailure = new Setting<>(true);
+
+    /**
+     * 😎 Render cached chunks as semitransparent. Doesn't work with OptiFine 😭 Rarely randomly crashes, see <a href="https://github.com/cabaletta/baritone/issues/327">this issue</a>.
+     * <p>
+     * Can be very useful on servers with low render distance. After enabling, you may need to reload the world in order for it to have an effect
+     * (e.g. disconnect and reconnect, enter then exit the nether, die and respawn, etc). This may literally kill your FPS and CPU because
+     * every chunk gets recompiled twice as much as normal, since the cached version comes into range, then the normal one comes from the server for real.
+     * <p>
+     * Note that flowing water is cached as AVOID, which is rendered as lava. As you get closer, you may therefore see lava falls being replaced with water falls.
+     * <p>
+     * SOLID is rendered as stone in the overworld, netherrack in the nether, and end stone in the end
+     */
+    public Setting<Boolean> renderCachedChunks = new Setting<>(false);
+
+    /**
+     * 0.0f = not visible, fully transparent
+     * 1.0f = fully opaque
+     */
+    public Setting<Float> cachedChunksOpacity = new Setting<>(0.5f);
+
+    /**
+     * If true, Baritone will not allow you to left or right click while pathing
+     */
+    public Setting<Boolean> suppressClicks = new Setting<>(false);
+
    /**
     * Whether or not to use the "#" command prefix
     */
-    public final Setting<Boolean> prefix = new Setting<>(false);
+    public final Setting<Boolean> prefixControl = new Setting<>(true);

    /**
     * Don't stop walking forward when you need to break blocks in your way
@@ -485,6 +539,11 @@ public final class Settings {
     */
    public final Setting<Integer> mineGoalUpdateInterval = new Setting<>(5);

+    /**
+     * When GetToBlock doesn't know any locations for the desired block, explore randomly instead of giving up.
+     */
+    public final Setting<Boolean> exploreForBlocks = new Setting<>(true);
+
    /**
     * While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?
     */
@@ -522,6 +581,19 @@ public final class Settings {
     */
    public final Setting<Integer> legitMineYLevel = new Setting<>(11);

+    /**
+     * Magically see ores that are separated diagonally from existing ores. Basically like mining around the ores that it finds
+     * in case there's one there touching it diagonally, except it checks it un-legit-ly without having the mine blocks to see it.
+     * You can decide whether this looks plausible or not.
+     * <p>
+     * This is disabled because it results in some weird behavior. For example, it can """see""" the top block of a vein of iron_ore
+     * through a lava lake. This isn't an issue normally since it won't consider anything touching lava, so it just ignores it.
+     * However, this setting expands that and allows it to see the entire vein so it'll mine under the lava lake to get the iron that
+     * it can reach without mining blocks adjacent to lava. This really defeats the purpose of legitMine since a player could never
+     * do that lol, so thats one reason why its disabled
+     */
+    public final Setting<Boolean> legitMineIncludeDiagonals = new Setting<>(false);
+
    /**
     * When mining block of a certain type, try to mine two at once instead of one.
     * If the block above is also a goal block, set GoalBlock instead of GoalTwoBlocks
@@ -638,7 +710,7 @@ public final class Settings {
        }
    }

-    public class Setting<T> {
+    public final class Setting<T> {
        public T value;
        public final T defaultValue;
        private String name;
--- a/src/api/java/baritone/api/behavior/IPathingBehavior.java
+++ b/src/api/java/baritone/api/behavior/IPathingBehavior.java
@@ -38,11 +38,24 @@ public interface IPathingBehavior extends IBehavior {
     * @return The estimated remaining ticks in the current segment.
     */
    default Optional<Double> ticksRemainingInSegment() {
+        return ticksRemainingInSegment(true);
+    }
+
+    /**
+     * Returns the estimated remaining ticks in the current pathing
+     * segment. Given that the return type is an optional, {@link Optional#empty()}
+     * will be returned in the case that there is no current segment being pathed.
+     *
+     * @param includeCurrentMovement whether or not to include the entirety of the cost of the currently executing movement in the total
+     * @return The estimated remaining ticks in the current segment.
+     */
+    default Optional<Double> ticksRemainingInSegment(boolean includeCurrentMovement) {
        IPathExecutor current = getCurrent();
        if (current == null) {
            return Optional.empty();
        }
-        return Optional.of(current.getPath().ticksRemainingFrom(current.getPosition()));
+        int start = includeCurrentMovement ? current.getPosition() : current.getPosition() + 1;
+        return Optional.of(current.getPath().ticksRemainingFrom(start));
    }

    /**
--- a/src/api/java/baritone/api/utils/Rotation.java
+++ b/src/api/java/baritone/api/utils/Rotation.java
@@ -117,8 +117,12 @@ public class Rotation {
     * @return are they really close
     */
    public boolean isReallyCloseTo(Rotation other) {
-        float yawDiff = Math.abs(this.yaw - other.yaw); // you cant fool me
-        return (yawDiff < 0.01 || yawDiff > 359.9) && Math.abs(this.pitch - other.pitch) < 0.01;
+        return yawIsReallyClose(other) && Math.abs(this.pitch - other.pitch) < 0.01;
+    }
+
+    public boolean yawIsReallyClose(Rotation other) {
+        float yawDiff = Math.abs(normalizeYaw(yaw) - normalizeYaw(other.yaw)); // you cant fool me
+        return (yawDiff < 0.01 || yawDiff > 359.99);
    }

    /**
@@ -147,4 +151,9 @@ public class Rotation {
        }
        return newYaw;
    }
+
+    @Override
+    public String toString() {
+        return "Yaw: " + yaw + ", Pitch: " + pitch;
+    }
 }
--- a/src/api/java/baritone/api/utils/RotationUtils.java
+++ b/src/api/java/baritone/api/utils/RotationUtils.java
@@ -78,6 +78,9 @@ public final class RotationUtils {
     * @return The wrapped angles
     */
    public static Rotation wrapAnglesToRelative(Rotation current, Rotation target) {
+        if (current.yawIsReallyClose(target)) {
+            return new Rotation(current.getYaw(), target.getPitch());
+        }
        return target.subtract(current).normalize().add(current);
    }

@@ -102,7 +105,7 @@ public final class RotationUtils {
     * @param dest The destination position
     * @return The rotation from the origin to the destination
     */
-    public static Rotation calcRotationFromVec3d(Vec3d orig, Vec3d dest) {
+    private static Rotation calcRotationFromVec3d(Vec3d orig, Vec3d dest) {
        double[] delta = {orig.x - dest.x, orig.y - dest.y, orig.z - dest.z};
        double yaw = MathHelper.atan2(delta[0], -delta[2]);
        double dist = Math.sqrt(delta[0] * delta[0] + delta[2] * delta[2]);
@@ -196,7 +199,7 @@ public final class RotationUtils {
     * @return The optional rotation
     */
    public static Optional<Rotation> reachableOffset(Entity entity, BlockPos pos, Vec3d offsetPos, double blockReachDistance) {
-        Rotation rotation = calcRotationFromVec3d(entity.getPositionEyes(1.0F), offsetPos);
+        Rotation rotation = calcRotationFromVec3d(entity.getPositionEyes(1.0F), offsetPos, new Rotation(entity.rotationYaw, entity.rotationPitch));
        RayTraceResult result = RayTraceUtils.rayTraceTowards(entity, rotation, blockReachDistance);
        //System.out.println(result);
        if (result != null && result.typeOfHit == RayTraceResult.Type.BLOCK) {
--- a/src/launch/java/baritone/launch/mixins/MixinChunkRenderContainer.java
+++ b/src/launch/java/baritone/launch/mixins/MixinChunkRenderContainer.java
@@ -0,0 +1,52 @@
+/*
+ * 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.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ChunkRenderContainer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.chunk.RenderChunk;
+import net.minecraft.util.math.BlockPos;
+import org.lwjgl.opengl.GL14;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import static org.lwjgl.opengl.GL11.*;
+
+@Mixin(ChunkRenderContainer.class)
+public class MixinChunkRenderContainer {
+
+    @Redirect( // avoid creating CallbackInfo at all costs; this is called 40k times per second
+            method = "preRenderChunk",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/renderer/chunk/RenderChunk.getPosition()Lnet/minecraft/util/math/BlockPos;"
+            )
+    )
+    private BlockPos getPosition(RenderChunk renderChunkIn) {
+        if (Baritone.settings().renderCachedChunks.get() && Minecraft.getMinecraft().world.getChunk(renderChunkIn.getPosition()).isEmpty()) {
+            GlStateManager.enableAlpha();
+            GlStateManager.enableBlend();
+            GL14.glBlendColor(0, 0, 0, Baritone.settings().cachedChunksOpacity.get());
+            GlStateManager.tryBlendFuncSeparate(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_ONE, GL_ZERO);
+        }
+        return renderChunkIn.getPosition();
+    }
+}
--- a/src/launch/java/baritone/launch/mixins/MixinChunkRenderWorker.java
+++ b/src/launch/java/baritone/launch/mixins/MixinChunkRenderWorker.java
@@ -0,0 +1,56 @@
+/*
+ * 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.launch.mixins;
+
+import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.utils.IPlayerContext;
+import net.minecraft.client.renderer.chunk.ChunkRenderWorker;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+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.Redirect;
+
+@Mixin(ChunkRenderWorker.class)
+public abstract class MixinChunkRenderWorker {
+
+    @Shadow
+    protected abstract boolean isChunkExisting(BlockPos pos, World worldIn);
+
+    @Redirect(
+            method = "processTask",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/renderer/chunk/ChunkRenderWorker.isChunkExisting(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/world/World;)Z"
+            )
+    )
+    private boolean isChunkExisting(ChunkRenderWorker worker, BlockPos pos, World world) {
+        if (Baritone.settings().renderCachedChunks.get()) {
+            Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
+            IPlayerContext ctx = baritone.getPlayerContext();
+            if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {
+                return baritone.bsi.isLoaded(pos.getX(), pos.getZ()) || this.isChunkExisting(pos, world);
+            }
+        }
+
+        return this.isChunkExisting(pos, world);
+    }
+}
+
--- a/src/launch/java/baritone/launch/mixins/MixinEntity.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntity.java
@@ -1,74 +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.launch.mixins;
-
-import baritone.api.BaritoneAPI;
-import baritone.api.event.events.RotationMoveEvent;
-import net.minecraft.client.entity.EntityPlayerSP;
-import net.minecraft.entity.Entity;
-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.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import static org.spongepowered.asm.lib.Opcodes.GETFIELD;
-
-/**
- * @author Brady
- * @since 8/21/2018
- */
-@Mixin(Entity.class)
-public class MixinEntity {
-
-    @Shadow
-    public float rotationYaw;
-
-    /**
-     * Event called to override the movement direction when walking
-     */
-    private RotationMoveEvent motionUpdateRotationEvent;
-
-    @Inject(
-            method = "moveRelative",
-            at = @At("HEAD")
-    )
-    private void preMoveRelative(float strafe, float up, float forward, float friction, CallbackInfo ci) {
-        // noinspection ConstantConditions
-        if (EntityPlayerSP.class.isInstance(this)) {
-            this.motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
-            BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(this.motionUpdateRotationEvent);
-        }
-    }
-
-    @Redirect(
-            method = "moveRelative",
-            at = @At(
-                    value = "FIELD",
-                    opcode = GETFIELD,
-                    target = "net/minecraft/entity/Entity.rotationYaw:F"
-            )
-    )
-    private float overrideYaw(Entity self) {
-        if (self instanceof EntityPlayerSP) {
-            return this.motionUpdateRotationEvent.getYaw();
-        }
-        return self.rotationYaw;
-    }
-}
--- a/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntityLivingBase.java
@@ -74,4 +74,25 @@ public abstract class MixinEntityLivingBase extends Entity {
        }
        return self.rotationYaw;
    }
+
+    @Redirect(
+            method = "travel",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/entity/EntityLivingBase.moveRelative(FFFF)V"
+            )
+    )
+    private void travel(EntityLivingBase self, float strafe, float up, float forward, float friction) {
+        // noinspection ConstantConditions
+        if (!EntityPlayerSP.class.isInstance(this)) {
+            moveRelative(strafe, up, forward, friction);
+            return;
+        }
+        RotationMoveEvent motionUpdateRotationEvent = new RotationMoveEvent(RotationMoveEvent.Type.MOTION_UPDATE, this.rotationYaw);
+        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerRotationMove(motionUpdateRotationEvent);
+        float originalYaw = this.rotationYaw;
+        this.rotationYaw = motionUpdateRotationEvent.getYaw();
+        this.moveRelative(strafe, up, forward, friction);
+        this.rotationYaw = originalYaw;
+    }
 }
--- a/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java
+++ b/src/launch/java/baritone/launch/mixins/MixinEntityPlayerSP.java
@@ -18,6 +18,7 @@
 package baritone.launch.mixins;

 import baritone.api.BaritoneAPI;
+import baritone.api.IBaritone;
 import baritone.api.behavior.IPathingBehavior;
 import baritone.api.event.events.ChatEvent;
 import baritone.api.event.events.PlayerUpdateEvent;
@@ -100,8 +101,16 @@ public class MixinEntityPlayerSP {
    )
    private boolean isKeyDown(KeyBinding keyBinding) {
        SprintStateEvent event = new SprintStateEvent();
-        BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this).getGameEventHandler().onPlayerSprintState(event);
-        return event.getState() == null ? keyBinding.isKeyDown() : event.getState();
+        IBaritone baritone = BaritoneAPI.getProvider().getBaritoneForPlayer((EntityPlayerSP) (Object) this);
+        baritone.getGameEventHandler().onPlayerSprintState(event);
+        if (event.getState() != null) {
+            return event.getState();
+        }
+        if (baritone != BaritoneAPI.getProvider().getPrimaryBaritone()) {
+            // hitting control shouldn't make all bots sprint
+            return false;
+        }
+        return keyBinding.isKeyDown();
    }

    @Inject(
--- a/src/launch/java/baritone/launch/mixins/MixinKeyBinding.java
+++ b/src/launch/java/baritone/launch/mixins/MixinKeyBinding.java
@@ -17,8 +17,10 @@

 package baritone.launch.mixins;

+import baritone.Baritone;
 import baritone.api.BaritoneAPI;
 import baritone.utils.Helper;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.settings.KeyBinding;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -45,6 +47,9 @@ public class MixinKeyBinding {
        // only the primary baritone forces keys
        Boolean force = BaritoneAPI.getProvider().getPrimaryBaritone().getInputOverrideHandler().isInputForcedDown((KeyBinding) (Object) this);
        if (force != null) {
+            if (!force && !Baritone.settings().suppressClicks.get()) {
+                return;
+            }
            cir.setReturnValue(force); // :sunglasses:
        }
    }
@@ -57,9 +62,15 @@ public class MixinKeyBinding {
    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) { // <-- cursed
+        if (pressTime > 0 && (KeyBinding) (Object) this == Minecraft.getMinecraft().gameSettings.keyBindAttack && Baritone.settings().clickCancel.get() && BaritoneAPI.getProvider().getPrimaryBaritone().getPathingBehavior().isPathing()) {
+            Helper.HELPER.logDirect("Cancelling path on left click since the clickCancel setting is enabled!");
+            BaritoneAPI.getProvider().getPrimaryBaritone().getPathingBehavior().cancelEverything();
+            return;
+        }
+        if (force != null && !force && Baritone.settings().suppressClicks.get()) { // <-- cursed
            if (pressTime > 0) {
-                Helper.HELPER.logDirect("You're trying to press this mouse button but I won't let you");
+                Helper.HELPER.logDirect("You're trying to press this mouse button but I won't let you.");
+                Helper.HELPER.logDirect("Turn off the suppressClicks setting to allow clicking while pathing.");
                pressTime--;
            }
            cir.setReturnValue(force); // :sunglasses:
--- a/src/launch/java/baritone/launch/mixins/MixinRenderChunk.java
+++ b/src/launch/java/baritone/launch/mixins/MixinRenderChunk.java
@@ -0,0 +1,88 @@
+/*
+ * 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.launch.mixins;
+
+import baritone.Baritone;
+import baritone.api.BaritoneAPI;
+import baritone.api.utils.IPlayerContext;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.renderer.chunk.RenderChunk;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.ChunkCache;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * @author Brady
+ * @since 1/29/2019
+ */
+@Mixin(RenderChunk.class)
+public class MixinRenderChunk {
+
+    @Redirect(
+            method = "rebuildChunk",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/world/ChunkCache.isEmpty()Z"
+            )
+    )
+    private boolean isEmpty(ChunkCache chunkCache) {
+        if (!chunkCache.isEmpty()) {
+            return false;
+        }
+        if (Baritone.settings().renderCachedChunks.get()) {
+            Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
+            IPlayerContext ctx = baritone.getPlayerContext();
+            if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {
+                BlockPos position = ((RenderChunk) (Object) this).getPosition();
+                // RenderChunk extends from -1,-1,-1 to +16,+16,+16
+                // then the constructor of ChunkCache extends it one more (presumably to get things like the connected status of fences? idk)
+                // so if ANY of the adjacent chunks are loaded, we are unempty
+                for (int dx = -1; dx <= 1; dx++) {
+                    for (int dz = -1; dz <= 1; dz++) {
+                        if (baritone.bsi.isLoaded(16 * dx + position.getX(), 16 * dz + position.getZ())) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    @Redirect(
+            method = "rebuildChunk",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/world/ChunkCache.getBlockState(Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/block/state/IBlockState;"
+            )
+    )
+    private IBlockState getBlockState(ChunkCache chunkCache, BlockPos pos) {
+        if (Baritone.settings().renderCachedChunks.get()) {
+            Baritone baritone = (Baritone) BaritoneAPI.getProvider().getPrimaryBaritone();
+            IPlayerContext ctx = baritone.getPlayerContext();
+            if (ctx.player() != null && ctx.world() != null && baritone.bsi != null) {
+                return baritone.bsi.get0(pos);
+            }
+        }
+
+        return chunkCache.getBlockState(pos);
+    }
+}
--- a/src/launch/java/baritone/launch/mixins/MixinRenderList.java
+++ b/src/launch/java/baritone/launch/mixins/MixinRenderList.java
@@ -0,0 +1,46 @@
+/*
+ * 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.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import static org.lwjgl.opengl.GL11.*;
+
+@Mixin(RenderList.class)
+public class MixinRenderList {
+
+    @Redirect( // avoid creating CallbackInfo at all costs; this is called 40k times per second
+            method = "renderChunkLayer",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/renderer/GlStateManager.popMatrix()V"
+            )
+    )
+    private void popMatrix() {
+        if (Baritone.settings().renderCachedChunks.get()) {
+            // reset the blend func to normal (not dependent on constant alpha)
+            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        }
+        GlStateManager.popMatrix();
+    }
+}
--- a/src/launch/java/baritone/launch/mixins/MixinVboRenderList.java
+++ b/src/launch/java/baritone/launch/mixins/MixinVboRenderList.java
@@ -0,0 +1,46 @@
+/*
+ * 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.launch.mixins;
+
+import baritone.Baritone;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.VboRenderList;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import static org.lwjgl.opengl.GL11.*;
+
+@Mixin(VboRenderList.class)
+public class MixinVboRenderList {
+
+    @Redirect( // avoid creating CallbackInfo at all costs; this is called 40k times per second
+            method = "renderChunkLayer",
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/renderer/GlStateManager.popMatrix()V"
+            )
+    )
+    private void popMatrix() {
+        if (Baritone.settings().renderCachedChunks.get()) {
+            // reset the blend func to normal (not dependent on constant alpha)
+            GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        }
+        GlStateManager.popMatrix();
+    }
+}
--- a/src/launch/resources/mixins.baritone.json
+++ b/src/launch/resources/mixins.baritone.json
@@ -12,7 +12,8 @@
    "MixinBlockPos",
    "MixinChunkProviderClient",
    "MixinChunkProviderServer",
-    "MixinEntity",
+    "MixinChunkRenderContainer",
+    "MixinChunkRenderWorker",
    "MixinEntityLivingBase",
    "MixinEntityPlayerSP",
    "MixinEntityRenderer",
@@ -20,6 +21,9 @@
    "MixinMinecraft",
    "MixinNetHandlerPlayClient",
    "MixinNetworkManager",
+    "MixinRenderChunk",
+    "MixinRenderList",
+    "MixinVboRenderList",
    "MixinWorldClient"
  ]
 }
--- a/src/main/java/baritone/Baritone.java
+++ b/src/main/java/baritone/Baritone.java
@@ -29,10 +29,7 @@ import baritone.process.CustomGoalProcess;
 import baritone.process.FollowProcess;
 import baritone.process.GetToBlockProcess;
 import baritone.process.MineProcess;
-import baritone.utils.BaritoneAutoTest;
-import baritone.utils.ExampleBaritoneControl;
-import baritone.utils.InputOverrideHandler;
-import baritone.utils.PathingControlManager;
+import baritone.utils.*;
 import baritone.utils.player.PrimaryPlayerContext;
 import net.minecraft.client.Minecraft;

@@ -89,10 +86,13 @@ public class Baritone implements IBaritone {
    private IPlayerContext playerContext;
    private WorldProvider worldProvider;

+    public BlockStateInterface bsi;
+
    Baritone() {
        this.gameEventHandler = new GameEventHandler(this);
    }

+    @Override
    public synchronized void init() {
        if (initialized) {
            return;
--- a/src/main/java/baritone/behavior/LookBehavior.java
+++ b/src/main/java/baritone/behavior/LookBehavior.java
@@ -103,7 +103,7 @@ public final class LookBehavior extends Behavior implements ILookBehavior {

    @Override
    public void onPlayerRotationMove(RotationMoveEvent event) {
-        if (this.target != null && !this.force) {
+        if (this.target != null) {

            event.setYaw(this.target.getYaw());

--- a/src/main/java/baritone/behavior/MemoryBehavior.java
+++ b/src/main/java/baritone/behavior/MemoryBehavior.java
@@ -65,6 +65,9 @@ public final class MemoryBehavior extends Behavior {

    @Override
    public synchronized void onTick(TickEvent event) {
+        if (!Baritone.settings().containerMemory.get()) {
+            return;
+        }
        if (event.getType() == TickEvent.Type.OUT) {
            enderChestWindowId = null;
            futureInventories.clear();
@@ -80,6 +83,9 @@ public final class MemoryBehavior extends Behavior {

    @Override
    public synchronized void onSendPacket(PacketEvent event) {
+        if (!Baritone.settings().containerMemory.get()) {
+            return;
+        }
        Packet p = event.getPacket();

        if (event.getState() == EventState.PRE) {
@@ -116,6 +122,9 @@ public final class MemoryBehavior extends Behavior {

    @Override
    public synchronized void onReceivePacket(PacketEvent event) {
+        if (!Baritone.settings().containerMemory.get()) {
+            return;
+        }
        Packet p = event.getPacket();

        if (event.getState() == EventState.PRE) {
@@ -162,6 +171,9 @@ public final class MemoryBehavior extends Behavior {


    private void updateInventory() {
+        if (!Baritone.settings().containerMemory.get()) {
+            return;
+        }
        int windowId = ctx.player().openContainer.windowId;
        if (enderChestWindowId != null) {
            if (windowId == enderChestWindowId) {
--- a/src/main/java/baritone/behavior/PathingBehavior.java
+++ b/src/main/java/baritone/behavior/PathingBehavior.java
@@ -61,6 +61,8 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,

    private boolean lastAutoJump;

+    private BlockPos expectedSegmentStart;
+
    private final LinkedBlockingQueue<PathEvent> toDispatch = new LinkedBlockingQueue<>();

    public PathingBehavior(Baritone baritone) {
@@ -88,6 +90,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
            baritone.getPathingControlManager().cancelEverything();
            return;
        }
+        expectedSegmentStart = pathStart();
        baritone.getPathingControlManager().preTick();
        tickPath();
        dispatchEvents();
@@ -111,11 +114,27 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
            cancelRequested = false;
            baritone.getInputOverrideHandler().clearAllKeys();
        }
-        if (current == null) {
-            return;
-        }
-        safeToCancel = current.onTick();
        synchronized (pathPlanLock) {
+            synchronized (pathCalcLock) {
+                if (inProgress != null) {
+                    // we are calculating
+                    // are we calculating the right thing though? 🤔
+                    BetterBlockPos calcFrom = inProgress.getStart();
+                    Optional<IPath> currentBest = inProgress.bestPathSoFar();
+                    if ((current == null || !current.getPath().getDest().equals(calcFrom)) // if current ends in inProgress's start, then we're ok
+                            && !calcFrom.equals(ctx.playerFeet()) && !calcFrom.equals(expectedSegmentStart) // if current starts in our playerFeet or pathStart, then we're ok
+                            && (!currentBest.isPresent() || (!currentBest.get().positions().contains(ctx.playerFeet()) && !currentBest.get().positions().contains(expectedSegmentStart))) // if
+                    ) {
+                        // when it was *just* started, currentBest will be empty so we need to also check calcFrom since that's always present
+                        inProgress.cancel(); // cancellation doesn't dispatch any events
+                        inProgress = null; // this is safe since we hold both locks
+                    }
+                }
+            }
+            if (current == null) {
+                return;
+            }
+            safeToCancel = current.onTick();
            if (current.failed() || current.finished()) {
                current = null;
                if (goal == null || goal.isInGoal(ctx.playerFeet())) {
@@ -124,7 +143,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                    next = null;
                    return;
                }
-                if (next != null && !next.getPath().positions().contains(ctx.playerFeet()) && !next.getPath().positions().contains(pathStart())) { // can contain either one
+                if (next != null && !next.getPath().positions().contains(ctx.playerFeet()) && !next.getPath().positions().contains(expectedSegmentStart)) { // can contain either one
                    // if the current path failed, we may not actually be on the next one, so make sure
                    logDebug("Discarding next path as it does not contain current position");
                    // for example if we had a nicely planned ahead path that starts where current ends
@@ -146,23 +165,12 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                // at this point, current just ended, but we aren't in the goal and have no plan for the future
                synchronized (pathCalcLock) {
                    if (inProgress != null) {
-                        // we are calculating
-                        // are we calculating the right thing though? 🤔
-                        BetterBlockPos calcFrom = inProgress.getStart();
-                        // if current just succeeded, we should be standing in calcFrom, so that's cool and good
-                        // but if current just failed, we should discard this calculation since it doesn't start from where we're standing
-                        if (calcFrom.equals(ctx.playerFeet()) || calcFrom.equals(pathStart())) {
-                            // cool and good
-                            queuePathEvent(PathEvent.PATH_FINISHED_NEXT_STILL_CALCULATING);
-                            return;
-                        }
-                        // oh noes
-                        inProgress.cancel(); // cancellation doesn't dispatch any events
-                        inProgress = null; // this is safe since we hold both locks
+                        queuePathEvent(PathEvent.PATH_FINISHED_NEXT_STILL_CALCULATING);
+                        return;
                    }
                    // we aren't calculating
                    queuePathEvent(PathEvent.CALC_STARTED);
-                    findPathInNewThread(pathStart(), true);
+                    findPathInNewThread(expectedSegmentStart, true);
                }
                return;
            }
@@ -193,8 +201,10 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                    // and this path doesn't get us all the way there
                    return;
                }
-                if (ticksRemainingInSegment().get() < Baritone.settings().planningTickLookAhead.get()) {
+                if (ticksRemainingInSegment(false).get() < Baritone.settings().planningTickLookahead.get()) {
                    // and this path has 7.5 seconds or less left
+                    // don't include the current movement so a very long last movement (e.g. descend) doesn't trip it up
+                    // if we actually included current, it wouldn't start planning ahead until the last movement was done, if the last movement took more than 7.5 seconds on its own
                    logDebug("Path almost over. Planning ahead...");
                    queuePathEvent(PathEvent.NEXT_SEGMENT_CALC_STARTED);
                    findPathInNewThread(current.getPath().getDest(), false);
@@ -296,12 +306,14 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
    public void secretInternalSegmentCancel() {
        queuePathEvent(PathEvent.CANCELED);
        synchronized (pathPlanLock) {
-            current = null;
-            next = null;
+            if (current != null) {
+                current = null;
+                next = null;
+                baritone.getInputOverrideHandler().clearAllKeys();
+                getInProgress().ifPresent(AbstractNodeCostSearch::cancel);
+                baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
+            }
        }
-        baritone.getInputOverrideHandler().clearAllKeys();
-        getInProgress().ifPresent(AbstractNodeCostSearch::cancel);
-        baritone.getInputOverrideHandler().getBlockBreakHelper().stopBreakingBlock();
    }

    public void forceCancel() { // NOT exposed on public api
@@ -333,7 +345,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                    return false;
                }
                queuePathEvent(PathEvent.CALC_STARTED);
-                findPathInNewThread(pathStart(), true);
+                findPathInNewThread(expectedSegmentStart, true);
                return true;
            }
        }
@@ -373,7 +385,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                    }
                    if (MovementHelper.canWalkOn(ctx, possibleSupport.down()) && MovementHelper.canWalkThrough(ctx, possibleSupport) && MovementHelper.canWalkThrough(ctx, possibleSupport.up())) {
                        // this is plausible
-                        logDebug("Faking path start assuming player is standing off the edge of a block");
+                        //logDebug("Faking path start assuming player is standing off the edge of a block");
                        return possibleSupport;
                    }
                }
@@ -382,7 +394,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                // !onGround
                // we're in the middle of a jump
                if (MovementHelper.canWalkOn(ctx, feet.down().down())) {
-                    logDebug("Faking path start assuming player is midair and falling");
+                    //logDebug("Faking path start assuming player is midair and falling");
                    return feet.down();
                }
            }
@@ -436,8 +448,12 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                Optional<PathExecutor> executor = calcResult.getPath().map(p -> new PathExecutor(PathingBehavior.this, p));
                if (current == null) {
                    if (executor.isPresent()) {
-                        queuePathEvent(PathEvent.CALC_FINISHED_NOW_EXECUTING);
-                        current = executor.get();
+                        if (executor.get().getPath().positions().contains(expectedSegmentStart)) {
+                            queuePathEvent(PathEvent.CALC_FINISHED_NOW_EXECUTING);
+                            current = executor.get();
+                        } else {
+                            logDebug("Warning: discarding orphan path segment with incorrect start");
+                        }
                    } else {
                        if (calcResult.getType() != PathCalculationResult.Type.CANCELLATION && calcResult.getType() != PathCalculationResult.Type.EXCEPTION) {
                            // don't dispatch CALC_FAILED on cancellation
@@ -447,8 +463,12 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                } else {
                    if (next == null) {
                        if (executor.isPresent()) {
-                            queuePathEvent(PathEvent.NEXT_SEGMENT_CALC_FINISHED);
-                            next = executor.get();
+                            if (executor.get().getPath().getSrc().equals(current.getPath().getDest())) {
+                                queuePathEvent(PathEvent.NEXT_SEGMENT_CALC_FINISHED);
+                                next = executor.get();
+                            } else {
+                                logDebug("Warning: discarding orphan next segment with incorrect start");
+                            }
                        } else {
                            queuePathEvent(PathEvent.NEXT_CALC_FAILED);
                        }
--- a/src/main/java/baritone/cache/CachedWorld.java
+++ b/src/main/java/baritone/cache/CachedWorld.java
@@ -45,7 +45,7 @@ public final class CachedWorld implements ICachedWorld, Helper {
    /**
     * The maximum number of regions in any direction from (0,0)
     */
-    private static final int REGION_MAX = 58594;
+    private static final int REGION_MAX = 30_000_000 / 512 + 1;

    /**
     * A map of all of the cached regions.
--- a/src/main/java/baritone/cache/ChunkPacker.java
+++ b/src/main/java/baritone/cache/ChunkPacker.java
@@ -124,12 +124,13 @@ public final class ChunkPacker {

    private static PathingBlockType getPathingBlockType(IBlockState state) {
        Block block = state.getBlock();
-        if (block == Blocks.WATER && !MovementHelper.isFlowing(state)) {
+        if ((block == Blocks.WATER || block == Blocks.FLOWING_WATER) && !MovementHelper.isFlowing(state)) {
            // only water source blocks are plausibly usable, flowing water should be avoid
+            // FLOWING_WATER is a waterfall, it doesn't really matter and caching it as AVOID just makes it look wrong
            return PathingBlockType.WATER;
        }

-        if (MovementHelper.avoidWalkingInto(block) || block == Blocks.FLOWING_WATER || MovementHelper.isBottomSlab(state)) {
+        if (MovementHelper.avoidWalkingInto(block) || MovementHelper.isBottomSlab(state)) {
            return PathingBlockType.AVOID;
        }
        // We used to do an AABB check here
--- a/src/main/java/baritone/cache/ContainerMemory.java
+++ b/src/main/java/baritone/cache/ContainerMemory.java
@@ -17,6 +17,7 @@

 package baritone.cache;

+import baritone.Baritone;
 import baritone.api.cache.IContainerMemory;
 import baritone.api.cache.IRememberedInventory;
 import baritone.api.utils.IPlayerContext;
@@ -69,6 +70,9 @@ public class ContainerMemory implements IContainerMemory {
    }

    public synchronized void save() throws IOException {
+        if (!Baritone.settings().containerMemory.get()) {
+            return;
+        }
        ByteBuf buf = Unpooled.buffer(0, Integer.MAX_VALUE);
        PacketBuffer out = new PacketBuffer(buf);
        out.writeInt(inventories.size());
--- a/src/main/java/baritone/event/GameEventHandler.java
+++ b/src/main/java/baritone/event/GameEventHandler.java
@@ -23,6 +23,7 @@ import baritone.api.event.events.type.EventState;
 import baritone.api.event.listener.IEventBus;
 import baritone.api.event.listener.IGameEventListener;
 import baritone.cache.WorldProvider;
+import baritone.utils.BlockStateInterface;
 import baritone.utils.Helper;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
@@ -46,6 +47,15 @@ public final class GameEventHandler implements IEventBus, Helper {

    @Override
    public final void onTick(TickEvent event) {
+        if (event.getType() == TickEvent.Type.IN) {
+            try {
+                baritone.bsi = new BlockStateInterface(baritone.getPlayerContext(), true);
+            } catch (Exception ex) {
+                baritone.bsi = null;
+            }
+        } else {
+            baritone.bsi = null;
+        }
        listeners.forEach(l -> l.onTick(event));
    }

--- a/src/main/java/baritone/pathing/calc/AStarPathFinder.java
+++ b/src/main/java/baritone/pathing/calc/AStarPathFinder.java
@@ -153,7 +153,7 @@ public final class AStarPathFinder extends AbstractNodeCostSearch {
                        if (bestHeuristicSoFar[i] - heuristic > minimumImprovement) {
                            bestHeuristicSoFar[i] = heuristic;
                            bestSoFar[i] = neighbor;
-                            if (getDistFromStartSq(neighbor) > MIN_DIST_PATH * MIN_DIST_PATH) {
+                            if (failing && getDistFromStartSq(neighbor) > MIN_DIST_PATH * MIN_DIST_PATH) {
                                failing = false;
                            }
                        }
--- a/src/main/java/baritone/pathing/movement/Movement.java
+++ b/src/main/java/baritone/pathing/movement/Movement.java
@@ -160,7 +160,7 @@ public abstract class Movement implements IMovement, MovementHelper {
                //i dont care if theres snow in the way!!!!!!!
                //you dont own me!!!!
                state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.player().getPositionEyes(1.0F),
-                        VecUtils.getBlockPosCenter(blockPos)), true)
+                        VecUtils.getBlockPosCenter(blockPos), ctx.playerRotations()), true)
                );
                // don't check selectedblock on this one, this is a fallback when we can't see any face directly, it's intended to be breaking the "incorrect" block
                state.setInput(Input.CLICK_LEFT, true);
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -439,11 +439,10 @@ public interface MovementHelper extends ActionCosts, Helper {
    }

    static void moveTowards(IPlayerContext ctx, MovementState state, BlockPos pos) {
-        EntityPlayerSP player = ctx.player();
        state.setTarget(new MovementTarget(
-                new Rotation(RotationUtils.calcRotationFromVec3d(player.getPositionEyes(1.0F),
+                new Rotation(RotationUtils.calcRotationFromVec3d(ctx.playerHead(),
                        VecUtils.getBlockPosCenter(pos),
-                        new Rotation(player.rotationYaw, player.rotationPitch)).getYaw(), player.rotationPitch),
+                        ctx.playerRotations()).getYaw(), ctx.player().rotationPitch),
                false
        )).setInput(Input.MOVE_FORWARD, true);
    }
--- a/src/main/java/baritone/pathing/movement/movements/MovementAscend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementAscend.java
@@ -181,14 +181,21 @@ public class MovementAscend extends Movement {
            return state;
        }

-        if (headBonkClear()) {
-            return state.setInput(Input.JUMP, true);
-        }
-
        int xAxis = Math.abs(src.getX() - dest.getX()); // either 0 or 1
        int zAxis = Math.abs(src.getZ() - dest.getZ()); // either 0 or 1
        double flatDistToNext = xAxis * Math.abs((dest.getX() + 0.5D) - ctx.player().posX) + zAxis * Math.abs((dest.getZ() + 0.5D) - ctx.player().posZ);
        double sideDist = zAxis * Math.abs((dest.getX() + 0.5D) - ctx.player().posX) + xAxis * Math.abs((dest.getZ() + 0.5D) - ctx.player().posZ);
+
+        double lateralMotion = xAxis * ctx.player().motionZ + zAxis * ctx.player().motionX;
+        if (Math.abs(lateralMotion) > 0.1) {
+            return state;
+        }
+
+        if (headBonkClear()) {
+            return state.setInput(Input.JUMP, true);
+        }
+
+
        // System.out.println(flatDistToNext + " " + sideDist);
        if (flatDistToNext > 1.2 || sideDist > 0.2) {
            return state;
@@ -200,7 +207,7 @@ public class MovementAscend extends Movement {
        return state.setInput(Input.JUMP, true);
    }

-    private boolean headBonkClear() {
+    public boolean headBonkClear() {
        BetterBlockPos startUp = src.up(2);
        for (int i = 0; i < 4; i++) {
            BetterBlockPos check = startUp.offset(EnumFacing.byHorizontalIndex(i));
--- a/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDescend.java
@@ -210,8 +210,8 @@ public class MovementDescend extends Movement {
            }*/
        }
        if (safeMode()) {
-            double destX = (src.getX() + 0.5) * 0.19 + (dest.getX() + 0.5) * 0.81;
-            double destZ = (src.getZ() + 0.5) * 0.19 + (dest.getZ() + 0.5) * 0.81;
+            double destX = (src.getX() + 0.5) * 0.17 + (dest.getX() + 0.5) * 0.83;
+            double destZ = (src.getZ() + 0.5) * 0.17 + (dest.getZ() + 0.5) * 0.83;
            EntityPlayerSP player = ctx.player();
            state.setTarget(new MovementState.MovementTarget(
                    new Rotation(RotationUtils.calcRotationFromVec3d(player.getPositionEyes(1.0F),
@@ -245,6 +245,10 @@ public class MovementDescend extends Movement {
        // (dest - src) + dest is offset 1 more in the same direction
        // so it's the block we'd need to worry about running into if we decide to sprint straight through this descend
        BlockPos into = dest.subtract(src.down()).add(dest);
+        if (skipToAscend()) {
+            // if dest extends into can't walk through, but the two above are can walk through, then we can overshoot and glitch in that weird way
+            return true;
+        }
        for (int y = 0; y <= 2; y++) { // we could hit any of the three blocks
            if (MovementHelper.avoidWalkingInto(BlockStateInterface.getBlock(ctx, into.up(y)))) {
                return true;
@@ -252,4 +256,9 @@ public class MovementDescend extends Movement {
        }
        return false;
    }
+
+    public boolean skipToAscend() {
+        BlockPos into = dest.subtract(src.down()).add(dest);
+        return !MovementHelper.canWalkThrough(ctx, new BetterBlockPos(into)) && MovementHelper.canWalkThrough(ctx, new BetterBlockPos(into).up()) && MovementHelper.canWalkThrough(ctx, new BetterBlockPos(into).up(2));
+    }
 }
--- a/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementDiagonal.java
@@ -17,6 +17,7 @@

 package baritone.pathing.movement.movements;

+import baritone.Baritone;
 import baritone.api.IBaritone;
 import baritone.api.pathing.movement.MovementStatus;
 import baritone.api.utils.BetterBlockPos;
@@ -114,7 +115,7 @@ public class MovementDiagonal extends Movement {
            return;
        }
        IBlockState pb3 = context.get(destX, y + 1, z);
-        if (optionA == 0 && ((MovementHelper.avoidWalkingInto(pb2.getBlock()) && pb2.getBlock() != Blocks.WATER) || (MovementHelper.avoidWalkingInto(pb3.getBlock()) && pb3.getBlock() != Blocks.WATER))) {
+        if (optionA == 0 && ((MovementHelper.avoidWalkingInto(pb2.getBlock()) && pb2.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb3.getBlock()))) {
            // at this point we're done calculating optionA, so we can check if it's actually possible to edge around in that direction
            return;
        }
@@ -123,7 +124,7 @@ public class MovementDiagonal extends Movement {
            // and finally, if the cost is nonzero for both ways to approach this diagonal, it's not possible
            return;
        }
-        if (optionB == 0 && ((MovementHelper.avoidWalkingInto(pb0.getBlock()) && pb0.getBlock() != Blocks.WATER) || (MovementHelper.avoidWalkingInto(pb1.getBlock()) && pb1.getBlock() != Blocks.WATER))) {
+        if (optionB == 0 && ((MovementHelper.avoidWalkingInto(pb0.getBlock()) && pb0.getBlock() != Blocks.WATER) || MovementHelper.avoidWalkingInto(pb1.getBlock()))) {
            // and now that option B is fully calculated, see if we can edge around that way
            return;
        }
@@ -173,13 +174,25 @@ public class MovementDiagonal extends Movement {
            state.setStatus(MovementStatus.SUCCESS);
            return state;
        }
-        if (!MovementHelper.isLiquid(ctx, ctx.playerFeet())) {
+        if (sprint()) {
            state.setInput(Input.SPRINT, true);
        }
        MovementHelper.moveTowards(ctx, state, dest);
        return state;
    }

+    public boolean sprint() {
+        if (MovementHelper.isLiquid(ctx, ctx.playerFeet()) && !Baritone.settings().sprintInWater.get()) {
+            return false;
+        }
+        for (int i = 0; i < 4; i++) {
+            if (!MovementHelper.canWalkThrough(ctx, positionsToBreak[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
    @Override
    protected boolean prepared(MovementState state) {
        return true;
--- a/src/main/java/baritone/pathing/movement/movements/MovementFall.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementFall.java
@@ -78,7 +78,7 @@ public class MovementFall extends Movement {
        }

        BlockPos playerFeet = ctx.playerFeet();
-        Rotation toDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest));
+        Rotation toDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations());
        Rotation targetRotation = null;
        Block destBlock = ctx.world().getBlockState(dest).getBlock();
        boolean isWater = destBlock == Blocks.WATER || destBlock == Blocks.FLOWING_WATER;
@@ -141,7 +141,7 @@ public class MovementFall extends Movement {
        }
        if (targetRotation == null) {
            Vec3d destCenterOffset = new Vec3d(destCenter.x + 0.125 * avoid.getX(), destCenter.y, destCenter.z + 0.125 * avoid.getZ());
-            state.setTarget(new MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), destCenterOffset), false));
+            state.setTarget(new MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), destCenterOffset, ctx.playerRotations()), false));
        }
        return state;
    }
--- a/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementParkour.java
@@ -187,6 +187,11 @@ public class MovementParkour extends Movement {
            logDebug("Pausing parkour since hand is active");
            return state;
        }
+        if (ctx.playerFeet().y < src.y) {
+            // we have fallen
+            logDebug("sorry");
+            return state.setStatus(MovementStatus.UNREACHABLE);
+        }
        if (dist >= 4) {
            state.setInput(Input.SPRINT, true);
        }
--- a/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementPillar.java
@@ -151,7 +151,7 @@ public class MovementPillar extends Movement {
        IBlockState fromDown = BlockStateInterface.get(ctx, src);
        if (MovementHelper.isWater(fromDown.getBlock()) && MovementHelper.isWater(ctx, dest)) {
            // stay centered while swimming up a water column
-            state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest)), false));
+            state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.getBlockPosCenter(dest), ctx.playerRotations()), false));
            Vec3d destCenter = VecUtils.getBlockPosCenter(dest);
            if (Math.abs(ctx.player().posX - destCenter.x) > 0.2 || Math.abs(ctx.player().posZ - destCenter.z) > 0.2) {
                state.setInput(Input.MOVE_FORWARD, true);
--- a/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
+++ b/src/main/java/baritone/pathing/movement/movements/MovementTraverse.java
@@ -174,7 +174,7 @@ public class MovementTraverse extends Movement {

            // combine the yaw to the center of the destination, and the pitch to the specific block we're trying to break
            // it's safe to do this since the two blocks we break (in a traverse) are right on top of each other and so will have the same yaw
-            float yawToDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), dest)).getYaw();
+            float yawToDest = RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), dest), ctx.playerRotations()).getYaw();
            float pitchToBreak = state.getTarget().getRotation().get().getPitch();

            state.setTarget(new MovementState.MovementTarget(new Rotation(yawToDest, pitchToBreak), true));
@@ -198,7 +198,7 @@ public class MovementTraverse extends Movement {
                isDoorActuallyBlockingUs = true;
            }
            if (isDoorActuallyBlockingUs && !(Blocks.IRON_DOOR.equals(pb0.getBlock()) || Blocks.IRON_DOOR.equals(pb1.getBlock()))) {
-                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), positionsToBreak[0])), true))
+                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), positionsToBreak[0]), ctx.playerRotations()), true))
                        .setInput(Input.CLICK_RIGHT, true);
            }
        }
@@ -212,7 +212,7 @@ public class MovementTraverse extends Movement {
            }

            if (blocked != null) {
-                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), blocked)), true))
+                return state.setTarget(new MovementState.MovementTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), VecUtils.calculateBlockCenter(ctx.world(), blocked), ctx.playerRotations()), true))
                        .setInput(Input.CLICK_RIGHT, true);
            }
        }
@@ -234,7 +234,7 @@ public class MovementTraverse extends Movement {
            BlockPos into = dest.subtract(src).add(dest);
            Block intoBelow = BlockStateInterface.get(ctx, into).getBlock();
            Block intoAbove = BlockStateInterface.get(ctx, into.up()).getBlock();
-            if (wasTheBridgeBlockAlwaysThere && !MovementHelper.isLiquid(ctx, ctx.playerFeet()) && !MovementHelper.avoidWalkingInto(intoBelow) && !MovementHelper.avoidWalkingInto(intoAbove)) {
+            if (wasTheBridgeBlockAlwaysThere && (!MovementHelper.isLiquid(ctx, ctx.playerFeet()) || Baritone.settings().sprintInWater.get()) && (!MovementHelper.avoidWalkingInto(intoBelow) || MovementHelper.isWater(intoBelow)) && !MovementHelper.avoidWalkingInto(intoAbove)) {
                state.setInput(Input.SPRINT, true);
            }
            Block destDown = BlockStateInterface.get(ctx, dest.down()).getBlock();
@@ -281,6 +281,8 @@ public class MovementTraverse extends Movement {
                    }
                    return state;
                }
+                default:
+                    break;
            }
            if (whereAmI.equals(dest)) {
                // If we are in the block that we are trying to get to, we are sneaking over air and we need to place a block beneath us against the one we just walked off of
--- a/src/main/java/baritone/pathing/path/PathExecutor.java
+++ b/src/main/java/baritone/pathing/path/PathExecutor.java
@@ -25,6 +25,7 @@ import baritone.api.pathing.movement.MovementStatus;
 import baritone.api.pathing.path.IPathExecutor;
 import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.IPlayerContext;
+import baritone.api.utils.RotationUtils;
 import baritone.api.utils.VecUtils;
 import baritone.api.utils.input.Input;
 import baritone.behavior.PathingBehavior;
@@ -39,6 +40,8 @@ import net.minecraft.block.BlockLiquid;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.Tuple;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;

 import java.util.*;

@@ -104,14 +107,6 @@ public class PathExecutor implements IPathExecutor, Helper {
        BetterBlockPos whereShouldIBe = path.positions().get(pathPosition);
        BetterBlockPos whereAmI = ctx.playerFeet();
        if (!whereShouldIBe.equals(whereAmI)) {
-
-            if (pathPosition == 0 && whereAmI.equals(whereShouldIBe.up()) && Math.abs(ctx.player().motionY) < 0.1 && !(path.movements().get(0) instanceof MovementAscend) && !(path.movements().get(0) instanceof MovementPillar)) {
-                // avoid the Wrong Y coordinate bug
-                // TODO add a timer here
-                new MovementDownward(behavior.baritone, whereAmI, whereShouldIBe).update();
-                return false;
-            }
-
            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))) {
@@ -122,6 +117,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                            path.movements().get(j).reset();
                        }
                        onChangeInPathPosition();
+                        onTick();
                        return false;
                    }
                }
@@ -134,6 +130,7 @@ public class PathExecutor implements IPathExecutor, Helper {
                        //System.out.println("Double skip sundae");
                        pathPosition = i - 1;
                        onChangeInPathPosition();
+                        onTick();
                        return false;
                    }
                }
@@ -195,17 +192,17 @@ public class PathExecutor implements IPathExecutor, Helper {
                continue;
            }
            Movement m = (Movement) path.movements().get(i);
-            HashSet<BlockPos> prevBreak = new HashSet<>(m.toBreak(bsi));
-            HashSet<BlockPos> prevPlace = new HashSet<>(m.toPlace(bsi));
-            HashSet<BlockPos> prevWalkInto = new HashSet<>(m.toWalkInto(bsi));
+            List<BlockPos> prevBreak = m.toBreak(bsi);
+            List<BlockPos> prevPlace = m.toPlace(bsi);
+            List<BlockPos> prevWalkInto = m.toWalkInto(bsi);
            m.resetBlockCache();
-            if (!prevBreak.equals(new HashSet<>(m.toBreak(bsi)))) {
+            if (!prevBreak.equals(m.toBreak(bsi))) {
                recalcBP = true;
            }
-            if (!prevPlace.equals(new HashSet<>(m.toPlace(bsi)))) {
+            if (!prevPlace.equals(m.toPlace(bsi))) {
                recalcBP = true;
            }
-            if (!prevWalkInto.equals(new HashSet<>(m.toWalkInto(bsi)))) {
+            if (!prevWalkInto.equals(m.toWalkInto(bsi))) {
                recalcBP = true;
            }
        }
@@ -249,6 +246,8 @@ public class PathExecutor implements IPathExecutor, Helper {
            return true;
        }
        if (!movement.calculatedWhileLoaded() && currentCost - currentMovementOriginalCostEstimate > Baritone.settings().maxCostIncrease.get() && canCancel) {
+            // don't do this if the movement was calculated while loaded
+            // that means that this isn't a cache error, it's just part of the path interfering with a later part
            logDebug("Original cost " + currentMovementOriginalCostEstimate + " current cost " + currentCost + ". Cancelling.");
            cancel();
            return true;
@@ -377,26 +376,43 @@ public class PathExecutor implements IPathExecutor, Helper {
    }

    private boolean shouldSprintNextTick() {
-        // 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) {
-            behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
-            return false;
-        }
-
-        // if the movement requested sprinting, then we're done
-        if (behavior.baritone.getInputOverrideHandler().isInputForcedDown(Input.SPRINT)) {
-            behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);
-            return true;
-        }
+        boolean requested = behavior.baritone.getInputOverrideHandler().isInputForcedDown(Input.SPRINT);

        // we'll take it from here, no need for minecraft to see we're holding down control and sprint for us
        behavior.baritone.getInputOverrideHandler().setInputForceState(Input.SPRINT, false);

-        // however, descend doesn't request sprinting, beceause it doesn't know the context of what movement comes after it
+        // 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) {
+            return false;
+        }
        IMovement current = path.movements().get(pathPosition);
+
+        // traverse requests sprinting, so we need to do this check first
+        if (current instanceof MovementTraverse && pathPosition < path.length() - 3) {
+            IMovement next = path.movements().get(pathPosition + 1);
+            if (next instanceof MovementAscend && sprintableAscend(ctx, (MovementTraverse) current, (MovementAscend) next, path.movements().get(pathPosition + 2))) {
+                if (skipNow(ctx, current, next)) {
+                    logDebug("Skipping traverse to straight ascend");
+                    pathPosition++;
+                    onChangeInPathPosition();
+                    onTick();
+                    behavior.baritone.getInputOverrideHandler().setInputForceState(Input.JUMP, true);
+                    return true;
+                } else {
+                    logDebug("Too far to the side to safely sprint ascend");
+                }
+            }
+        }
+
+        // if the movement requested sprinting, then we're done
+        if (requested) {
+            return true;
+        }
+
+        // however, descend and ascend don't request sprinting, because they don't know the context of what movement comes after it
        if (current instanceof MovementDescend) {

-            if (((MovementDescend) current).safeMode()) {
+            if (((MovementDescend) current).safeMode() && !((MovementDescend) current).skipToAscend()) {
                logDebug("Sprinting would be unsafe");
                return false;
            }
@@ -406,11 +422,13 @@ public class PathExecutor implements IPathExecutor, Helper {
                if (next instanceof MovementAscend && current.getDirection().up().equals(next.getDirection().down())) {
                    // a descend then an ascend in the same direction
                    pathPosition++;
+                    onChangeInPathPosition();
+                    onTick();
                    // okay to skip clearKeys and / or onChangeInPathPosition here since this isn't possible to repeat, since it's asymmetric
                    logDebug("Skipping descend to straight ascend");
                    return true;
                }
-                if (canSprintInto(ctx, current, next)) {
+                if (canSprintFromDescendInto(ctx, current, next)) {
                    if (ctx.playerFeet().equals(current.getDest())) {
                        pathPosition++;
                        onChangeInPathPosition();
@@ -430,11 +448,126 @@ public class PathExecutor implements IPathExecutor, Helper {
                    return true;
                }
            }
+            if (pathPosition < path.length() - 2 && prev instanceof MovementTraverse && sprintableAscend(ctx, (MovementTraverse) prev, (MovementAscend) current, path.movements().get(pathPosition + 1))) {
+                return true;
+            }
+        }
+        if (current instanceof MovementFall) {
+            Tuple<Vec3d, BlockPos> data = overrideFall((MovementFall) current);
+            if (data != null) {
+                BlockPos fallDest = data.getSecond();
+                if (!path.positions().contains(fallDest)) {
+                    throw new IllegalStateException();
+                }
+                if (ctx.playerFeet().equals(fallDest)) {
+                    pathPosition = path.positions().indexOf(fallDest);
+                    onChangeInPathPosition();
+                    onTick();
+                    return true;
+                }
+                clearKeys();
+                behavior.baritone.getLookBehavior().updateTarget(RotationUtils.calcRotationFromVec3d(ctx.playerHead(), data.getFirst(), ctx.playerRotations()), false);
+                behavior.baritone.getInputOverrideHandler().setInputForceState(Input.MOVE_FORWARD, true);
+                return true;
+            }
        }
        return false;
    }

-    private static boolean canSprintInto(IPlayerContext ctx, IMovement current, IMovement next) {
+    private Tuple<Vec3d, BlockPos> overrideFall(MovementFall movement) {
+        Vec3i dir = movement.getDirection();
+        if (dir.getY() < -3) {
+            return null;
+        }
+        if (!movement.toBreakCached.isEmpty()) {
+            return null; // it's breaking
+        }
+        Vec3i flatDir = new Vec3i(dir.getX(), 0, dir.getZ());
+        int i;
+        outer:
+        for (i = pathPosition + 1; i < path.length() - 1 && i < pathPosition + 3; i++) {
+            IMovement next = path.movements().get(i);
+            if (!(next instanceof MovementTraverse)) {
+                break;
+            }
+            if (!flatDir.equals(next.getDirection())) {
+                break;
+            }
+            for (int y = next.getDest().y; y <= movement.getSrc().y + 1; y++) {
+                BlockPos chk = new BlockPos(next.getDest().x, y, next.getDest().z);
+                if (!MovementHelper.fullyPassable(ctx.world().getBlockState(chk))) {
+                    break outer;
+                }
+            }
+            if (!MovementHelper.canWalkOn(ctx, next.getDest().down())) {
+                break;
+            }
+        }
+        i--;
+        if (i == pathPosition) {
+            return null; // no valid extension exists
+        }
+        double len = i - pathPosition - 0.4;
+        return new Tuple<>(
+                new Vec3d(flatDir.getX() * len + movement.getDest().x + 0.5, movement.getDest().y, flatDir.getZ() * len + movement.getDest().z + 0.5),
+                movement.getDest().add(flatDir.getX() * (i - pathPosition), 0, flatDir.getZ() * (i - pathPosition)));
+    }
+
+    private static boolean skipNow(IPlayerContext ctx, IMovement current, IMovement next) {
+        double offTarget = Math.abs(current.getDirection().getX() * (current.getSrc().z + 0.5D - ctx.player().posZ)) + Math.abs(current.getDirection().getZ() * (current.getSrc().x + 0.5D - ctx.player().posX));
+        if (offTarget > 0.1) {
+            return false;
+        }
+        // we are centered
+        BlockPos headBonk = current.getSrc().subtract(current.getDirection()).up(2);
+        if (MovementHelper.fullyPassable(ctx.world().getBlockState(headBonk))) {
+            return true;
+        }
+        // wait 0.3
+        double flatDist = Math.abs(current.getDirection().getX() * (headBonk.getX() + 0.5D - ctx.player().posX)) + Math.abs(current.getDirection().getZ() * (headBonk.getZ() + 0.5 - ctx.player().posZ));
+        return flatDist > 0.8;
+    }
+
+    private static boolean sprintableAscend(IPlayerContext ctx, MovementTraverse current, MovementAscend next, IMovement nextnext) {
+        if (!Baritone.settings().sprintAscends.get()) {
+            return false;
+        }
+        if (!current.getDirection().equals(next.getDirection().down())) {
+            return false;
+        }
+        if (nextnext.getDirection().getX() != next.getDirection().getX() || nextnext.getDirection().getZ() != next.getDirection().getZ()) {
+            return false;
+        }
+        if (!MovementHelper.canWalkOn(ctx, current.getDest().down())) {
+            return false;
+        }
+        if (!MovementHelper.canWalkOn(ctx, next.getDest().down())) {
+            return false;
+        }
+        if (!next.toBreakCached.isEmpty()) {
+            return false; // it's breaking
+        }
+        for (int x = 0; x < 2; x++) {
+            for (int y = 0; y < 3; y++) {
+                BlockPos chk = current.getSrc().up(y);
+                if (x == 1) {
+                    chk = chk.add(current.getDirection());
+                }
+                if (!MovementHelper.fullyPassable(ctx.world().getBlockState(chk))) {
+                    return false;
+                }
+            }
+        }
+        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(current.getSrc().up(3)).getBlock())) {
+            return false;
+        }
+        if (MovementHelper.avoidWalkingInto(ctx.world().getBlockState(next.getDest().up(2)).getBlock())) {
+            return false;
+        }
+        return true;
+    }
+
+    private static boolean canSprintFromDescendInto(IPlayerContext ctx, IMovement current, IMovement next) {
        if (next instanceof MovementDescend && next.getDirection().equals(current.getDirection())) {
            return true;
        }
--- a/src/main/java/baritone/process/GetToBlockProcess.java
+++ b/src/main/java/baritone/process/GetToBlockProcess.java
@@ -18,10 +18,7 @@
 package baritone.process;

 import baritone.Baritone;
-import baritone.api.pathing.goals.Goal;
-import baritone.api.pathing.goals.GoalComposite;
-import baritone.api.pathing.goals.GoalGetToBlock;
-import baritone.api.pathing.goals.GoalTwoBlocks;
+import baritone.api.pathing.goals.*;
 import baritone.api.process.IGetToBlockProcess;
 import baritone.api.process.PathingCommand;
 import baritone.api.process.PathingCommandType;
@@ -35,15 +32,14 @@ import net.minecraft.init.Blocks;
 import net.minecraft.inventory.ContainerPlayer;
 import net.minecraft.util.math.BlockPos;

-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;

 public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBlockProcess {

    private Block gettingTo;
    private List<BlockPos> knownLocations;
+    private List<BlockPos> blacklist; // locations we failed to calc to
+    private BlockPos start;

    private int tickCount = 0;

@@ -55,6 +51,8 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
    public void getToBlock(Block block) {
        onLostControl();
        gettingTo = block;
+        start = ctx.playerFeet();
+        blacklist = new ArrayList<>();
        rescan(new ArrayList<>(), new CalculationContext(baritone));
    }

@@ -64,23 +62,38 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
    }

    @Override
-    public PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
+    public synchronized PathingCommand onTick(boolean calcFailed, boolean isSafeToCancel) {
        if (knownLocations == null) {
            rescan(new ArrayList<>(), new CalculationContext(baritone));
        }
        if (knownLocations.isEmpty()) {
+            if (Baritone.settings().exploreForBlocks.get() && !calcFailed) {
+                return new PathingCommand(new GoalRunAway(1, start) {
+                    @Override
+                    public boolean isInGoal(int x, int y, int z) {
+                        return false;
+                    }
+                }, PathingCommandType.FORCE_REVALIDATE_GOAL_AND_PATH);
+            }
            logDirect("No known locations of " + gettingTo + ", canceling GetToBlock");
            if (isSafeToCancel) {
                onLostControl();
            }
            return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
        }
+        Goal goal = new GoalComposite(knownLocations.stream().map(this::createGoal).toArray(Goal[]::new));
        if (calcFailed) {
-            logDirect("Unable to find any path to " + gettingTo + ", canceling GetToBlock");
-            if (isSafeToCancel) {
-                onLostControl();
+            if (Baritone.settings().blacklistOnGetToBlockFailure.get()) {
+                logDirect("Unable to find any path to " + gettingTo + ", blacklisting presumably unreachable closest instances");
+                blacklistClosest();
+                return onTick(false, isSafeToCancel); // gamer moment
+            } else {
+                logDirect("Unable to find any path to " + gettingTo + ", canceling GetToBlock");
+                if (isSafeToCancel) {
+                    onLostControl();
+                }
+                return new PathingCommand(goal, PathingCommandType.CANCEL_AND_SET_GOAL);
            }
-            return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
        }
        int mineGoalUpdateInterval = Baritone.settings().mineGoalUpdateInterval.get();
        if (mineGoalUpdateInterval != 0 && tickCount++ % mineGoalUpdateInterval == 0) { // big brain
@@ -88,24 +101,58 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
            CalculationContext context = new CalculationContext(baritone, true);
            Baritone.getExecutor().execute(() -> rescan(current, context));
        }
-        Goal goal = new GoalComposite(knownLocations.stream().map(this::createGoal).toArray(Goal[]::new));
        if (goal.isInGoal(ctx.playerFeet()) && isSafeToCancel) {
            // we're there
            if (rightClickOnArrival(gettingTo)) {
                if (rightClick()) {
                    onLostControl();
+                    return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
                }
            } else {
                onLostControl();
+                return new PathingCommand(null, PathingCommandType.CANCEL_AND_SET_GOAL);
            }
        }
        return new PathingCommand(goal, PathingCommandType.REVALIDATE_GOAL_AND_PATH);
    }

+    // blacklist the closest block and its adjacent blocks
+    public synchronized void blacklistClosest() {
+        List<BlockPos> newBlacklist = new ArrayList<>();
+        knownLocations.stream().min(Comparator.comparingDouble(ctx.player()::getDistanceSq)).ifPresent(newBlacklist::add);
+        outer:
+        while (true) {
+            for (BlockPos known : knownLocations) {
+                for (BlockPos blacklist : newBlacklist) {
+                    if (areAdjacent(known, blacklist)) { // directly adjacent
+                        newBlacklist.add(known);
+                        knownLocations.remove(known);
+                        continue outer;
+                    }
+                }
+            }
+            if (true) {
+                break; // codacy gets mad if i just end on a break LOL
+            }
+        }
+        logDebug("Blacklisting unreachable locations " + newBlacklist);
+        blacklist.addAll(newBlacklist);
+    }
+
+    // safer than direct double comparison from distanceSq
+    private boolean areAdjacent(BlockPos posA, BlockPos posB) {
+        int diffX = Math.abs(posA.getX() - posB.getX());
+        int diffY = Math.abs(posA.getY() - posB.getY());
+        int diffZ = Math.abs(posA.getZ() - posB.getZ());
+        return (diffX + diffY + diffZ) == 1;
+    }
+
    @Override
-    public void onLostControl() {
+    public synchronized void onLostControl() {
        gettingTo = null;
        knownLocations = null;
+        start = null;
+        blacklist = null;
        baritone.getInputOverrideHandler().clearAllKeys();
    }

@@ -114,8 +161,10 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
        return "Get To Block " + gettingTo;
    }

-    private void rescan(List<BlockPos> known, CalculationContext context) {
-        knownLocations = MineProcess.searchWorld(context, Collections.singletonList(gettingTo), 64, known);
+    private synchronized void rescan(List<BlockPos> known, CalculationContext context) {
+        List<BlockPos> positions = MineProcess.searchWorld(context, Collections.singletonList(gettingTo), 64, known);
+        positions.removeIf(blacklist::contains);
+        knownLocations = positions;
    }

    private Goal createGoal(BlockPos pos) {
--- a/src/main/java/baritone/process/MineProcess.java
+++ b/src/main/java/baritone/process/MineProcess.java
@@ -228,7 +228,7 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
        return prune(ctx, locs, mining, max);
    }

-    public void addNearby() {
+    private void addNearby() {
        knownOreLocations.addAll(droppedItemsScan(mining, ctx.world()));
        BlockPos playerFeet = ctx.playerFeet();
        BlockStateInterface bsi = new BlockStateInterface(ctx);
@@ -239,8 +239,11 @@ public final class MineProcess extends BaritoneProcessHelper implements IMinePro
                for (int z = playerFeet.getZ() - searchDist; z <= playerFeet.getZ() + searchDist; z++) {
                    // crucial to only add blocks we can see because otherwise this
                    // is an x-ray and it'll get caught
-                    if (mining.contains(bsi.get0(x, y, z).getBlock()) && RotationUtils.reachable(ctx.player(), new BlockPos(x, y, z), fakedBlockReachDistance).isPresent()) {
-                        knownOreLocations.add(new BlockPos(x, y, z));
+                    if (mining.contains(bsi.get0(x, y, z).getBlock())) {
+                        BlockPos pos = new BlockPos(x, y, z);
+                        if ((Baritone.settings().legitMineIncludeDiagonals.get() && knownOreLocations.stream().anyMatch(ore -> ore.distanceSq(pos) <= 2 /* sq means this is pytha dist <= sqrt(2) */)) || RotationUtils.reachable(ctx.player(), pos, fakedBlockReachDistance).isPresent()) {
+                            knownOreLocations.add(pos);
+                        }
                    }
                }
            }
@@ -250,12 +253,19 @@ 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);
+        dropped.removeIf(drop -> {
+            for (BlockPos pos : locs2) {
+                if (pos.distanceSq(drop) <= 9 && mining.contains(ctx.getBlock(pos.getX(), pos.getY(), pos.getZ())) && MineProcess.plausibleToBreak(ctx.bsi, pos)) { // TODO maybe drop also has to be supported? no lava below?
+                    return true;
+                }
+            }
+            return false;
+        });
        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))

                // remove any that are implausible to mine (encased in bedrock, or touching lava)
--- a/src/main/java/baritone/utils/ExampleBaritoneControl.java
+++ b/src/main/java/baritone/utils/ExampleBaritoneControl.java
@@ -24,6 +24,7 @@ import baritone.api.cache.IWaypoint;
 import baritone.api.event.events.ChatEvent;
 import baritone.api.pathing.goals.*;
 import baritone.api.pathing.movement.ActionCosts;
+import baritone.api.utils.BetterBlockPos;
 import baritone.api.utils.SettingsUtil;
 import baritone.behavior.Behavior;
 import baritone.behavior.PathingBehavior;
@@ -35,6 +36,7 @@ import baritone.pathing.movement.Moves;
 import baritone.process.CustomGoalProcess;
 import baritone.utils.pathing.SegmentedCalculator;
 import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.ChunkProviderClient;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
@@ -85,21 +87,19 @@ public class ExampleBaritoneControl extends Behavior implements Helper {

    @Override
    public void onSendChatMessage(ChatEvent event) {
+        String msg = event.getMessage();
+        if (Baritone.settings().prefixControl.get() && msg.startsWith(COMMAND_PREFIX)) {
+            if (!runCommand(msg.substring(COMMAND_PREFIX.length()))) {
+                logDirect("Invalid command");
+            }
+            event.cancel(); // always cancel if using prefixControl
+            return;
+        }
        if (!Baritone.settings().chatControl.get() && !Baritone.settings().removePrefix.get()) {
            return;
        }
-        String msg = event.getMessage();
-        if (Baritone.settings().prefix.get()) {
-            if (msg.startsWith(COMMAND_PREFIX)) {
-                if (!runCommand(msg.substring(COMMAND_PREFIX.length()))) {
-                    logDirect("Invalid command");
-                }
-                event.cancel(); // always cancel if using prefix
-            }
-        } else {
-            if (runCommand(msg)) {
-                event.cancel();
-            }
+        if (runCommand(msg)) {
+            event.cancel();
        }
    }

@@ -163,36 +163,19 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
        }

        if (msg.startsWith("goal")) {
-            String[] params = msg.substring(4).trim().split(" ");
-            if (params[0].equals("")) {
-                params = new String[]{};
-            }
+            String rest = msg.substring(4).trim();
            Goal goal;
-            try {
-                switch (params.length) {
-                    case 0:
-                        goal = new GoalBlock(ctx.playerFeet());
-                        break;
-                    case 1:
-                        if (params[0].equals("clear") || params[0].equals("none")) {
-                            goal = null;
-                        } else {
-                            goal = new GoalYLevel(Integer.parseInt(params[0]));
-                        }
-                        break;
-                    case 2:
-                        goal = new GoalXZ(Integer.parseInt(params[0]), Integer.parseInt(params[1]));
-                        break;
-                    case 3:
-                        goal = new GoalBlock(new BlockPos(Integer.parseInt(params[0]), Integer.parseInt(params[1]), Integer.parseInt(params[2])));
-                        break;
-                    default:
-                        logDirect("unable to understand lol");
-                        return true;
+            if (rest.equals("clear") || rest.equals("none")) {
+                goal = null;
+            } else {
+                String[] params = rest.split(" ");
+                if (params[0].equals("")) {
+                    params = new String[]{};
+                }
+                goal = parseGoal(params);
+                if (goal == null) {
+                    return true;
                }
-            } catch (NumberFormatException ex) {
-                logDirect("unable to parse integer " + ex);
-                return true;
            }
            customGoalProcess.setGoal(goal);
            logDirect("Goal: " + goal);
@@ -227,6 +210,15 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
            }
            return true;
        }
+        if (msg.equals("version")) {
+            String version = ExampleBaritoneControl.class.getPackage().getImplementationVersion();
+            if (version == null) {
+                logDirect("No version detected. Either dev environment or broken install.");
+            } else {
+                logDirect("You are using Baritone v" + version);
+            }
+            return true;
+        }
        if (msg.equals("repack") || msg.equals("rescan")) {
            ChunkProviderClient cli = (ChunkProviderClient) ctx.world().getChunkProvider();
            int playerChunkX = ctx.playerFeet().getX() >> 4;
@@ -244,7 +236,7 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
            logDirect("Queued " + count + " chunks for repacking");
            return true;
        }
-        if (msg.equals("axis")) {
+        if (msg.equals("axis") || msg.equals("highway")) {
            customGoalProcess.setGoalAndPath(new GoalAxis());
            return true;
        }
@@ -289,6 +281,12 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
            logDirect("Baritone settings reset");
            return true;
        }
+        if (msg.equals("render")) {
+            BetterBlockPos pf = ctx.playerFeet();
+            Minecraft.getMinecraft().renderGlobal.markBlockRangeForRenderUpdate(pf.x - 500, pf.y - 500, pf.z - 500, pf.x + 500, pf.y + 500, pf.z + 500);
+            logDirect("okay");
+            return true;
+        }
        if (msg.equals("echest")) {
            Optional<List<ItemStack>> contents = baritone.getMemoryBehavior().echest();
            if (contents.isPresent()) {
@@ -454,7 +452,11 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
                if (block == null) {
                    waypoint = baritone.getWorldProvider().getCurrentWorld().getWaypoints().getAllWaypoints().stream().filter(w -> w.getName().equalsIgnoreCase(mining)).max(Comparator.comparingLong(IWaypoint::getCreationTimestamp)).orElse(null);
                    if (waypoint == null) {
-                        logDirect("No locations for " + mining + " known, cancelling");
+                        Goal goal = parseGoal(waypointType.split(" "));
+                        if (goal != null) {
+                            logDirect("Going to " + goal);
+                            customGoalProcess.setGoalAndPath(goal);
+                        }
                        return true;
                    }
                } else {
@@ -533,4 +535,31 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
            }
        }
    }
+
+    private Goal parseGoal(String[] params) {
+        Goal goal;
+        try {
+            switch (params.length) {
+                case 0:
+                    goal = new GoalBlock(ctx.playerFeet());
+                    break;
+                case 1:
+                    goal = new GoalYLevel(Integer.parseInt(params[0]));
+                    break;
+                case 2:
+                    goal = new GoalXZ(Integer.parseInt(params[0]), Integer.parseInt(params[1]));
+                    break;
+                case 3:
+                    goal = new GoalBlock(new BlockPos(Integer.parseInt(params[0]), Integer.parseInt(params[1]), Integer.parseInt(params[2])));
+                    break;
+                default:
+                    logDirect("unable to understand lol");
+                    return null;
+            }
+        } catch (NumberFormatException ex) {
+            logDirect("unable to parse integer " + ex);
+            return null;
+        }
+        return goal;
+    }
 }
--- a/src/main/java/baritone/utils/InputOverrideHandler.java
+++ b/src/main/java/baritone/utils/InputOverrideHandler.java
@@ -25,7 +25,6 @@ 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 java.util.HashMap;
@@ -111,14 +110,17 @@ public final class InputOverrideHandler extends Behavior implements IInputOverri
        }
        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
+        if (inControl()) {
+            if (ctx.player().movementInput.getClass() != PlayerMovementInput.class) {
+                ctx.player().movementInput = new PlayerMovementInput(this);
+            }
+        } else {
+            if (ctx.player().movementInput.getClass() == PlayerMovementInput.class) { // allow other movement inputs that aren't this one, e.g. for a freecam
+                ctx.player().movementInput = new MovementInputFromOptions(Minecraft.getMinecraft().gameSettings);
+            }
        }
+        // 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() {
--- a/src/main/java/baritone/utils/PathRenderer.java
+++ b/src/main/java/baritone/utils/PathRenderer.java
@@ -57,8 +57,6 @@ public final class PathRenderer implements Helper {
    private PathRenderer() {}

    public static void render(RenderEvent event, PathingBehavior behavior) {
-        // System.out.println("Render passing");
-        // System.out.println(event.getPartialTicks());
        float partialTicks = event.getPartialTicks();
        Goal goal = behavior.getGoal();

@@ -80,7 +78,7 @@ public final class PathRenderer implements Helper {
        }

        if (goal != null && Baritone.settings().renderGoal.value) {
-            drawLitDankGoalBox(renderView, goal, partialTicks, Baritone.settings().colorGoalBox.get());
+            drawDankLitGoalBox(renderView, goal, partialTicks, Baritone.settings().colorGoalBox.get());
        }
        if (!Baritone.settings().renderPath.get()) {
            return;
@@ -261,7 +259,7 @@ public final class PathRenderer implements Helper {
        GlStateManager.disableBlend();
    }

-    public static void drawLitDankGoalBox(Entity player, Goal goal, float partialTicks, Color color) {
+    public static void drawDankLitGoalBox(Entity player, Goal goal, float partialTicks, Color color) {
        double renderPosX = player.lastTickPosX + (player.posX - player.lastTickPosX) * (double) partialTicks;
        double renderPosY = player.lastTickPosY + (player.posY - player.lastTickPosY) * (double) partialTicks;
        double renderPosZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * (double) partialTicks;
@@ -332,7 +330,7 @@ public final class PathRenderer implements Helper {
            maxY = 256 - renderPosY;
        } else if (goal instanceof GoalComposite) {
            for (Goal g : ((GoalComposite) goal).goals()) {
-                drawLitDankGoalBox(player, g, partialTicks, color);
+                drawDankLitGoalBox(player, g, partialTicks, color);
            }
            return;
        } else {
--- a/src/main/java/baritone/utils/PlayerMovementInput.java
+++ b/src/main/java/baritone/utils/PlayerMovementInput.java
@@ -31,7 +31,7 @@ public class PlayerMovementInput extends MovementInput {
        this.moveStrafe = 0.0F;
        this.moveForward = 0.0F;

-        jump = handler.isInputForcedDown(Input.JUMP); // oppa
+        jump = handler.isInputForcedDown(Input.JUMP); // oppa gangnam

        if (this.forwardKeyDown = handler.isInputForcedDown(Input.MOVE_FORWARD)) {
            this.moveForward++;
Author	SHA1	Message	Date
Leijurv	f7a9380b9d	v1.1.6	2019-02-19 14:53:43 -08:00
Leijurv	5617c595b2	public init	2019-02-19 14:43:48 -08:00
Leijurv	8770524679	fix weird angle forcing behavior, fixes #341	2019-02-19 14:29:08 -08:00
Leijurv	a8ddb2fcf1	also disallow while breaking	2019-02-19 13:28:58 -08:00
Leijurv	76c4ca9ba6	fix path reliability after lateral movement	2019-02-19 12:55:58 -08:00
Leijurv	ed2b0f0bb9	fix jump before place ascend	2019-02-19 12:44:29 -08:00
Leijurv	6702b44b3e	reformatted and fixed stuck on break fall	2019-02-19 12:43:44 -08:00
Leijurv	c486d8241e	continue	2019-02-19 07:53:36 -08:00
Leijurv	d2bb8c374e	explain	2019-02-18 21:18:37 -08:00
Leijurv	530cecea5b	it flows better this way	2019-02-17 21:41:54 -08:00
Leijurv	266e2dada9	cleanup	2019-02-16 20:49:38 -08:00
Leijurv	11af0a7aac	v1.1.5	2019-02-15 21:36:34 -08:00
Leijurv	46c2d8f7c7	unneeded	2019-02-15 21:35:52 -08:00
Leijurv	38127011fb	Merge pull request #336 from babbaj/master Fix potential problems	2019-02-14 14:48:48 -08:00
Leijurv	89b5ce4b63	properly detect failure	2019-02-14 14:47:38 -08:00
babbaj	4fe9c180d5	Fix potential problems	2019-02-14 07:03:22 -05:00
Leijurv	f094e83e4d	codacy	2019-02-13 22:41:18 -08:00
Leijurv	5b6c9fc348	blacklist unreachable gettoblocks	2019-02-13 22:39:43 -08:00
Leijurv	3f1ee100bf	only sprint ascends that are followed in the same direction	2019-02-13 22:39:34 -08:00
Leijurv	41b1106c72	sprint in water for real	2019-02-13 21:20:06 -08:00
Leijurv	b27d95a615	proper fall overshooting	2019-02-13 21:11:13 -08:00
Leijurv	5b8a83853d	add setting to sprint in water	2019-02-13 19:23:16 -08:00
Leijurv	d0548b2715	add a warning	2019-02-13 18:39:26 -08:00
Leijurv	bffeb9c862	forgot one extra check	2019-02-13 18:38:46 -08:00
Leijurv	dbd760fbcb	some polish on ascend sprinting	2019-02-13 18:26:30 -08:00
Leijurv	a84b3bfc7a	sprint through ascends whenever possible, fixes #149	2019-02-13 16:55:08 -08:00
Leijurv	e8d3bf509c	clarify	2019-02-13 16:33:27 -08:00
Leijurv	b2583773d5	discard next segment properly	2019-02-13 16:30:53 -08:00
Leijurv	9ecd24c755	remove toxic cloud	2019-02-13 16:30:41 -08:00
Leijurv	f1bacd6210	fix cancellation of unusable segments	2019-02-13 16:22:49 -08:00
Leijurv	a21ec54d4f	stop breaking block when you let go of left click lol	2019-02-13 14:05:14 -08:00
Leijurv	0b4efb24ae	momentous occasion: turning that crap off	2019-02-13 13:57:33 -08:00
Leijurv	c473914d05	fix flashing backwards, fixes #265	2019-02-13 13:54:50 -08:00
Leijurv	90a1fa8337	lol	2019-02-12 22:06:13 -08:00
Leijurv	99cb7f5142	crucial performance optimization	2019-02-12 21:36:53 -08:00
Leijurv	4026b850f8	dont spam debug chat	2019-02-12 18:34:58 -08:00
Leijurv	aac7ebf6dd	avoid creating callbackinfo at all costs	2019-02-12 18:32:03 -08:00
Leijurv	8d481ba394	lol	2019-02-12 09:58:44 -08:00
Leijurv	24fa75c24e	did someone say more badges	2019-02-11 22:26:49 -08:00
Leijurv	cf38d593b8	thanks leafeon	2019-02-11 22:20:59 -08:00
Leijurv	36f608c63c	add epic gamer address	2019-02-11 19:21:08 -08:00
Leijurv	1d88564a72	clarify this setting since its got a similar name	2019-02-10 16:50:54 -08:00
Leijurv	503f2fb197	direct link to the top of the detail section since its not sorted alphabetically	2019-02-10 16:46:37 -08:00
Leijurv	bb000c4e3f	include diagonals, and better settings	2019-02-10 16:44:09 -08:00
Leijurv	4868ed7560	explain whats going on	2019-02-10 15:12:52 -08:00
Leijurv	7017e9e2ea	crucial performance optimization	2019-02-10 15:10:44 -08:00
Leijurv	a18eb90702	address glaring inconsistency	2019-02-10 13:49:28 -08:00
Leijurv	9d1d4fe0d9	typo	2019-02-10 10:44:04 -08:00
Leijurv	1a430dc2cf	explain	2019-02-09 17:38:42 -08:00
Leijurv	e37a09a1c8	makes mining faster, fixes #330	2019-02-08 12:08:34 -08:00
Leijurv	d0d8b12fb8	add clickCancel, fixes #326	2019-02-07 17:18:14 -08:00
Leijurv	9a29f9ce57	better behavior on arrival and failure	2019-02-07 16:39:15 -08:00
Leijurv	42513e4b56	better check	2019-02-07 16:12:34 -08:00
Leijurv	67fa91abe8	fixes to descend, and goto coords	2019-02-07 15:55:39 -08:00
Leijurv	6faa7344aa	properly discard orphan path segments	2019-02-07 14:11:18 -08:00
Leijurv	c0761c0eef	be more tolerant of alternate movement inputs	2019-02-07 10:46:32 -08:00
Leijurv	46f8829951	v1.1.4	2019-02-07 09:16:19 -08:00
Leijurv	b484e6fa3f	literally disable the entire thing	2019-02-06 21:00:53 -08:00
Leijurv	aa8773a67e	fixes to sprinting through descend and diagonal	2019-02-06 20:54:07 -08:00
Leijurv	bf9ee918f3	5 artifacts and documentation	2019-02-06 12:50:42 -08:00
Leijurv	92ba76e7a1	since all settings are individually final, the class should be too	2019-02-06 10:23:01 -08:00
Leijurv	3326339263	lol that wasnt even right	2019-02-05 22:17:28 -08:00
Leijurv	52cafbc7aa	add a little version thingy	2019-02-05 21:49:09 -08:00
Leijurv	efb316de14	codacy	2019-02-05 18:11:33 -08:00
Leijurv	3cf944398f	😭	2019-02-05 14:03:32 -08:00
Leijurv	d2bfd47039	how to check	2019-02-05 12:41:30 -08:00
Leijurv	920cb6556b	a bit more	2019-02-05 12:38:39 -08:00
Leijurv	cd3ae2a7f5	documentation overhaul	2019-02-05 12:34:29 -08:00
Leijurv	b12fedb2d9	help	2019-02-05 11:08:12 -08:00
Leijurv	1cae7ad6b1	v1.1.3	2019-02-05 09:55:29 -08:00
Leijurv	7dd881aa9a	latest forge works yay	2019-02-05 09:54:17 -08:00
Leijurv	c7ad235110	v1.1.2	2019-02-05 09:38:33 -08:00
Leijurv	a989547976	add proper setting for suppressing clicks	2019-02-05 09:37:42 -08:00
Leijurv	fa75880626	v1.1.1	2019-02-05 08:25:30 -08:00
Leijurv	529895f970	was only needed for freecam anyway	2019-02-05 08:25:14 -08:00
Leijurv	3d5de440fd	what a mess	2019-02-04 21:30:58 -08:00
Leijurv	568bb1b0e8	some forge info	2019-02-04 21:23:19 -08:00
Leijurv	b9ae8306dd	v1.1.0	2019-02-04 20:11:55 -08:00
Leijurv	4aededff46	allow prefix and non prefix control at the same time	2019-02-04 19:57:01 -08:00
Leijurv	ed8f9863e3	spacing 3	2019-02-04 19:37:36 -08:00
Leijurv	e85de55c8f	spacing 2	2019-02-04 19:36:16 -08:00
Leijurv	adbf927270	spacing	2019-02-04 19:35:22 -08:00
Leijurv	dfe171a5c2	forge	2019-02-04 19:34:44 -08:00
Leijurv	b55e449398	extra line	2019-02-04 19:01:50 -08:00
Leijurv	62b11c0a8a	i'm legitimately sorry	2019-02-04 19:01:01 -08:00
Leijurv	90cb11f55e	this is needed	2019-02-04 18:19:51 -08:00
Leijurv	40a66b0306	almost forge support	2019-02-04 18:05:05 -08:00
Leijurv	8c899698e0	explore for blocks, fixes #323	2019-02-04 16:27:32 -08:00
Leijurv	58fa1571f3	added more info	2019-02-04 15:43:02 -08:00
Leijurv	2cbe77aa04	many fixes	2019-02-04 15:24:27 -08:00
Leijurv	a0c2935580	Merge branch 'master' into mega-cancer-rendering	2019-02-04 14:52:30 -08:00
Leijurv	798f25ff81	dont glitch weirdly when failing a parkour jump	2019-02-04 13:52:11 -08:00
Leijurv	57b2e360ca	dont include current movement cost while deciding when to plan ahead	2019-02-04 13:27:35 -08:00
Leijurv	ee23d59e11	now we can cache flowing water properly	2019-02-04 13:07:56 -08:00
Leijurv	04e7da9b73	lower walk into can be water, but not upper	2019-02-04 13:07:05 -08:00
Leijurv	5382d265f2	crucial performance optimization	2019-02-03 19:46:59 -08:00
Leijurv	0e1534613c	appease codacy	2019-02-03 19:34:29 -08:00
Leijurv	d799fac688	epicer gradle output	2019-02-03 19:27:28 -08:00
Leijurv	913247996e	smh my head. who right clicks gradle tasks??	2019-02-02 14:23:01 -08:00
Leijurv	dc3bab26de	6 months =D	2019-02-01 22:54:14 -08:00
Leijurv	5c1cf050e2	im idiot	2019-01-31 20:27:14 -08:00
Leijurv	747bee41b7	holding control shouldnt make all bots sprint	2019-01-31 20:26:24 -08:00
Leijurv	246c00c773	dont repeat that	2019-01-31 19:19:44 -08:00
Leijurv	b953da0341	more accurate isEmpty	2019-01-30 12:19:15 -08:00
Leijurv	c2a6445c9e	Merge branch 'master' into mega-cancer-rendering	2019-01-30 12:07:58 -08:00
Leijurv	b177ae7ee6	proguard can just ignore GL14 reference actually	2019-01-30 11:57:54 -08:00
Leijurv	8947eff3b1	bsi might be old	2019-01-30 11:42:46 -08:00
Brady	06b3c5ddb5	LeijurvUtils	2019-01-30 12:42:26 -06:00
Leijurv	1968f47fc9	add a setting to play with	2019-01-29 19:44:23 -08:00
Leijurv	6a2cd9d3ba	Merge branch 'master' into mega-cancer-rendering	2019-01-29 13:55:00 -08:00
Leijurv	9028564c10	only when the setting is enabled	2019-01-29 13:54:54 -08:00
Brady	b471d7419e	Replace most of the @Inject usages for cancer render with @Redirect	2019-01-29 12:41:14 -06:00
Leijurv	5179cfc5ba	semitransparency working	2019-01-28 21:28:26 -08:00
Leijurv	784b2f541d	lol	2019-01-28 19:02:07 -08:00
Leijurv	735cf47c35	actually works	2019-01-28 17:34:14 -08:00
Leijurv	b005ce8e6b	mega cancer render cached chunks	2019-01-17 18:54:37 -08:00