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
39 changed files with 654 additions and 236 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/)
@@ -30,6 +32,8 @@ the original version of the bot for Minecraft 1.8, rebuilt for 1.12.2. Baritone

 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)
@@ -40,16 +44,11 @@ Here are some links to help to get started:

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

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

-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.
-
-On v1.1.0 and newer: Put a `#` in front so that if you make a typo it doesn't go into public chat (anything beginning with `#` isn't sent).
-
-For older than v1.1.0, `#` must be enabled by toggling on the `prefix` setting.
-
-**Only** in Impact is `.b` also a valid prefix
+- [Baritone chat control usage](USAGE.md)

 # API example

@@ -64,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,14 +1,31 @@
 # Setup

 ## Prebuilt
-[Releases](https://github.com/cabaletta/baritone/releases)
+(not always completely up to date with latest features)

-Not always completely up to date with latest features.
+Download from the [Releases](https://github.com/cabaletta/baritone/releases)

-The forge release (currently `baritone-forge-1.1.3.jar`) can simply be added as a Forge mod.
+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

@@ -75,16 +92,4 @@ $ gradlew build

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

- Double click on **build** to run it
-
-## Artifacts
-
-Building Baritone will result in 4 artifacts created in the ``dist`` directory.
-
- **Forge**: Forge mod
- **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.1.3'
+version '1.1.6'

 buildscript {
    repositories {
@@ -116,7 +116,10 @@ jar {
 jar {
    manifest {
        attributes(
-                'MixinConfigs': 'mixins.baritone.json'
+                'MixinConfigs': 'mixins.baritone.json',
+
+                'Implementation-Title': 'Baritone',
+                'Implementation-Version': version
        )
    }
 }
--- 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,28 +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_FORGE       = "%s-forge-%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, artifactForgePath, 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.artifactForgePath       = this.getBuildFile(formatVersion(ARTIFACT_FORGE));
+        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);

@@ -97,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,10 +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 forge       = getRelativeFile("dist/" + formatVersion(ARTIFACT_FORGE));
+        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/");
@@ -54,13 +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.artifactForgePath,       forge,       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, forge)
+        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
@@ -73,7 +73,6 @@ public class ProguardTask extends BaritoneGradleTask {
        acquireDependencies();
        proguardApi();
        proguardStandalone();
-        createForge();
        cleanup();
    }

@@ -274,15 +273,13 @@ public class ProguardTask extends BaritoneGradleTask {
    private void proguardApi() throws Exception {
        runProguard(getTemporaryFile(PROGUARD_API_CONFIG));
        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(), Optional.empty());
-    }
-
-    private void createForge() throws Exception {
-        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgePath.toString(), Optional.of(mixin));
+        Determinizer.determinize(this.proguardOut.toString(), this.artifactForgeStandalonePath.toString(), Optional.of(mixin));
    }

    private void cleanup() {
--- 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
@@ -460,7 +479,18 @@ public final class Settings {
    public final Setting<Boolean> pathThroughCachedOnly = new Setting<>(false);

    /**
-     * 😎 Render cached chunks as semitransparent.
+     * 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
@@ -551,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
@@ -667,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/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
@@ -22,27 +22,31 @@ 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.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.Redirect;

 import static org.lwjgl.opengl.GL11.*;

@Mixin(ChunkRenderContainer.class)
 public class MixinChunkRenderContainer {

-    @Inject(
+    @Redirect( // avoid creating CallbackInfo at all costs; this is called 40k times per second
            method = "preRenderChunk",
-            at = @At("HEAD")
+            at = @At(
+                    value = "INVOKE",
+                    target = "net/minecraft/client/renderer/chunk/RenderChunk.getPosition()Lnet/minecraft/util/math/BlockPos;"
+            )
    )
-    private void preRenderChunk(RenderChunk renderChunkIn, CallbackInfo ci) {
+    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/MixinKeyBinding.java
+++ b/src/launch/java/baritone/launch/mixins/MixinKeyBinding.java
@@ -20,6 +20,7 @@ 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;
@@ -61,6 +62,11 @@ 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 (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.");
--- a/src/launch/java/baritone/launch/mixins/MixinRenderList.java
+++ b/src/launch/java/baritone/launch/mixins/MixinRenderList.java
@@ -22,25 +22,25 @@ 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.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.Redirect;

 import static org.lwjgl.opengl.GL11.*;

@Mixin(RenderList.class)
 public class MixinRenderList {

-    @Inject(
+    @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 renderChunkLayer(CallbackInfo info) {
+    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
@@ -22,25 +22,25 @@ 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.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.Redirect;

 import static org.lwjgl.opengl.GL11.*;

@Mixin(VboRenderList.class)
 public class MixinVboRenderList {

-    @Inject(
+    @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 renderChunkLayer(CallbackInfo info) {
+    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/main/java/baritone/Baritone.java
+++ b/src/main/java/baritone/Baritone.java
@@ -92,6 +92,7 @@ public class Baritone implements IBaritone {
        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,7 +201,7 @@ public final class PathingBehavior extends Behavior implements IPathingBehavior,
                    // and this path doesn't get us all the way there
                    return;
                }
-                if (ticksRemainingInSegment(false).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
@@ -298,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
@@ -335,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;
            }
        }
@@ -375,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;
                    }
                }
@@ -384,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();
                }
            }
@@ -438,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
@@ -449,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/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
@@ -50,7 +50,9 @@ public final class GameEventHandler implements IEventBus, Helper {
        if (event.getType() == TickEvent.Type.IN) {
            try {
                baritone.bsi = new BlockStateInterface(baritone.getPlayerContext(), true);
-            } catch (Exception ex) {}
+            } catch (Exception ex) {
+                baritone.bsi = null;
+            }
        } else {
            baritone.bsi = null;
        }
--- 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;
@@ -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/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();
--- 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;
            }
        }
@@ -388,17 +385,34 @@ public class PathExecutor implements IPathExecutor, Helper {
        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 doesn't request sprinting, beceause it doesn't know the context of what movement comes after it
-        IMovement current = path.movements().get(pathPosition);
+        // 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;
            }
@@ -408,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();
@@ -432,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
@@ -32,15 +32,13 @@ 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;
@@ -54,6 +52,7 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
        onLostControl();
        gettingTo = block;
        start = ctx.playerFeet();
+        blacklist = new ArrayList<>();
        rescan(new ArrayList<>(), new CalculationContext(baritone));
    }

@@ -63,12 +62,12 @@ 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()) {
+            if (Baritone.settings().exploreForBlocks.get() && !calcFailed) {
                return new PathingCommand(new GoalRunAway(1, start) {
                    @Override
                    public boolean isInGoal(int x, int y, int z) {
@@ -82,12 +81,19 @@ public class GetToBlockProcess extends BaritoneProcessHelper implements IGetToBl
            }
            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
@@ -95,25 +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();
    }

@@ -122,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
@@ -88,14 +88,12 @@ public class ExampleBaritoneControl extends Behavior implements Helper {
    @Override
    public void onSendChatMessage(ChatEvent event) {
        String msg = event.getMessage();
-        if (Baritone.settings().prefixControl.get()) {
-            if (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().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;
@@ -165,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);
@@ -229,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;
@@ -246,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;
        }
@@ -462,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 {
@@ -541,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